diff --git a/src/note-c/.devcontainer/devcontainer.json b/src/note-c/.devcontainer/devcontainer.json
new file mode 100644
index 0000000..a1b99f3
--- /dev/null
+++ b/src/note-c/.devcontainer/devcontainer.json
@@ -0,0 +1,39 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.205.2/containers/docker-existing-dockerfile
+{
+    "name": "Note-C Development Environment Dockerfile",
+
+    // Sets the run context to one level up instead of the .devcontainer folder.
+    "context": "..",
+
+    // Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
+    "image": "ghcr.io/blues/note_c_ci:latest",
+    // "dockerFile": "../Dockerfile",
+
+    // Set *default* container specific settings.json values on container create.
+    "settings": {},
+
+    // Add the IDs of extensions you want installed when the container is created.
+    "extensions": [
+        "ms-vscode.cpptools",
+        "shardulm94.trailing-spaces",
+        "twxs.cmake"
+    ],
+
+    // Use 'forwardPorts' to make a list of ports inside the container available locally.
+    // "forwardPorts": [],
+
+    // Uncomment the next line to run commands after the container is created - for example installing curl.
+    // "postCreateCommand": "apt-get update && apt-get install -y curl",
+
+    // Uncomment when using a ptrace-based debugger like C++, Go, and Rust
+    // "runArgs": [
+    //     "--device=/dev/bus/usb/"
+    // ],
+
+    // Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker.
+    // "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ],
+
+    // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
+    "remoteUser": "blues"
+}
diff --git a/src/note-c/.github/actions/load-ci-image/action.yml b/src/note-c/.github/actions/load-ci-image/action.yml
new file mode 100644
index 0000000..7e1bc73
--- /dev/null
+++ b/src/note-c/.github/actions/load-ci-image/action.yml
@@ -0,0 +1,17 @@
+name: 'Load note-c CI Docker image'
+runs:
+  using: 'composite'
+  steps:
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+
+    - name: Download image artifact
+      uses: actions/download-artifact@v3
+      with:
+        name: note_c_ci_image
+        path: /tmp
+
+    - name: Load Docker image
+      shell: bash
+      run: |
+        docker load --input /tmp/note_c_ci_image.tar
diff --git a/src/note-c/.github/workflows/ci.yml b/src/note-c/.github/workflows/ci.yml
new file mode 100644
index 0000000..01ac6e9
--- /dev/null
+++ b/src/note-c/.github/workflows/ci.yml
@@ -0,0 +1,183 @@
+name: note-c CI Pipeline
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  check_dockerfile_changed:
+    runs-on: ubuntu-latest
+    outputs:
+      changed: ${{ steps.filter.outputs.changed }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      # TODO: This is a 3rd party GitHub action from some dude. Ideally, we'd
+      #       use something more "official".
+      - name: Check if Dockerfile changed
+        uses: dorny/paths-filter@v2
+        id: filter
+        with:
+          base: 'master'
+          filters: |
+            changed:
+              - 'Dockerfile'
+
+  build_ci_docker_image:
+    runs-on: ubuntu-latest
+    needs: [check_dockerfile_changed]
+    if: ${{ needs.check_dockerfile_changed.outputs.changed == 'true' }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Rebuild image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          load: true
+          tags: ghcr.io/blues/note_c_ci:latest
+          outputs: type=docker,dest=/tmp/note_c_ci_image.tar
+
+      - name: Upload image artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: note_c_ci_image
+          path: /tmp/note_c_ci_image.tar
+
+  build_docs:
+    runs-on: ubuntu-latest
+    if: ${{ always() }}
+    needs: [build_ci_docker_image]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Load CI Docker image
+        # Only load the Docker image artifact if build_ci_docker_image actually
+        # ran (e.g. it wasn't skipped and was successful).
+        if: ${{ needs.build_ci_docker_image.result == 'success' }}
+        uses: ./.github/actions/load-ci-image
+
+      - name: Build docs
+        run: |
+          docker run --rm --volume $(pwd):/note-c/ --workdir /note-c/ --entrypoint ./scripts/build_docs.sh ghcr.io/blues/note_c_ci:latest
+
+  check_libc_dependencies:
+    runs-on: ubuntu-latest
+    if: ${{ always() }}
+    needs: [build_ci_docker_image]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Load CI Docker image
+        # Only load the Docker image artifact if build_ci_docker_image actually
+        # ran (e.g. it wasn't skipped and was successful).
+        if: ${{ needs.build_ci_docker_image.result == 'success' }}
+        uses: ./.github/actions/load-ci-image
+
+      - name: Check note-c's libc dependencies
+        run: |
+          docker run --rm --volume $(pwd):/note-c/ --workdir /note-c/ --entrypoint ./scripts/check_libc_dependencies.sh ghcr.io/blues/note_c_ci:latest
+
+  run_unit_tests:
+    runs-on: ubuntu-latest
+    if: ${{ always() }}
+    needs: [build_ci_docker_image]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Load CI Docker image
+        if: ${{ needs.build_ci_docker_image.result == 'success' }}
+        uses: ./.github/actions/load-ci-image
+
+      - name: Run tests
+        run: |
+          docker run --rm --volume $(pwd):/note-c/ --workdir /note-c/ --entrypoint ./scripts/run_unit_tests.sh ghcr.io/blues/note_c_ci:latest --coverage --mem-check
+
+      - name: Adjust lcov source file paths for Coveralls
+        run: sudo sed -i 's/\/note-c\///g' ./build/test/coverage/lcov.info
+
+      - name: Publish test coverage
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path-to-lcov: ./build/test/coverage/lcov.info
+
+  run_low_mem_unit_tests:
+    runs-on: ubuntu-latest
+    if: ${{ always() }}
+    needs: [build_ci_docker_image]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Load CI Docker image
+        if: ${{ needs.build_ci_docker_image.result == 'success' }}
+        uses: ./.github/actions/load-ci-image
+
+      - name: Run tests with NOTE_LOWMEM defined
+        run: |
+          docker run --rm --volume $(pwd):/note-c/ --workdir /note-c/ --entrypoint ./scripts/run_unit_tests.sh ghcr.io/blues/note_c_ci:latest --mem-check --low-mem --single-precision
+
+  run_astyle:
+    runs-on: ubuntu-latest
+    if: ${{ always() }}
+    needs: [build_ci_docker_image]
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Load CI Docker image
+        if: ${{ needs.build_ci_docker_image.result == 'success' }}
+        uses: ./.github/actions/load-ci-image
+
+      - name: Run astyle
+        run: |
+          docker run --rm --volume $(pwd):/note-c/ --workdir /note-c/ --entrypoint ./scripts/run_astyle.sh ghcr.io/blues/note_c_ci:latest
+
+  publish_ci_image:
+    runs-on: ubuntu-latest
+    # Make sure unit tests unit tests passed before publishing.
+    needs: [build_ci_docker_image, run_unit_tests]
+    # Only publish the image if this is a push event and the Docker image was rebuilt
+    if: ${{ github.event_name == 'push' && needs.build_ci_docker_image.result == 'success' }}
+
+    steps:
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Push image to registry
+        uses: docker/build-push-action@v4
+        with:
+          push: true
+          tags: ghcr.io/blues/note_c_ci:latest
diff --git a/src/note-c/.github/workflows/md5srv-tests.yml b/src/note-c/.github/workflows/md5srv-tests.yml
new file mode 100644
index 0000000..51cbb24
--- /dev/null
+++ b/src/note-c/.github/workflows/md5srv-tests.yml
@@ -0,0 +1,42 @@
+name: MD5 Server Tests
+
+on:
+  workflow_dispatch:
+  workflow_call:  # reusable workflow
+
+jobs:
+  test-md5srv: # job id
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    env:
+        TERM: xterm-256color
+        MD5SRV_TIMEOUT: 5
+        MD5SRV_DIR: ./test/hitl/scripts
+        BATS_VERSION: 1.10.0
+        BATS_LIB_PATH: /usr/lib
+        # /usr/local/lib on OSX
+    steps:
+      - name: Setup Bats and bats libs
+        uses: brokenpip3/setup-bats-libs@1.0.0
+        with:
+            bats-install: true
+            file-install: false
+            detik-install: false
+      - name: Setup BATS_LIB_PATH
+        run: |
+          if [ -e /usr/local/lib/bats-support ]; then
+            echo "BATS_LIB_PATH=/usr/local/lib" >> $GITHUB_ENV
+          fi
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Run Tests
+        run: |
+            cd ${{env.MD5SRV_DIR}}
+            $HOME/.local/bin/bats -p --print-output-on-failure .
+      - name: Rerun Tests
+        if: failure()
+        run: |
+          cd ${{env.MD5SRV_DIR}}
+          $HOME/.local/bin/bats -p --print-output-on-failure -x .
diff --git a/src/note-c/.github/workflows/notecard-binary-tests.yml b/src/note-c/.github/workflows/notecard-binary-tests.yml
new file mode 100644
index 0000000..a967dcf
--- /dev/null
+++ b/src/note-c/.github/workflows/notecard-binary-tests.yml
@@ -0,0 +1,221 @@
+name: Note Binary CI
+
+on:
+  pull_request:
+    branches: [ master ]
+  workflow_dispatch:
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    - cron:  '45 4 * * 1'  # 4.45am every Monday
+
+permissions:
+  checks: write
+
+jobs:
+  md5srv-test:
+     uses: ./.github/workflows/md5srv-tests.yml
+
+  notecard-binary-test:
+    # needs: md5srv-test
+    runs-on: [self-hosted, swan, notecard, stlink, notecard-serial, md5srv, notehub-client]
+    defaults:
+      run:
+        shell: bash
+    env:
+        NOTEHUB: "notehub.io"
+        NOTEHUB_API: "api.notefile.net"
+        NOTEHUB_ROUTE_TIMEOUT: 180
+        PIO_PROJECT_DIR: ./test/hitl/card.binary
+        NOTEHUB_PROXY_ROUTE_ALIAS: card.binary.${{github.run_id}}
+        NOTEHUB_PROXY_ROUTE_LABEL: card.binary.proxy.${{github.run_id}}
+        NOTEHUB_HTTP_ROUTE_LABEL: card.binary.http.${{github.run_id}}
+
+        # Troubleshooting helpers
+        # DELETE_NOTEHUB_ROUTES set to false to see the created routes on notehub
+        DELETE_NOTEHUB_ROUTES: true
+        # CREATE_NOTEHUB_ROUTES set to false to use the already created routes on notehub
+        CREATE_NOTEHUB_ROUTES: true
+        # FLASH_TEST_FIRMWARE set to false to skip flashing firmware to the Host (Swan).
+        # Be sure to press reset on Swan before running the workflow unless you deliberately want to skip running the tests.
+        FLASH_TEST_FIRMWARE: true
+        # START_MD5SRV set to false to skip starting the MD5 server. There should be one
+        # already running locally with MD5SRV_PORT/ADDRESS/TOKEN set correspondingly.
+        START_MD5SRV: true
+        # START_TUNNELMOLE: set to false to skip starting tunnel mole.
+        START_TUNNELMOLE: true
+        # When neither tunneling solution is used (because they're already instantiated outside of the workflow)
+        # be sure to set MD5SRV_URL in the environment
+    steps:
+      - name: Checkout note-c repo
+        uses: actions/checkout@v3
+
+      - name: Generate MD5 Server Token
+        run: |
+          [ -n "$MD5SRV_TOKEN" ] || echo "MD5SRV_TOKEN=`uuidgen`" >> $GITHUB_ENV
+          # propagate the environment variable so that it's available in the `env` context
+          echo "MD5SRV_PORT=$MD5SRV_PORT" >> $GITHUB_ENV
+
+      - name: Check env vars
+        run: |
+          . scripts/check_runner_config.sh
+          echo NOTEHUB_PROXY_ROUTE_ALIAS=$NOTEHUB_PROXY_ROUTE_ALIAS
+
+      - name: Install PlatformIO dependencies
+        if: env.FLASH_TEST_FIRMWARE!='false'
+        run: |
+          python3 -m venv venv    # python venv is also used by the md5server, so this comes first.
+          source venv/bin/activate
+          pip install platformio
+          cd $PIO_PROJECT_DIR
+          pio pkg install -l "Blues Wireless Notecard" -e debug
+          # Remove the bundled note-c and put the local working copy there
+          NOTE_C_DEP="$GITHUB_WORKSPACE/$PIO_PROJECT_DIR/.pio/libdeps/debug/Blues Wireless Notecard/src/note-c"
+          rm -rf "$NOTE_C_DEP"
+          mkdir "$NOTE_C_DEP"
+          # copy only files in note-c
+          find "$GITHUB_WORKSPACE" -maxdepth 1 -type f -exec cp "{}" "${NOTE_C_DEP}" \;
+
+      - name: Start MD5 server
+        run: |
+          mkdir md5srv-files
+          ./scripts/run_md5srv.sh
+
+      - name: Build and upload test firmware
+        if: env.FLASH_TEST_FIRMWARE!='false'
+        run: |
+          source venv/bin/activate
+          export PLATFORMIO_BUILD_FLAGS="'-D NOTEHUB_PROXY_ROUTE_ALIAS=\"$NOTEHUB_PROXY_ROUTE_ALIAS\"' '-D PRODUCT_UID=\"$NOTEHUB_PRODUCT_UID\"'"
+          echo "build flags $PLATFORMIO_BUILD_FLAGS"
+          timeout 10 ./scripts/wait_for_file.sh "$STLINK_PROGRAMMER_PORT"
+          platformio test -e debug --without-testing --upload-port "$STLINK_PROGRAMMER_PORT" --project-dir "$PIO_PROJECT_DIR"
+          timeout 10 ./scripts/wait_for_file.sh "$SWAN_SERIAL"
+
+      - name: Start tunnelmole
+        if: env.START_TUNNELMOLE!='false'
+        run: |
+          rm -f tmole.log
+          ./scripts/run_tunnelmole.sh
+
+      - name: Check MD5 server is available
+        run: |
+          # the request will return a 401 from md5srv, but that's expected without the access token
+          # Curl still returns success because it could contact the server
+          code=`curl -s -o /dev/null -w "%{http_code}" $MD5SRV_URL`
+          if [ "$code" -ge "500" ]; then
+            echo "5xx error ($code) from tunnel."
+            exit 1
+          else
+            echo "MD5 server is available."
+          fi
+
+      - name: Create Notehub accesss token
+        if: env.CREATE_NOTEHUB_ROUTES!='false'
+        run: |
+          curl -f -X POST \
+            -L 'https://${{env.NOTEHUB}}/oauth2/token' \
+            -H 'content-type: application/x-www-form-urlencoded' \
+            -d grant_type=client_credentials \
+            -d client_id=$NOTEHUB_CLIENT_ID \
+            -d client_secret=$NOTEHUB_CLIENT_SECRET | \
+            { token=$(jq -r .access_token); echo "NOTEHUB_ACCESS_TOKEN=$token" >> $GITHUB_ENV; }
+
+      - name: Create Notehub HTTP route
+        if: env.CREATE_NOTEHUB_ROUTES!='false'
+        run: |
+          # ?note=1 instructs the MD5 server to process the content as an event, extracting the path
+          # from the event body.
+          route_req=`jq -n --arg TOKEN "$MD5SRV_TOKEN" --arg LABEL "$NOTEHUB_HTTP_ROUTE_LABEL" --arg URL "$MD5SRV_URL/?note=1" --argjson TIMEOUT $NOTEHUB_ROUTE_TIMEOUT \
+            '{ "label":$LABEL, "type":"http", "http":{ "timeout":$TIMEOUT, "filter": { "type":"include", "files": ["cardbinary.qo"] }, "url":$URL, "http_headers": { "X-Access-Token":$TOKEN } } }'`
+          echo "Notehub HTTP route request: $route_req"
+          route=`echo "$route_req" | curl -s -f -X POST -L "https://$NOTEHUB_API/v1/projects/${NOTEHUB_PROJECT_UID}/routes" \
+                  -H "Authorization: Bearer $NOTEHUB_ACCESS_TOKEN" -d @-`
+          echo "Notehub HTTP route: $route"
+          route_uid=`echo $route | jq -r .uid`
+          if [ -n "$route_uid" ]; then
+            echo "NOTEHUB_HTTP_ROUTE_UID=$route_uid" >> $GITHUB_ENV
+          else
+            echo "Failed to create or parse Notehub HTTP route."
+            exit 1
+          fi
+
+      - name: Create Notehub proxy route
+        run: |
+          ALIAS="$NOTEHUB_PROXY_ROUTE_ALIAS"
+          route=`jq -n --arg TOKEN "$MD5SRV_TOKEN" --arg LABEL "$NOTEHUB_PROXY_ROUTE_LABEL" --arg URL "$MD5SRV_URL" --arg ALIAS "$ALIAS" --argjson TIMEOUT $NOTEHUB_ROUTE_TIMEOUT \
+            '{ "label":$LABEL, "type":"proxy", "proxy":{ "timeout":$TIMEOUT, "url":$URL, "alias":$ALIAS, "http_headers": { "X-Access-Token":$TOKEN } } }' \
+            | curl -s -f -X POST -L "https://api.notefile.net/v1/projects/${NOTEHUB_PROJECT_UID}/routes" \
+                  -H "Authorization: Bearer $NOTEHUB_ACCESS_TOKEN" -d @-`
+          echo "Notehub proxy route: $route"
+          route_uid=`echo "$route" | jq -r .uid`
+          if [ -n $route_uid ]; then
+            echo "NOTEHUB_PROXY_ROUTE_UID=$route_uid" >> $GITHUB_ENV
+            echo "NOTEHUB_PROXY_ROUTE_ALIAS=$ALIAS" >> $GITHUB_ENV
+          else
+            echo "Failed to create or parse Notehub proxy route."
+            exit 1
+          fi
+
+      - name: Run tests
+        run: |
+          source venv/bin/activate
+          cd $PIO_PROJECT_DIR
+          platformio test -v -e debug \
+             --without-building --without-uploading \
+             --test-port "$SWAN_SERIAL" \
+             --json-output-path test.json \
+             --junit-output-path test.xml
+
+      - name: Publish test report
+        uses: mikepenz/action-junit-report@v3
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        if: env.GITHUB_TOKEN && (success() || failure()) # always run even if the previous step fails
+        with:
+          report_paths: '**/test/hitl/card.binary/test*.xml'
+          check_name: Notecard Binary HIL Tests
+          require_tests: true
+
+      - name: Cleanup Notehub proxy route
+        if: always()
+        run: |
+          if [ "$DELETE_NOTEHUB_ROUTES" == "true" && -n "$NOTEHUB_PROXY_ROUTE_UID" ]; then
+            echo "Deleting Notehub proxy route."
+            curl -f -s -X DELETE \
+              -L "https://api.notefile.net/v1/projects/$NOTEHUB_PROJECT_UID/routes/$NOTEHUB_PROXY_ROUTE_UID" \
+              -H "Authorization: Bearer $NOTEHUB_ACCESS_TOKEN"
+          fi
+
+      - name: Cleanup Notehub HTTP route
+        if: always()
+        run: |
+          if [ "$DELETE_NOTEHUB_ROUTES" == "true" ] && [ -n "$NOTEHUB_HTTP_ROUTE_UID" ]; then
+            echo "Deleting Notehub HTTP route."
+            curl -f -s -X DELETE \
+              -L "https://$NOTEHUB_API/v1/projects/$NOTEHUB_PROJECT_UID/routes/$NOTEHUB_HTTP_ROUTE_UID" \
+              -H "Authorization: Bearer $NOTEHUB_ACCESS_TOKEN"
+          fi
+
+
+      - name: Cleanup tunnelmole
+        if: always()
+        run: |
+          if [ -n "$TMOLE_PID" ]; then
+            echo "Stopping tunnelmole."
+            kill $TMOLE_PID
+          else
+            echo "Tunnelmole not running (TMOLE_PID is empty)."
+          fi
+
+      - name: Cleanup MD5 server
+        if: always()
+        run: |
+          if [ -d md5srv-files ]; then
+            echo "Deleting md5srv-files directory."
+            rm -rf md5srv-files
+          fi
+          if [ -n "$MD5SRV_PID" ]; then
+            echo "Stopping MD5 server."
+            kill $MD5SRV_PID
+          else
+            echo "MD5 server not running (MD5SRV_PID is empty)."
+          fi
diff --git a/src/note-c/.github/workflows/publish_docs_site.yml b/src/note-c/.github/workflows/publish_docs_site.yml
new file mode 100644
index 0000000..b367659
--- /dev/null
+++ b/src/note-c/.github/workflows/publish_docs_site.yml
@@ -0,0 +1,40 @@
+name: Publish note-c docs site
+
+on:
+  push:
+    branches: [ master ]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  publish_docs_site:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v3
+
+      - name: Install Python dependencies
+        run: |
+          pip install sphinx sphinx_rtd_theme breathe
+
+      - name: Install other dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake doxygen
+
+      - name: Build docs site
+        # The TZ=UTC thing is a workaround for this problem:
+        # https://github.com/nektos/act/issues/1853
+        run: |
+          TZ=UTC ./scripts/build_docs.sh
+
+      - name: Deploy docs site to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v3
+        if: ${{ github.event_name == 'push' }}
+        with:
+          publish_branch: gh-pages
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: build/docs/
+          force_orphan: true
diff --git a/src/note-c/.gitignore b/src/note-c/.gitignore
new file mode 100644
index 0000000..9552ba0
--- /dev/null
+++ b/src/note-c/.gitignore
@@ -0,0 +1,10 @@
+.DS_Store
+Doxyfile.bak
+latex/
+html/
+__pycache__/
+
+# VS Code workspace files
+*.code-workspace
+*.orig
+settings.json
diff --git a/src/note-c/.vscode/extensions.json b/src/note-c/.vscode/extensions.json
new file mode 100644
index 0000000..363da33
--- /dev/null
+++ b/src/note-c/.vscode/extensions.json
@@ -0,0 +1,9 @@
+{
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
+    "unwantedRecommendations": [
+        "ms-vscode.cmake-tools",
+        "ms-vscode.cpptools-extension-pack",
+        "ms-azuretools.vscode-docker"
+    ]
+}
diff --git a/src/note-c/.vscode/tasks.json b/src/note-c/.vscode/tasks.json
new file mode 100644
index 0000000..14ad13a
--- /dev/null
+++ b/src/note-c/.vscode/tasks.json
@@ -0,0 +1,58 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Note-C: Compile and Run ALL Tests",
+            "type": "cppbuild",
+            "command": "./scripts/run_unit_tests.sh",
+            "args": [],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "Note-C: Compile and Run ALL Tests (with coverage and memory check)",
+            "type": "cppbuild",
+            "command": "./scripts/run_unit_tests.sh",
+            "args": [
+                "--coverage",
+                "--mem-check"
+            ],
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": false
+            }
+        },
+        {
+            "label": "Note-C: Run `astyle` Formatter",
+            "type": "shell",
+            "command": "./scripts/run_astyle.sh",
+            "args": [],
+            "options": {
+                "cwd": "${workspaceFolder}",
+                "env": {
+                    "LC_ALL":"C"
+                }
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "none"
+            }
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/note-c/CMakeLists.txt b/src/note-c/CMakeLists.txt
new file mode 100644
index 0000000..449cbdb
--- /dev/null
+++ b/src/note-c/CMakeLists.txt
@@ -0,0 +1,125 @@
+cmake_minimum_required(VERSION 3.13)
+
+if ("${CMAKE_BINARY_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
+    message(FATAL_ERROR "In-source builds are not allowed.
+    Please create a build directory and use `cmake ..` inside it.
+    NOTE: cmake will now create CMakeCache.txt and CMakeFiles/*.
+          You must delete them, or cmake will refuse to work.")
+endif()
+
+project(note_c)
+
+# Automatically ignore CMake build directory.
+if(NOT EXISTS ${PROJECT_BINARY_DIR}/.gitignore)
+    file(WRITE ${PROJECT_BINARY_DIR}/.gitignore "*")
+endif()
+
+option(NOTE_C_BUILD_TESTS "Build tests." OFF)
+option(NOTE_C_COVERAGE "Compile for test NOTE_C_COVERAGE reporting." OFF)
+option(NOTE_C_MEM_CHECK "Run tests with Valgrind." OFF)
+option(NOTE_C_BUILD_DOCS "Build docs." OFF)
+option(NOTE_C_NO_LIBC "Build the library without linking against libc, generating errors for any undefined symbols." OFF)
+option(NOTE_C_LOW_MEM "Build the library tailored for low memory usage." OFF)
+option(NOTE_C_TEST_SINGLE_PRECISION "Use single precision for JSON floating point numbers." OFF)
+
+set(NOTE_C_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+add_library(note_c SHARED)
+target_sources(
+    note_c
+    PRIVATE
+        ${NOTE_C_SRC_DIR}/n_atof.c
+        ${NOTE_C_SRC_DIR}/n_b64.c
+        ${NOTE_C_SRC_DIR}/n_cjson.c
+        ${NOTE_C_SRC_DIR}/n_cjson_helpers.c
+        ${NOTE_C_SRC_DIR}/n_cobs.c
+        ${NOTE_C_SRC_DIR}/n_const.c
+        ${NOTE_C_SRC_DIR}/n_ftoa.c
+        ${NOTE_C_SRC_DIR}/n_helpers.c
+        ${NOTE_C_SRC_DIR}/n_hooks.c
+        ${NOTE_C_SRC_DIR}/n_i2c.c
+        ${NOTE_C_SRC_DIR}/n_md5.c
+        ${NOTE_C_SRC_DIR}/n_printf.c
+        ${NOTE_C_SRC_DIR}/n_request.c
+        ${NOTE_C_SRC_DIR}/n_serial.c
+        ${NOTE_C_SRC_DIR}/n_str.c
+)
+target_compile_options(
+    note_c
+    PRIVATE
+        -Wall
+        -Wextra
+        -Wpedantic
+        -Werror
+        -Og
+        -ggdb
+)
+target_include_directories(
+    note_c
+    PUBLIC ${NOTE_C_SRC_DIR}
+)
+
+if(NOTE_C_LOW_MEM)
+    target_compile_definitions(
+        note_c
+        PUBLIC
+            NOTE_C_LOW_MEM
+    )
+else()
+    # This file is empty if NOTE_C_LOW_MEM is defined, which leads to a warning
+    # about an empty translation unit, so we only add it to the build if
+    # NOTE_C_LOW_MEM is false.
+    target_sources(
+        note_c
+        PRIVATE
+            ${NOTE_C_SRC_DIR}/n_ua.c
+    )
+endif()
+
+if(NOTE_C_NO_LIBC)
+    target_link_options(
+        note_c
+        PRIVATE
+            -nostdlib
+            -nodefaultlibs
+            LINKER:--no-undefined
+    )
+endif()
+
+if(NOTE_C_TEST_SINGLE_PRECISION)
+    target_compile_definitions(
+        note_c
+        PUBLIC
+            NOTE_C_TEST_SINGLE_PRECISION
+    )
+endif()
+
+if(NOTE_C_BUILD_TESTS)
+    # Including CTest here rather than in test/CMakeLists.txt allows us to run
+    # ctest from the root build directory (e.g. build/ instead of build/test/).
+    # We also need to set MEMORYCHECK_COMMAND_OPTIONS before including this.
+    # See: https://stackoverflow.com/a/60741757
+    if(NOTE_C_MEM_CHECK)
+        # Go ahead and make sure we can find valgrind while we're here.
+        find_program(VALGRIND valgrind REQUIRED)
+        message(STATUS "Found valgrind: ${VALGRIND}")
+        set(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1")
+    endif(NOTE_C_MEM_CHECK)
+    include(CTest)
+
+    target_compile_definitions(
+        note_c
+        PUBLIC
+            NOTE_C_TEST
+    )
+    target_include_directories(
+        note_c
+        PRIVATE
+            ${CMAKE_CURRENT_LIST_DIR}/test/include
+    )
+
+    add_subdirectory(test)
+endif(NOTE_C_BUILD_TESTS)
+
+if(NOTE_C_BUILD_DOCS)
+    add_subdirectory(docs)
+endif(NOTE_C_BUILD_DOCS)
diff --git a/src/note-c/CODE_OF_CONDUCT.md b/src/note-c/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..50838cf
--- /dev/null
+++ b/src/note-c/CODE_OF_CONDUCT.md
@@ -0,0 +1,7 @@
+# Code of conduct
+
+By participating in this project, you agree to abide by the
+[Blues Inc code of conduct][1].
+
+[1]: https://blues.github.io/opensource/code-of-conduct
+
diff --git a/src/note-c/CONTRIBUTING.md b/src/note-c/CONTRIBUTING.md
new file mode 100644
index 0000000..39410cb
--- /dev/null
+++ b/src/note-c/CONTRIBUTING.md
@@ -0,0 +1,64 @@
+# Contributing to blues/note-c
+
+We love pull requests from everyone. By participating in this project, you
+agree to abide by the Blues Inc [code of conduct].
+
+[code of conduct]: https://blues.github.io/opensource/code-of-conduct
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code ( **no patch is too small** : fix typos, add comments,
+clean up inconsistent whitespace )
+* by refactoring code
+* by closing [issues][]
+* by reviewing patches
+
+[issues]: https://github.com/blues/note-c/issues
+
+## Submitting an Issue
+
+* We use the [GitHub issue tracker][issues] to track bugs and features.
+* Before submitting a bug report or feature request, check to make sure it
+  hasn't
+  already been submitted.
+* When submitting a bug report, please include a [Gist][] that includes a stack
+  trace and any details that may be necessary to reproduce the bug, including
+  your gem version, Ruby version, and operating system.  Ideally, a bug report
+  should include a pull request with failing specs.
+
+[gist]: https://gist.github.com/
+
+## Cleaning up issues
+
+* Issues that have no response from the submitter will be closed after 30 days.
+* Issues will be closed once they're assumed to be fixed or answered. If the
+  maintainer is wrong, it can be opened again.
+* If your issue is closed by mistake, please understand and explain the issue.
+  We will happily reopen the issue.
+
+## Submitting a Pull Request
+1. [Fork][fork] the [official repository][repo].
+2. [Create a topic branch.][branch]
+3. Implement your feature or bug fix.
+4. Add, commit, and push your changes.
+5. [Submit a pull request.][pr]
+
+## Notes
+* Please add tests if you changed code. Contributions without tests won't be
+* accepted. If you don't know how to add tests, please put in a PR and leave a
+* comment asking for help. We love helping!
+
+[repo]: https://github.com/blues/note-c/tree/master
+[fork]: https://help.github.com/articles/fork-a-repo/
+[branch]:
+https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/
+[pr]: https://help.github.com/articles/creating-a-pull-request-from-a-fork/
+
+Inspired by
+https://github.com/thoughtbot/factory_bot/blob/master/CONTRIBUTING.md
+
diff --git a/src/note-c/Dockerfile b/src/note-c/Dockerfile
new file mode 100644
index 0000000..0368b33
--- /dev/null
+++ b/src/note-c/Dockerfile
@@ -0,0 +1,95 @@
+# Container with dependencies necessary to run note-c unit tests.
+
+# Build development environment
+# $ docker build . --tag note_c_run_unit_tests
+
+# Launch development environment (mount source root as /note-c/)
+# $ docker run --rm --volume $(pwd)/../../../:/note-c/ --workdir /note-c/ note_c_run_unit_tests
+
+# Global Argument(s)
+ARG DEBIAN_FRONTEND="noninteractive"
+ARG UID=1000
+ARG USER="blues"
+
+# POSIX compatible (Linux/Unix) base image.
+FROM --platform=linux/amd64 debian:stable-slim
+
+# Import Global Argument(s)
+ARG DEBIAN_FRONTEND
+ARG UID
+ARG USER
+
+# Local Argument(s)
+
+# Create Non-Root User
+RUN ["dash", "-c", "\
+    addgroup \
+     --gid ${UID} \
+     \"${USER}\" \
+ && adduser \
+     --disabled-password \
+     --gecos \"\" \
+     --ingroup \"${USER}\" \
+     --uid ${UID} \
+     \"${USER}\" \
+ && usermod \
+     --append \
+     --groups \"dialout,plugdev\" \
+     \"${USER}\" \
+"]
+
+# Install whatever dependencies we can via apt-get.
+RUN ["dash", "-c", "\
+    apt-get update --quiet \
+ && apt-get install --assume-yes --no-install-recommends --quiet \
+     astyle \
+     ca-certificates \
+     curl \
+     g++ \
+     gcc \
+     gdb \
+     git \
+     lcov \
+     make \
+     nano \
+     python3-pip \
+     python3-sphinx \
+     valgrind \
+ && pip install --break-system-packages \
+     breathe \
+     sphinx-rtd-theme \
+ && apt-get clean \
+ && apt-get purge \
+ && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* \
+ "]
+
+# Download and install Doxygen 1.9.8. Currently, the version of Doxygen that
+# gets installed via apt-get doesn't have support FAIL_ON_WARNINGS_PRINT for the
+# WARN_AS_ERROR config option (added in 1.9.7).
+RUN ["dash", "-c", "\
+    curl -LO https://github.com/doxygen/doxygen/releases/download/Release_1_9_8/doxygen-1.9.8.linux.bin.tar.gz \
+ && tar xf doxygen-1.9.8.linux.bin.tar.gz \
+ && cd doxygen-1.9.8 \
+ && make INSTALL=/usr install \
+ && cd .. \
+ && rm doxygen-1.9.8.linux.bin.tar.gz \
+ && rm -rf doxygen-1.9.8 \
+"]
+
+# Download and install CMake v3.25.1. We need CMake v3.20+ in order to get the
+# ctest --test-dir option used by run_unit_tests.sh.
+RUN ["dash", "-c", "\
+    curl -LO https://github.com/Kitware/CMake/releases/download/v3.25.1/cmake-3.25.1-linux-x86_64.tar.gz \
+ && tar xf cmake-3.25.1-linux-x86_64.tar.gz --strip-components=1 -C /usr \
+ && rm cmake-3.25.1-linux-x86_64.tar.gz \
+"]
+
+# Download and install Catch2 v3.2.1.
+RUN ["dash", "-c", "\
+    curl -LO https://github.com/catchorg/Catch2/archive/refs/tags/v3.2.1.tar.gz \
+ && tar xf v3.2.1.tar.gz \
+ && cd Catch2-3.2.1 \
+ && cmake -DCATCH_INSTALL_DOCS=0 -B build/ \
+ && cmake --build build/ --target install \
+ && rm -rf Catch2-3.2.1  v3.2.1.tar.gz \
+"]
diff --git a/src/note-c/LICENSE b/src/note-c/LICENSE
new file mode 100644
index 0000000..aed1af8
--- /dev/null
+++ b/src/note-c/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2019 Blues Inc
+
+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 AUTHORS OR COPYRIGHT HOLDERS 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.
diff --git a/src/note-c/README.md b/src/note-c/README.md
new file mode 100644
index 0000000..a6e8f3b
--- /dev/null
+++ b/src/note-c/README.md
@@ -0,0 +1,64 @@
+[![Coverage Status](https://coveralls.io/repos/github/blues/note-c/badge.svg?branch=master)](https://coveralls.io/github/blues/note-c?branch=master)
+
+# note-c
+
+The note-c C library for communicating with the
+[Blues Wireless][blues] Notecard via serial or I²C.
+
+This library allows you to control a Notecard by writing a C
+or C++ program. Your program may programmatically configure Notecard and send
+Notes to [Notehub.io][notehub].
+
+This library is used by the [note-arduino library][note-arduino], which includes
+it as a git subtree.
+
+## Documentation
+
+The documentation for this library can be found [here](https://blues.github.io/note-c/index.html).
+
+## CMake
+
+The CMake build system is primarily here for testing note-c on a development
+machine. You can use it to generate a static or shared note-c library, but
+embedded users will typically just compile all the .c source files into their
+firmware image. For more on testing, see test/README.md.
+
+### Options
+
+- BUILD_TESTS: Build the tests. See the tests directory. Default: ON.
+- BUILD_SHARED_LIBS: Build the note-c library as shared instead of static. This
+reduces the total size of the compiled tests. Default: ON.
+
+## Contributing
+
+We love issues, fixes, and pull requests from everyone. By participating in this
+project, you agree to abide by the Blues Inc [code of conduct].
+
+For details on contributions we accept and the process for contributing, see our
+[contribution guide](CONTRIBUTING.md).
+
+## More Information
+
+For additional Notecard SDKs and Libraries, see:
+
+- [note-arduino][note-arduino] for Arduino support
+- [note-python][note-python] for Python
+- [note-go][note-go] for Go
+
+## To learn more about Blues Wireless, the Notecard and Notehub, see:
+
+- [blues.com](https://blues.io)
+- [notehub.io][notehub]
+- [wireless.dev](https://wireless.dev)
+
+## License
+
+Copyright (c) 2019 Blues Inc. Released under the MIT license. See
+[LICENSE](LICENSE) for details.
+
+[blues]: https://blues.com
+[notehub]: https://notehub.io
+[note-arduino]: https://github.com/blues/note-arduino
+[note-go]: https://github.com/blues/note-go
+[note-python]: https://github.com/blues/note-python
+[code of conduct]: https://blues.github.io/opensource/code-of-conduct
diff --git a/src/note-c/assets/blues_logo_no_text.png b/src/note-c/assets/blues_logo_no_text.png
new file mode 100644
index 0000000..1598330
Binary files /dev/null and b/src/note-c/assets/blues_logo_no_text.png differ
diff --git a/src/note-c/docs/CMakeLists.txt b/src/note-c/docs/CMakeLists.txt
new file mode 100644
index 0000000..c5fbe35
--- /dev/null
+++ b/src/note-c/docs/CMakeLists.txt
@@ -0,0 +1,26 @@
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
+
+find_package(Doxygen REQUIRED)
+
+find_program(SPHINX_BUILD sphinx-build REQUIRED)
+
+set(DOCS_CFG_DIR ${CMAKE_CURRENT_LIST_DIR})
+set(DOCS_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR})
+set(DOCS_SRC_DIR ${PROJECT_SOURCE_DIR}/docs)
+
+set(SPHINX_OPTS "-j auto -W --keep-going -T")
+separate_arguments(SPHINX_OPTS)
+
+add_custom_target(
+    docs
+    COMMAND ${CMAKE_COMMAND} -E env
+        ${SPHINX_BUILD}
+        -b html
+        -c ${DOCS_CFG_DIR}
+        -w ${DOCS_BUILD_DIR}/build.log
+        ${SPHINX_OPTS}
+        ${DOCS_SRC_DIR}
+        ${DOCS_BUILD_DIR}
+    USES_TERMINAL
+    COMMENT "Running Sphinx HTML build..."
+)
diff --git a/src/note-c/docs/Doxyfile.in b/src/note-c/docs/Doxyfile.in
new file mode 100644
index 0000000..72b9e0b
--- /dev/null
+++ b/src/note-c/docs/Doxyfile.in
@@ -0,0 +1,2820 @@
+# Doxyfile 1.9.8
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+#
+# Note:
+#
+# Use doxygen to compare the used configuration file with the template
+# configuration file:
+# doxygen -x [configFile]
+# Use doxygen to compare the used configuration file with the template
+# configuration file without replacing the environment variables or CMake type
+# replacement variables:
+# doxygen -x_noenv [configFile]
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = note-c
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         = 1.0
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = "An easy to use Notecard Library for C/C++"
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           = @NOTE_C_BASE@/assets/blues_logo_no_text.png
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       = @DOXY_OUT@
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 4096
+# sub-directories (in 2 levels) under the output directory of each output format
+# and will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system. Adapt CREATE_SUBDIRS_LEVEL to
+# control the number of sub-directories.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# Controls the number of sub-directories that will be created when
+# CREATE_SUBDIRS tag is set to YES. Level 0 represents 16 directories, and every
+# level increment doubles the number of directories, resulting in 4096
+# directories at level 8 which is the default and also the maximum value. The
+# sub-directories are organized in 2 levels, the first level always has a fixed
+# number of 16 directories.
+# Minimum value: 0, maximum value: 8, default value: 8.
+# This tag requires that the tag CREATE_SUBDIRS is set to YES.
+
+CREATE_SUBDIRS_LEVEL   = 8
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Bulgarian,
+# Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch, English
+# (United States), Esperanto, Farsi (Persian), Finnish, French, German, Greek,
+# Hindi, Hungarian, Indonesian, Italian, Japanese, Japanese-en (Japanese with
+# English messages), Korean, Korean-en (Korean with English messages), Latvian,
+# Lithuanian, Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese,
+# Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish,
+# Swedish, Turkish, Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = YES
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:^^"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". Note that you cannot put \n's in the value part of an alias
+# to insert newlines (in the resulting output). You can put ^^ in the value part
+# of an alias to insert a newline as if a physical newline was in the original
+# file. When you need a literal { or } or , in the value part of an alias you
+# have to escape them by means of a backslash (\), this can lead to conflicts
+# with the commands \{ and \} for these it is advised to use the version @{ and
+# @} or use a double escape (\\{ and \\})
+
+ALIASES                =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, Lex, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# VHDL, Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
+# The MARKDOWN_ID_STYLE tag can be used to specify the algorithm used to
+# generate identifiers for the Markdown headings. Note: Every identifier is
+# unique.
+# Possible values are: DOXYGEN use a fixed 'autotoc_md' string followed by a
+# sequence number starting at 0 and GITHUB use the lower case version of title
+# with any whitespace replaced by '-' and punctuation characters removed.
+# The default value is: DOXYGEN.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+MARKDOWN_ID_STYLE      = DOXYGEN
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+# The NUM_PROC_THREADS specifies the number of threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which effectively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
+# If the TIMESTAMP tag is set different from NO then each generated page will
+# contain the date or date and time when the page was generated. Setting this to
+# NO can help when comparing the output of multiple runs.
+# Possible values are: YES, NO, DATETIME and DATE.
+# The default value is: NO.
+
+TIMESTAMP              = NO
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# will also hide undocumented C++ concepts if enabled. This option has no effect
+# if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
+# Possible values are: SYSTEM, NO and YES.
+# The default value is: SYSTEM.
+
+CASE_SENSE_NAMES       = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_HEADERFILE tag is set to YES then the documentation for a class
+# will show which file needs to be included to use the class.
+# The default value is: YES.
+
+SHOW_HEADERFILE        = YES
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file. See also section "Changing the
+# layout of pages" for information.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as documenting some parameters in
+# a documented function twice, or documenting parameters that don't exist or
+# using markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete
+# function parameter documentation. If set to NO, doxygen will accept that some
+# parameters have no documentation without warning.
+# The default value is: YES.
+
+WARN_IF_INCOMPLETE_DOC = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong parameter
+# documentation, but not about the absence of documentation. If EXTRACT_ALL is
+# set to YES then this flag will automatically be disabled. See also
+# WARN_IF_INCOMPLETE_DOC
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If WARN_IF_UNDOC_ENUM_VAL option is set to YES, doxygen will warn about
+# undocumented enumeration values. If set to NO, doxygen will accept
+# undocumented enumeration values. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: NO.
+
+WARN_IF_UNDOC_ENUM_VAL = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS_PRINT then doxygen behaves
+# like FAIL_ON_WARNINGS but in case no WARN_LOGFILE is defined doxygen will not
+# write the warning messages in between other messages but write them at the end
+# of a run, in case a WARN_LOGFILE is defined the warning messages will be
+# besides being in the defined file also be shown at the end of a run, unless
+# the WARN_LOGFILE is defined as - i.e. standard output (stdout) in that case
+# the behavior will remain as with the setting FAIL_ON_WARNINGS.
+# Possible values are: NO, YES, FAIL_ON_WARNINGS and FAIL_ON_WARNINGS_PRINT.
+# The default value is: NO.
+
+WARN_AS_ERROR          = FAIL_ON_WARNINGS_PRINT
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# See also: WARN_LINE_FORMAT
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# In the $text part of the WARN_FORMAT command it is possible that a reference
+# to a more specific place is given. To make it easier to jump to this place
+# (outside of doxygen) the user can define a custom "cut" / "paste" string.
+# Example:
+# WARN_LINE_FORMAT = "'vi $file +$line'"
+# See also: WARN_FORMAT
+# The default value is: at line $line of file $file.
+
+WARN_LINE_FORMAT       = "at line $line of file $file"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr). In case the file specified cannot be opened for writing the
+# warning and error messages are written to standard error. When as file - is
+# specified the warning and error messages are written to standard output
+# (stdout).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = @NOTE_C_BASE@/n_hooks.c \
+                         @NOTE_C_BASE@/n_request.c \
+                         @NOTE_C_BASE@/n_cjson.h \
+                         @NOTE_C_BASE@/n_cjson.c \
+                         @NOTE_C_BASE@/n_cjson_helpers.c \
+                         @NOTE_C_BASE@/note.h
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
+# See also: INPUT_FILE_ENCODING
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses The INPUT_FILE_ENCODING tag can be used to specify
+# character encoding on a per file pattern basis. Doxygen will compare the file
+# name with each pattern and apply the encoding instead of the default
+# INPUT_ENCODING) if there is a match. The character encodings are a list of the
+# form: pattern=encoding (like *.php=ISO-8859-1). See cfg_input_encoding
+# "INPUT_ENCODING" for further information on supported encodings.
+
+INPUT_FILE_ENCODING    =
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cxxm,
+# *.cpp, *.cppm, *.c++, *.c++m, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl,
+# *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, *.h++, *.ixx, *.l, *.cs, *.d, *.php,
+# *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be
+# provided as doxygen C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
+# *.f18, *.f, *.for, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
+
+FILE_PATTERNS          = *.c \
+                         *.h
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# ANamespace::AClass, ANamespace::*Test
+
+EXCLUDE_SYMBOLS        =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that doxygen will use the data processed and written to standard output
+# for further processing, therefore nothing else, like debug statements or used
+# commands (so in case of a Windows batch file always use @echo OFF), should be
+# written to standard output.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+# The Fortran standard specifies that for fixed formatted Fortran code all
+# characters from position 72 are to be considered as comment. A common
+# extension is to allow longer lines before the automatic comment starts. The
+# setting FORTRAN_COMMENT_AFTER will also make it possible that longer lines can
+# be processed before the automatic comment starts.
+# Minimum value: 7, maximum value: 10000, default value: 72.
+
+FORTRAN_COMMENT_AFTER  = 72
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# entity all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see https://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+# The default value is: NO.
+
+CLANG_ASSISTED_PARSING = NO
+
+# If the CLANG_ASSISTED_PARSING tag is set to YES and the CLANG_ADD_INC_PATHS
+# tag is set to YES then doxygen will add the directory of each input to the
+# include path.
+# The default value is: YES.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
+# If clang assisted parsing is enabled you can provide the compiler with command
+# line options that you would normally use when invoking the compiler. Note that
+# the include paths will already be set by doxygen for the files and directories
+# specified with INPUT and INCLUDE_PATH.
+# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
+
+CLANG_OPTIONS          =
+
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# The IGNORE_PREFIX tag can be used to specify a prefix (or a list of prefixes)
+# that should be ignored while generating the index headers. The IGNORE_PREFIX
+# tag works for classes, function and member names. The entity will be placed in
+# the alphabetical list under the first letter of the entity name that remains
+# after removing the prefix.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# Note: Since the styling of scrollbars can currently not be overruled in
+# Webkit/Chromium, the styling will be left out of the default doxygen.css if
+# one or more extra stylesheets have been specified. So if scrollbar
+# customization is desired it has to be added explicitly. For an example see the
+# documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE tag can be used to specify if the generated HTML output
+# should be rendered with a dark or light theme.
+# Possible values are: LIGHT always generate light mode output, DARK always
+# generate dark mode output, AUTO_LIGHT automatically set the mode according to
+# the user preference, use light mode if no preference is set (the default),
+# AUTO_DARK automatically set the mode according to the user preference, use
+# dark mode if no preference is set and TOGGLE allow to user to switch between
+# light and dark mode via a button.
+# The default value is: AUTO_LIGHT.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE        = AUTO_LIGHT
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a color-wheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use gray-scales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# If the HTML_CODE_FOLDING tag is set to YES then classes and functions can be
+# dynamically folded and expanded in the generated HTML source code.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_CODE_FOLDING      = YES
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag determines the URL of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDURL         =
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# on Windows. In the beginning of 2021 Microsoft took the original page, with
+# a.o. the download links, offline the HTML help workshop was already many years
+# in maintenance mode). You can download the HTML help workshop from the web
+# archives at Installation executable (see:
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the main .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# The SITEMAP_URL tag is used to specify the full URL of the place where the
+# generated documentation will be placed on the server by the user during the
+# deployment of the documentation. The generated sitemap is called sitemap.xml
+# and placed on the directory specified by HTML_OUTPUT. In case no SITEMAP_URL
+# is specified no sitemap is generated. For information about the sitemap
+# protocol see https://www.sitemaps.org
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SITEMAP_URL            =
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine tune the look of the index (see "Fine-tuning the output"). As an
+# example, the default style sheet generated by doxygen has an example that
+# shows how to put an image at the root of the tree instead of the PROJECT_NAME.
+# Since the tree basically has the same information as the tab index, you could
+# consider setting DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = NO
+
+# When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+# FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+# area (value NO) or if it should extend to the full height of the window (value
+# YES). Setting this to YES gives a layout similar to
+# https://docs.readthedocs.io with more room for contents, but less room for the
+# project logo, title, and description. If either GENERATE_TREEVIEW or
+# DISABLE_INDEX is set to NO, this option has no effect.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FULL_SIDEBAR           = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# If the OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email
+# addresses.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+OBFUSCATE_EMAILS       = YES
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
+# Note that the different versions of MathJax have different requirements with
+# regards to the different settings, so it is possible that also other MathJax
+# settings have to be changed when switching between the different MathJax
+# versions.
+# Possible values are: MathJax_2 and MathJax_3.
+# The default value is: MathJax_2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_VERSION        = MathJax_2
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. For more details about the output format see MathJax
+# version 2 (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3
+# (see:
+# http://docs.mathjax.org/en/latest/web/components/output.html).
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility. This is the name for Mathjax version 2, for MathJax version 3
+# this will be translated into chtml), NativeMML (i.e. MathML. Only supported
+# for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This
+# is the name for Mathjax version 3, for MathJax version 2 this will be
+# translated into HTML-CSS) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from https://www.mathjax.org before deployment. The default value is:
+# - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
+# - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = https://cdn.jsdelivr.net/npm/mathjax@2
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# for MathJax version 2 (see
+# https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions):
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# For example for MathJax version 3 (see
+# http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
+# MATHJAX_EXTENSIONS = ams
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using JavaScript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         =
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a user-defined LaTeX header for
+# the generated LaTeX document. The header should contain everything until the
+# first chapter. If it is left blank doxygen will generate a standard header. It
+# is highly recommended to start with a default header using
+# doxygen -w latex new_header.tex new_footer.tex new_stylesheet.sty
+# and then modify the file new_header.tex. See also section "Doxygen usage" for
+# information on how to generate the default header that doxygen normally uses.
+#
+# Note: Only use a user-defined header if you know what you are doing!
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. The following
+# commands have a special meaning inside the header (and footer): For a
+# description of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a user-defined LaTeX footer for
+# the generated LaTeX document. The footer should contain everything after the
+# last chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer. See also section "Doxygen
+# usage" for information on how to generate the default footer that doxygen
+# normally uses. Note: Only use a user-defined footer if you know what you are
+# doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# The LATEX_BATCHMODE tag signals the behavior of LaTeX in case of an error.
+# Possible values are: NO same as ERROR_STOP, YES same as BATCH, BATCH In batch
+# mode nothing is printed on the terminal, errors are scrolled as if <return> is
+# hit at every error; missing files that TeX tries to input or request from
+# keyboard input (\read on a not open input stream) cause the job to abort,
+# NON_STOP In nonstop mode the diagnostic message will appear on the terminal,
+# but there is no possibility of user interaction just like in batch mode,
+# SCROLL In scroll mode, TeX will stop only for missing files to input or if
+# keyboard input is necessary and ERROR_STOP In errorstop mode, TeX will stop at
+# each error, asking for user intervention.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = YES
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see https://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to Sqlite3 output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_SQLITE3 tag is set to YES doxygen will generate a Sqlite3
+# database with symbols found by doxygen stored in tables.
+# The default value is: NO.
+
+GENERATE_SQLITE3       = NO
+
+# The SQLITE3_OUTPUT tag is used to specify where the Sqlite3 database will be
+# put. If a relative path is entered the value of OUTPUT_DIRECTORY will be put
+# in front of it.
+# The default directory is: sqlite3.
+# This tag requires that the tag GENERATE_SQLITE3 is set to YES.
+
+SQLITE3_OUTPUT         = sqlite3
+
+# The SQLITE3_OVERWRITE_DB tag is set to YES, the existing doxygen_sqlite3.db
+# database file will be recreated with each doxygen run. If set to NO, doxygen
+# will warn if an a database file is already found and not modify it.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_SQLITE3 is set to YES.
+
+SQLITE3_RECREATE_DB    = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = YES
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor. Note that the INCLUDE_PATH is not recursive, so the setting of
+# RECURSIVE has no effect here.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  =
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             = NOTE_C_STATIC=static \
+                         N_CJSON_PUBLIC(type)=type
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external classes and namespaces
+# will be listed in the class and namespace index. If set to NO, only the
+# inherited external classes will be listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the topic index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to diagram generator tools
+#---------------------------------------------------------------------------
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# https://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
+
+HAVE_DOT               = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# DOT_COMMON_ATTR is common attributes for nodes, edges and labels of
+# subgraphs. When you want a differently looking font in the dot files that
+# doxygen generates you can specify fontname, fontcolor and fontsize attributes.
+# For details please see <a href=https://graphviz.org/doc/info/attrs.html>Node,
+# Edge and Graph Attributes specification</a> You need to make sure dot is able
+# to find the font, which can be done by putting it in a standard location or by
+# setting the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font. Default graphviz fontsize is 14.
+# The default value is: fontname=Helvetica,fontsize=10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_COMMON_ATTR        = "fontname=Helvetica,fontsize=10"
+
+# DOT_EDGE_ATTR is concatenated with DOT_COMMON_ATTR. For elegant style you can
+# add 'arrowhead=open, arrowtail=open, arrowsize=0.5'. <a
+# href=https://graphviz.org/doc/info/arrows.html>Complete documentation about
+# arrows shapes.</a>
+# The default value is: labelfontname=Helvetica,labelfontsize=10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_EDGE_ATTR          = "labelfontname=Helvetica,labelfontsize=10"
+
+# DOT_NODE_ATTR is concatenated with DOT_COMMON_ATTR. For view without boxes
+# around nodes set 'shape=plain' or 'shape=plaintext' <a
+# href=https://www.graphviz.org/doc/info/shapes.html>Shapes specification</a>
+# The default value is: shape=box,height=0.2,width=0.4.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
+
+# You can set the path where dot can find font specified with fontname in
+# DOT_COMMON_ATTR and others dot attributes.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES or GRAPH or BUILTIN then doxygen will
+# generate a graph for each documented class showing the direct and indirect
+# inheritance relations. In case the CLASS_GRAPH tag is set to YES or GRAPH and
+# HAVE_DOT is enabled as well, then dot will be used to draw the graph. In case
+# the CLASS_GRAPH tag is set to YES and HAVE_DOT is disabled or if the
+# CLASS_GRAPH tag is set to BUILTIN, then the built-in generator will be used.
+# If the CLASS_GRAPH tag is set to TEXT the direct and indirect inheritance
+# relations will be shown as texts / links.
+# Possible values are: NO, YES, TEXT, GRAPH and BUILTIN.
+# The default value is: YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes. Explicit enabling a collaboration graph,
+# when COLLABORATION_GRAPH is set to NO, can be accomplished by means of the
+# command \collaborationgraph. Disabling a collaboration graph can be
+# accomplished by means of the command \hidecollaborationgraph.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies. Explicit enabling a group
+# dependency graph, when GROUP_GRAPHS is set to NO, can be accomplished by means
+# of the command \groupgraph. Disabling a directory graph can be accomplished by
+# means of the command \hidegroupgraph. See also the chapter Grouping in the
+# manual.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files. Explicit enabling an include graph, when INCLUDE_GRAPH is is set to NO,
+# can be accomplished by means of the command \includegraph. Disabling an
+# include graph can be accomplished by means of the command \hideincludegraph.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files. Explicit enabling an included by graph, when INCLUDED_BY_GRAPH is set
+# to NO, can be accomplished by means of the command \includedbygraph. Disabling
+# an included by graph can be accomplished by means of the command
+# \hideincludedbygraph.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories. Explicit enabling a directory graph, when
+# DIRECTORY_GRAPH is set to NO, can be accomplished by means of the command
+# \directorygraph. Disabling a directory graph can be accomplished by means of
+# the command \hidedirectorygraph.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels
+# of child directories generated in directory dependency graphs by dot.
+# Minimum value: 1, maximum value: 25, default value: 1.
+# This tag requires that the tag DIRECTORY_GRAPH is set to YES.
+
+DIR_GRAPH_MAX_DEPTH    = 1
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# https://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file or to the filename of jar file
+# to be used. If left blank, it is assumed PlantUML is not used or called during
+# a preprocessing step. Doxygen will generate a warning when it encounters a
+# \startuml command in this case and will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal
+# graphical representation for inheritance and collaboration diagrams is used.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
+# files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc temporary
+# files.
+# The default value is: YES.
+
+DOT_CLEANUP            = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. If the MSCGEN_TOOL tag is left empty (the default), then doxygen will
+# use a built-in version of mscgen tool to produce the charts. Alternatively,
+# the MSCGEN_TOOL tag can also specify the name an external tool. For instance,
+# specifying prog as the value, doxygen will call the tool as prog -T
+# <outfile_format> -o <outputfile> <inputfile>. The external tool should support
+# output file formats "png", "eps", "svg", and "ismap".
+
+MSCGEN_TOOL            =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
diff --git a/src/note-c/docs/_extensions/doxyrunner.py b/src/note-c/docs/_extensions/doxyrunner.py
new file mode 100644
index 0000000..605592c
--- /dev/null
+++ b/src/note-c/docs/_extensions/doxyrunner.py
@@ -0,0 +1,399 @@
+"""
+Doxyrunner Sphinx Plugin
+########################
+
+Copyright (c) 2021 Nordic Semiconductor ASA
+SPDX-License-Identifier: Apache-2.0
+
+Introduction
+============
+
+This Sphinx plugin can be used to run Doxygen build as part of the Sphinx build
+process. It is meant to be used with other plugins such as ``breathe`` in order
+to improve the user experience. The principal features offered by this plugin
+are:
+
+- Doxygen build is run before Sphinx reads input files
+- Doxyfile can be optionally pre-processed so that variables can be inserted
+- Changes in the Doxygen input files are tracked so that Doxygen build is only
+  run if necessary.
+- Synchronizes Doxygen XML output so that even if Doxygen is run only changed,
+  deleted or added files are modified.
+
+References:
+
+-  https://github.com/michaeljones/breathe/issues/420
+
+Configuration options
+=====================
+
+- ``doxyrunner_doxygen``: Path to the Doxygen binary.
+- ``doxyrunner_doxyfile``: Path to Doxyfile.
+- ``doxyrunner_outdir``: Doxygen build output directory (inserted to
+  ``OUTPUT_DIRECTORY``)
+- ``doxyrunner_outdir_var``: Variable representing the Doxygen build output
+  directory, as used by ``OUTPUT_DIRECTORY``. This can be useful if other
+  Doxygen variables reference to the output directory.
+- ``doxyrunner_fmt``: Flag to indicate if Doxyfile should be formatted.
+- ``doxyrunner_fmt_vars``: Format variables dictionary (name: value).
+- ``doxyrunner_fmt_pattern``: Format pattern.
+- ``doxyrunner_silent``: If Doxygen output should be logged or not. Note that
+  this option may not have any effect if ``QUIET`` is set to ``YES``.
+"""
+
+import filecmp
+import hashlib
+from pathlib import Path
+import re
+import shlex
+import shutil
+from subprocess import Popen, PIPE, STDOUT
+import tempfile
+from typing import List, Dict, Optional, Any
+
+from sphinx.application import Sphinx
+from sphinx.environment import BuildEnvironment
+from sphinx.util import logging
+
+
+__version__ = "0.1.0"
+
+
+logger = logging.getLogger(__name__)
+
+
+def hash_file(file: Path) -> str:
+    """Compute the hash (SHA256) of a file in text mode.
+
+    Args:
+        file: File to be hashed.
+
+    Returns:
+        Hash.
+    """
+
+    with open(file, encoding="utf-8") as f:
+        sha256 = hashlib.sha256(f.read().encode("utf-8"))
+
+    return sha256.hexdigest()
+
+def get_doxygen_option(doxyfile: str, option: str) -> List[str]:
+    """Obtain the value of a Doxygen option.
+
+    Args:
+        doxyfile: Content of the Doxyfile.
+        option: Option to be retrieved.
+
+    Notes:
+        Does not support appended values.
+
+    Returns:
+        Option values.
+    """
+
+    option_re = re.compile(r"^\s*([A-Z0-9_]+)\s*=\s*(.*)$")
+    multiline_re = re.compile(r"^\s*(.*)$")
+
+    values = []
+    found = False
+    finished = False
+    for line in doxyfile.splitlines():
+        if not found:
+            m = option_re.match(line)
+            if not m or m.group(1) != option:
+                continue
+
+            found = True
+            value = m.group(2)
+        else:
+            m = multiline_re.match(line)
+            if not m:
+                raise ValueError(f"Unexpected line content: {line}")
+
+            value = m.group(1)
+
+        # check if it is a multiline value
+        finished = not value.endswith("\\")
+
+        # strip backslash
+        if not finished:
+            value = value[:-1]
+
+        # split values
+        values += shlex.split(value.replace("\\", "\\\\"))
+
+        if finished:
+            break
+
+    return values
+
+
+def process_doxyfile(
+    doxyfile: str,
+    outdir: Path,
+    silent: bool,
+    fmt: bool = False,
+    fmt_pattern: Optional[str] = None,
+    fmt_vars: Optional[Dict[str, str]] = None,
+    outdir_var: Optional[str] = None,
+) -> str:
+    """Process Doxyfile.
+
+    Notes:
+        OUTPUT_DIRECTORY, WARN_FORMAT and QUIET are overridden to satisfy
+        extension operation needs.
+
+    Args:
+        doxyfile: Path to the Doxyfile.
+        outdir: Output directory of the Doxygen build.
+        silent: If Doxygen should be run in quiet mode or not.
+        fmt: If Doxyfile should be formatted.
+        fmt_pattern: Format pattern.
+        fmt_vars: Format variables.
+        outdir_var: Variable representing output directory.
+
+     Returns:
+        Processed Doxyfile content.
+    """
+
+    with open(doxyfile) as f:
+        content = f.read()
+
+    content = re.sub(
+        r"^\s*OUTPUT_DIRECTORY\s*=.*$",
+        f"OUTPUT_DIRECTORY={outdir.as_posix()}",
+        content,
+        flags=re.MULTILINE,
+    )
+
+    content = re.sub(
+        r"^\s*WARN_FORMAT\s*=.*$",
+        'WARN_FORMAT="$file:$line: $text"',
+        content,
+        flags=re.MULTILINE,
+    )
+
+    content = re.sub(
+        r"^\s*QUIET\s*=.*$",
+        "QUIET=YES" if silent else "QUIET=NO",
+        content,
+        flags=re.MULTILINE,
+    )
+
+    if fmt:
+        if not fmt_pattern or not fmt_vars:
+            raise ValueError("Invalid formatting pattern or variables")
+
+        if outdir_var:
+            fmt_vars = fmt_vars.copy()
+            fmt_vars[outdir_var] = outdir.as_posix()
+
+        for var, value in fmt_vars.items():
+            content = content.replace(fmt_pattern.format(var), value)
+
+    return content
+
+
+def doxygen_input_has_changed(env: BuildEnvironment, doxyfile: str) -> bool:
+    """Check if Doxygen input files have changed.
+
+    Args:
+        env: Sphinx build environment instance.
+        doxyfile: Doxyfile content.
+
+    Returns:
+        True if changed, False otherwise.
+    """
+
+    # obtain Doxygen input files and patterns
+    input_files = get_doxygen_option(doxyfile, "INPUT")
+    if not input:
+        raise ValueError("No INPUT set in Doxyfile")
+
+    file_patterns = get_doxygen_option(doxyfile, "FILE_PATTERNS")
+    if not file_patterns:
+        raise ValueError("No FILE_PATTERNS set in Doxyfile")
+
+    # build a set with input files hash
+    cache = set()
+    for file in input_files:
+        path = Path(file)
+        if path.is_file():
+            cache.add(hash_file(path))
+        else:
+            for pattern in file_patterns:
+                for p_file in path.glob("**/" + pattern):
+                    cache.add(hash_file(p_file))
+
+    # check if any file has changed
+    if hasattr(env, "doxyrunner_cache") and env.doxyrunner_cache == cache:
+        return False
+
+    # store current state
+    env.doxyrunner_cache = cache
+
+    return True
+
+
+def process_doxygen_output(line: str, silent: bool) -> None:
+    """Process a line of Doxygen program output.
+
+    This function will map Doxygen output to the Sphinx logger output. Errors
+    and warnings will be converted to Sphinx errors and warnings. Other
+    messages, if not silent, will be mapped to the info logger channel.
+
+    Args:
+        line: Doxygen program line.
+        silent: True if regular messages should be logged, False otherwise.
+    """
+
+    m = re.match(r"(.*):(\d+): ([a-z]+): (.*)", line)
+    if m:
+        type = m.group(3)
+        message = f"{m.group(1)}:{m.group(2)}: {m.group(4)}"
+        if type == "error":
+            logger.error(message)
+        elif type == "warning":
+            logger.warning(message)
+        else:
+            logger.info(message)
+    elif not silent:
+        logger.info(line)
+
+
+def run_doxygen(doxygen: str, doxyfile: str, silent: bool = False) -> None:
+    """Run Doxygen build.
+
+    Args:
+        doxygen: Path to Doxygen binary.
+        doxyfile: Doxyfile content.
+        silent: If Doxygen output should be logged or not.
+    """
+
+    f_doxyfile = tempfile.NamedTemporaryFile("w", delete=False)
+    f_doxyfile.write(doxyfile)
+    f_doxyfile.close()
+
+    p = Popen([doxygen, f_doxyfile.name], stdout=PIPE, stderr=STDOUT, encoding="utf-8")
+    while True:
+        line = p.stdout.readline()  # type: ignore
+        if line:
+            process_doxygen_output(line.rstrip(), silent)
+        if p.poll() is not None:
+            break
+
+    Path(f_doxyfile.name).unlink()
+
+    if p.returncode:
+        raise IOError(f"Doxygen process returned non-zero ({p.returncode})")
+
+
+def sync_doxygen(doxyfile: str, new: Path, prev: Path) -> None:
+    """Synchronize Doxygen output with a previous build.
+
+    This function makes sure that only new, deleted or changed files are
+    actually modified in the Doxygen XML output. Latest HTML content is just
+    moved.
+
+    Args:
+        doxyfile: Contents of the Doxyfile.
+        new: Newest Doxygen build output directory.
+        prev: Previous Doxygen build output directory.
+    """
+
+    generate_html = get_doxygen_option(doxyfile, "GENERATE_HTML")
+    if generate_html[0] == "YES":
+        html_output = get_doxygen_option(doxyfile, "HTML_OUTPUT")
+        if not html_output:
+            raise ValueError("No HTML_OUTPUT set in Doxyfile")
+
+        new_htmldir = new / html_output[0]
+        prev_htmldir = prev / html_output[0]
+
+        if prev_htmldir.exists():
+            shutil.rmtree(prev_htmldir)
+        new_htmldir.rename(prev_htmldir)
+
+    xml_output = get_doxygen_option(doxyfile, "XML_OUTPUT")
+    if not xml_output:
+        raise ValueError("No XML_OUTPUT set in Doxyfile")
+
+    new_xmldir = new / xml_output[0]
+    prev_xmldir = prev / xml_output[0]
+
+    if prev_xmldir.exists():
+        dcmp = filecmp.dircmp(new_xmldir, prev_xmldir)
+
+        for file in dcmp.right_only:
+            (Path(dcmp.right) / file).unlink()
+
+        for file in dcmp.left_only + dcmp.diff_files:
+            shutil.copy(Path(dcmp.left) / file, Path(dcmp.right) / file)
+
+        shutil.rmtree(new_xmldir)
+    else:
+        new_xmldir.rename(prev_xmldir)
+
+
+def doxygen_build(app: Sphinx) -> None:
+    """Doxyrunner entry point.
+
+    Args:
+        app: Sphinx application instance.
+    """
+
+    if app.config.doxyrunner_outdir:
+        outdir = Path(app.config.doxyrunner_outdir)
+    else:
+        outdir = Path(app.outdir) / "_doxygen"
+
+    outdir.mkdir(exist_ok=True)
+    tmp_outdir = outdir / "tmp"
+
+    logger.info("Preparing Doxyfile...")
+    doxyfile = process_doxyfile(
+        app.config.doxyrunner_doxyfile,
+        tmp_outdir,
+        app.config.doxyrunner_silent,
+        app.config.doxyrunner_fmt,
+        app.config.doxyrunner_fmt_pattern,
+        app.config.doxyrunner_fmt_vars,
+        app.config.doxyrunner_outdir_var,
+    )
+
+    logger.info("Checking if Doxygen needs to be run...")
+    changed = doxygen_input_has_changed(app.env, doxyfile)
+    if not changed:
+        logger.info("Doxygen build will be skipped (no changes)!")
+        return
+
+    logger.info("Running Doxygen...")
+    run_doxygen(
+        app.config.doxyrunner_doxygen,
+        doxyfile,
+        app.config.doxyrunner_silent,
+    )
+
+    logger.info("Syncing Doxygen output...")
+    sync_doxygen(doxyfile, tmp_outdir, outdir)
+
+    shutil.rmtree(tmp_outdir)
+
+
+def setup(app: Sphinx) -> Dict[str, Any]:
+    app.add_config_value("doxyrunner_doxygen", "doxygen", "env")
+    app.add_config_value("doxyrunner_doxyfile", None, "env")
+    app.add_config_value("doxyrunner_outdir", None, "env")
+    app.add_config_value("doxyrunner_outdir_var", None, "env")
+    app.add_config_value("doxyrunner_fmt", False, "env")
+    app.add_config_value("doxyrunner_fmt_vars", {}, "env")
+    app.add_config_value("doxyrunner_fmt_pattern", "@{}@", "env")
+    app.add_config_value("doxyrunner_silent", True, "")
+
+    app.connect("builder-inited", doxygen_build)
+
+    return {
+        "version": __version__,
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
diff --git a/src/note-c/docs/api_reference.rst b/src/note-c/docs/api_reference.rst
new file mode 100644
index 0000000..ec96f13
--- /dev/null
+++ b/src/note-c/docs/api_reference.rst
@@ -0,0 +1,188 @@
+*************
+API Reference
+*************
+
+.. contents:: Table of Contents
+   :depth: 2
+
+These pages cover the core functions and types that make up the note-c API.
+
+Dynamic Memory and Timing Hooks
+===============================
+
+Functions
+---------
+
+.. doxygenfunction:: NoteSetFn
+
+Types
+-----
+
+.. doxygentypedef:: mallocFn
+
+.. doxygentypedef:: freeFn
+
+.. doxygentypedef:: delayMsFn
+
+.. doxygentypedef:: getMsFn
+
+
+I/O Hooks
+=========
+
+Serial Hooks
+------------
+
+Functions
+^^^^^^^^^
+
+.. doxygenfunction:: NoteSetFnSerial
+
+Types
+^^^^^
+
+.. doxygentypedef:: serialResetFn
+
+.. doxygentypedef:: serialTransmitFn
+
+.. doxygentypedef:: serialAvailableFn
+
+.. doxygentypedef:: serialReceiveFn
+
+I2C
+---
+
+Functions
+^^^^^^^^^
+
+.. doxygenfunction:: NoteSetFnI2C
+
+Types
+^^^^^
+
+.. doxygentypedef:: i2cResetFn
+
+.. doxygentypedef:: i2cTransmitFn
+
+.. doxygentypedef:: i2cReceiveFn
+
+Macros
+^^^^^^
+
+.. doxygendefine:: NOTE_I2C_ADDR_DEFAULT
+
+.. doxygendefine:: NOTE_I2C_MAX_DEFAULT
+
+Mutex Hooks
+===========
+
+Notecard Mutex
+--------------
+
+Functions
+^^^^^^^^^
+
+.. doxygenfunction:: NoteSetFnNoteMutex
+
+Types
+^^^^^
+
+.. doxygentypedef:: mutexFn
+
+I2C Mutex
+---------
+
+Functions
+^^^^^^^^^
+
+.. doxygenfunction:: NoteSetFnI2CMutex
+
+Types
+^^^^^
+
+See :c:type:`mutexFn`.
+
+Notecard API Calls
+==================
+
+Functions
+---------
+
+.. doxygenfunction:: NoteNewRequest
+
+.. doxygenfunction:: NoteRequestResponse
+
+.. doxygenfunction:: NoteRequestResponseWithRetry
+
+.. doxygenfunction:: NoteRequest
+
+.. doxygenfunction:: NoteRequestWithRetry
+
+.. doxygendefine:: NoteResponseError
+
+.. doxygendefine:: NoteDeleteResponse
+
+.. doxygenfunction:: NoteRequestResponseJSON
+
+JSON Manipulation
+=================
+
+Functions
+---------
+
+.. doxygenfunction:: JAddBinaryToObject
+
+.. doxygenfunction:: JAddBoolToObject
+
+.. doxygenfunction:: JAddNumberToObject
+
+.. doxygenfunction:: JAddStringToObject
+
+.. doxygenfunction:: JAddObjectToObject
+
+.. doxygenfunction:: JAddArrayToObject
+
+.. doxygenfunction:: JCreateObject
+
+.. doxygenfunction:: JDelete
+
+.. doxygenfunction:: JFree
+
+.. doxygenfunction:: JGetArray
+
+.. doxygenfunction:: JGetBinaryFromObject
+
+.. doxygenfunction:: JGetBool
+
+.. doxygenfunction:: JGetInt
+
+.. doxygenfunction:: JGetNumber
+
+.. doxygenfunction:: JGetObject
+
+.. doxygenfunction:: JGetString
+
+.. doxygenfunction:: JIsPresent
+
+.. doxygenfunction:: JMalloc
+
+.. doxygenfunction:: JParse
+
+.. doxygenfunction:: JPrintUnformatted
+
+
+Types
+-----
+
+.. doxygenstruct:: J
+
+.. doxygentypedef:: JNUMBER
+
+.. doxygentypedef:: JINTEGER
+
+.. doxygentypedef:: JUINTEGER
+
+Macros
+------
+
+.. doxygendefine:: N_CJSON_NESTING_LIMIT
diff --git a/src/note-c/docs/calling_the_notecard_api.rst b/src/note-c/docs/calling_the_notecard_api.rst
new file mode 100644
index 0000000..4c37db4
--- /dev/null
+++ b/src/note-c/docs/calling_the_notecard_api.rst
@@ -0,0 +1,81 @@
+************************
+Calling the Notecard API
+************************
+
+The `Notecard API <https://dev.blues.io/api-reference/notecard-api/introduction/>`_ is JSON-based. note-c uses a modified version of the `cJSON library <https://github.com/DaveGamble/cJSON>`_ for working with JSON. The core JSON struct used in note-c is ``J``. You should treat this type as opaque; you will only ever need to work with ``J *`` when using note-c.
+
+To make a Notecard API call, first create a JSON request:
+
+.. code-block:: c
+
+   J *req = NoteNewRequest("note.add");
+
+When ``req`` is serialized to a string, it looks like this:
+
+.. code-block:: json
+
+   {"req": "note.add"}
+
+To add fields to the request, there are a number of ``JAdd*`` functions:
+
+* :c:func:`JAddBoolToObject`
+* :c:func:`JAddNumberToObject`
+* :c:func:`JAddStringToObject`
+* :c:func:`JAddObjectToObject`
+* :c:func:`JAddArrayToObject`
+
+For example, to add the field ``"file": "data.qo"`` to ``req``, use :c:func:`JAddStringToObject`:
+
+.. code-block:: c
+
+   JAddStringToObject(req, "file", "data.qo")
+
+Now, when ``req`` is serialized, it will have the ``"file"`` field:
+
+.. code-block:: json
+
+   {"req": "note.add", "file": "data.qo"}
+
+Once the request has been prepared, send it to the Notecard with :c:func:`NoteRequestResponse`:
+
+.. code-block:: c
+
+   J *rsp = NoteRequestResponse(req);
+
+``rsp`` holds the JSON response from the Notecard. Use :c:func:`NoteResponseError` to check the response for errors:
+
+.. code-block:: c
+
+   if (rsp == NULL || NoteResponseError(rsp)) {
+      // handle error
+   }
+
+``NoteRequestResponse`` will take care of freeing the passed in request object, but you must free the response with :c:func:`NoteDeleteResponse`:
+
+.. code-block:: c
+
+   NoteDeleteResponse(rsp);
+
+The function :c:func:`NoteRequest` is useful when you don't care about the details of the Notecard's response, just whether the API call was successful or not. It returns true if the API call was successful and false if there was an error sending the request or if there was an error in the response (i.e. it calls :c:func:`NoteResponseError` internally):
+
+.. code-block:: c
+
+   if (NoteRequest(req)) {
+      // success
+   }
+   else {
+      // handle error
+   }
+
+:c:func:`NoteRequest` frees the request object for you.
+
+.. note::
+   To use plain C-strings as the JSON interface into note-c, rather than ``J *``, check out :c:func:`NoteRequestResponseJSON`
+
+Examples
+========
+
+For examples of real applications calling the Notecard API with note-c, check out some of the `Zephyr <https://zephyrproject.org/>`_-based `Blues App Accelerators <https://github.com/blues/app-accelerators>`_:
+
+* `Valve Monitor and Control <https://github.com/blues/app-accelerators/tree/main/09-valve-monitor/firmware/zephyr>`_
+* `Temperature and Humidity Monitor <https://github.com/blues/app-accelerators/tree/main/18-temperature-and-humidity-monitor/firmware/zephyr>`_
diff --git a/src/note-c/docs/conf.py b/src/note-c/docs/conf.py
new file mode 100644
index 0000000..5a04823
--- /dev/null
+++ b/src/note-c/docs/conf.py
@@ -0,0 +1,71 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+import sys
+import os
+from pathlib import Path
+from sphinx.cmd.build import get_parser
+import sphinx_rtd_theme
+
+args = get_parser().parse_args()
+
+NOTE_C_BASE = Path(__file__).resolve().parents[1]
+NOTE_C_BUILD = Path(args.outputdir).resolve()
+
+# Add the '_extensions' directory to sys.path, to enable finding Sphinx
+# extensions within.
+sys.path.insert(0, str(NOTE_C_BASE / 'docs' / '_extensions'))
+
+# Project information
+
+project = 'note-c'
+copyright = '2023, Blues'
+author = 'Blues'
+
+# General configuration
+
+extensions = [
+    'doxyrunner',
+    'breathe',
+    'sphinx.ext.autosectionlabel',
+    'sphinxcontrib.jquery',
+]
+suppress_warnings = ['autosectionlabel.*']
+templates_path = ['_templates']
+exclude_patterns = ['build/']
+master_doc = 'index'
+
+# Options for autosectionlabel
+
+autosectionlabel_prefix_document = True
+
+# Options for doxyrunner
+
+doxyrunner_doxygen = os.environ.get('DOXYGEN_EXECUTABLE', 'doxygen')
+doxyrunner_doxyfile = NOTE_C_BASE / 'docs' / 'Doxyfile.in'
+doxyrunner_outdir = NOTE_C_BUILD / 'doxygen'
+doxyrunner_fmt = True
+doxyrunner_fmt_vars = {'NOTE_C_BASE': str(NOTE_C_BASE)}
+doxyrunner_outdir_var = 'DOXY_OUT'
+doxyrunner_silent = False
+
+# Options for breathe
+
+breathe_projects = {'note-c': str(doxyrunner_outdir / 'xml')}
+breathe_default_project = 'note-c'
+breathe_domain_by_extension = {
+    'h': 'c',
+    'c': 'c',
+}
+
+# Options for HTML output
+
+html_theme = 'sphinx_rtd_theme'
+html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+html_logo = str(NOTE_C_BASE / 'assets' / 'blues_logo_no_text.png')
+html_theme_options = {
+    'logo_only': True,
+    'prev_next_buttons_location': None
+}
diff --git a/src/note-c/docs/getting_started.rst b/src/note-c/docs/getting_started.rst
new file mode 100644
index 0000000..dcfa004
--- /dev/null
+++ b/src/note-c/docs/getting_started.rst
@@ -0,0 +1,20 @@
+Getting Started
+===============
+
+Notecard Background
+-------------------
+
+Before using note-c, it's essential to understand the fundamentals of communicating with a Notecard. Read the `Notecard Overview <https://dev.blues.io/notecard/notecard-walkthrough/overview/>`_ on the Blues developer site to familiarize yourself with the communications protocol. The protocol is JSON-based and supports `serial and I2C connections <https://dev.blues.io/notecard/notecard-walkthrough/notecard-interfaces/>`_.
+
+Getting the Source Code
+-----------------------
+
+To use note-c in your project, you can `download or clone the git repository from GitHub <https://github.com/blues/note-c>`_. The library is composed of all the .c and .h files prefixed with "n\_" in the root directory of the repository. Simply add the .c files alongside your other source files and make sure the .h files are on an include path visible to your compiler.
+
+Using the Library
+-----------------
+
+The pages below cover how to use note-c in your project.
+
+* :doc:`library_initialization`
+* :doc:`calling_the_notecard_api`
diff --git a/src/note-c/docs/index.rst b/src/note-c/docs/index.rst
new file mode 100644
index 0000000..0912ee7
--- /dev/null
+++ b/src/note-c/docs/index.rst
@@ -0,0 +1,18 @@
+.. note-c documentation master file, created by
+   sphinx-quickstart on Fri Oct 27 12:49:18 2023.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+note-c
+======
+
+note-c is the official C library for communicating with a `Blues Notecard <https://blues.com/products/notecard/>`_. The source code is open source and `available on GitHub <https://github.com/blues/note-c>`_ under the MIT license.
+
+.. toctree::
+   :maxdepth: 1
+
+   getting_started
+   library_initialization
+   calling_the_notecard_api
+   ports
+   api_reference
diff --git a/src/note-c/docs/library_initialization.rst b/src/note-c/docs/library_initialization.rst
new file mode 100644
index 0000000..9b84c36
--- /dev/null
+++ b/src/note-c/docs/library_initialization.rst
@@ -0,0 +1,343 @@
+**********************
+Library Initialization
+**********************
+
+.. contents:: Table of Contents
+   :depth: 2
+
+In order to send and receive data to and from the Notecard, note-c requires several hooks (i.e. callbacks) to be set. The implementations of the hooks are platform-specific and hence cannot be provided by note-c itself.
+
+Blues develops several open source ports of these hooks for different platforms to accelerate getting started with note-c. The level of abstraction of these ports varies. For example, `note-stm32l4 <https://github.com/blues/note-stm32l4>`_ implements these hooks for the STM32L4 series of MCUs using the STM32L4 HAL, while `note-arduino <https://github.com/blues/note-arduino>`_ is a more generic port that allows you to use note-c with essentially any Arduino-compatible board.
+
+For a comprehensive listing of note-c ports, go to :doc:`ports`.
+
+For an example and detailed breakdown of implementing the hooks for a specific platform, go to :ref:`library_initialization:Example: note-c Hooks for STM32L4`.
+
+Dynamic Memory and Timing Hooks
+===============================
+
+A port must set the dynamic memory and timing hooks using :c:func:`NoteSetFn` for:
+
+* Allocating memory
+* Freeing memory
+* Millisecond delay
+* Millisecond counter
+
+I/O Hooks
+=========
+
+note-c maintains one active Notecard I/O interface (serial or I2C) at a time. Calling :c:func:`NoteSetFnSerial` sets the active interface to serial, and calling :c:func:`NoteSetFnI2C` sets the active interface to I2C.
+
+Serial
+------
+
+:c:func:`NoteSetFnSerial` sets the serial hooks for:
+
+* Resetting the serial peripheral
+* Transmitting bytes
+* Checking if there's a byte available to receive
+* Receiving a single byte
+
+I2C
+---
+
+:c:func:`NoteSetFnI2C` sets the I2C hooks for:
+
+* Resetting the I2C peripheral
+* Transmitting bytes
+* Receiving bytes
+
+:c:func:`NoteSetFnI2C` also requires two additional parameters: the I2C address of the Notecard and the maximum number of bytes to send to the Notecard in a single I2C chunk. To use the defaults for these two values, use the macros :c:macro:`NOTE_I2C_ADDR_DEFAULT` and :c:macro:`NOTE_I2C_MAX_DEFAULT`, respectively.
+
+The I2C hooks are slightly more complex than the serial hooks. The transmit and receive hooks must implement the Notecard's serial-over-I2C protocol:
+
+   *Unlike many fixed-length and register-based I2C protocols, the Notecard defines a variable-length, serial-over-I2C protocol that allows developers to handle JSON requests and responses in a similar manner as a direct serial connection.*
+
+Familiarize yourself with the protocol using `this guide <https://dev.blues.io/guides-and-tutorials/notecard-guides/serial-over-i2c-protocol/>`_ from the Blues developer site. :ref:`library_initialization:Example: note-c Hooks for STM32L4` provides a detailed breakdown of implementing the protocol for STM32L4. While this example uses the STM32L4 HAL, the overall approach is generalizable to other platforms.
+
+Mutex Hooks
+===========
+
+Notecard Mutex
+--------------
+
+A port must set the Notecard mutex hooks using :c:func:`NoteSetFnNoteMutex` if it intends to support multiple concurrent tasks that communicate with the Notecard. Specifically, the port must set lock and unlock hooks. Internally, note-c will call the lock hook before every transaction with the Notecard begins, and it will call the unlock hook after every transaction ends. This ensures that one task doesn't interrupt another task in the middle of a transaction.
+
+The simplest implementation of these hooks relies on a flag indicating if access to the Notecard is locked by some other task. The lock hook sleeps/yields until the flag indicates the Notecard is unlocked and then acquires the lock itself:
+
+.. code-block:: c
+
+   void lockNotecard(void)
+   {
+       while (notecardLocked) {
+           NoteDelayMs(10); // sleep 10 ms between checks
+       }
+
+       notecardLocked = true;
+   }
+
+The unlock hook simply clears the flag:
+
+.. code-block:: c
+
+   void unlockNotecard(void)
+   {
+       notecardLocked = false;
+   }
+
+I2C Mutex
+---------
+
+A port must set the I2C mutex hooks using :c:func:`NoteSetFnI2CMutex` if it intends to support multiple concurrent tasks that drive the same I2C bus that the Notecard is on. Specifically, the port must set lock and unlock hooks. The simple lock-unlock implementation described previously in :ref:`library_initialization:Notecard Mutex` can be used for these hooks, too. Internally, note-c will call the lock hook before every I2C transaction with the Notecard begins, and it will call the unlock hook after every I2C transaction ends. The other tasks using I2C must be amended to do the same.
+
+Example: note-c Hooks for STM32L4
+=================================
+
+`note-stm32l4 <https://github.com/blues/note-stm32l4>`_ is the note-c port for the STM32L4 series of MCUs. This section walks through how the various note-c hooks are implemented for this platform. Notecard and I2C mutex hooks are not covered.
+
+Dynamic Memory and Timing Hooks
+-------------------------------
+
+This line in `Src/main.c <https://github.com/blues/note-stm32l4/blob/master/Src/main.c>`_ sets the dynamic memory and timing hooks:
+
+.. code-block:: c
+
+   NoteSetFn(malloc, free, delay, millis);
+
+``malloc``
+^^^^^^^^^^
+
+The memory allocation hook is set to ``malloc`` from libc.
+
+``free``
+^^^^^^^^
+
+The memory freeing hook is set to ``free`` from libc.
+
+``delay``
+^^^^^^^^^
+
+.. code-block:: c
+
+   void delay(uint32_t ms) {
+      HAL_Delay(ms);
+   }
+
+``delay`` calls into the STM32 HAL to delay for the specified number of milliseconds.
+
+``millis``
+^^^^^^^^^^
+
+.. code-block:: c
+
+   long unsigned int millis() {
+      return (long unsigned int) HAL_GetTick();
+   }
+
+``millis`` uses the HAL to get the value of a continuously running millisecond counter.
+
+I/O Hooks
+---------
+
+The code below from `Src/main.c <https://github.com/blues/note-stm32l4/blob/master/Src/main.c>`_ determines which I/O interface gets used, depending on the value of the ``NOTECARD_USE_I2C`` macro.
+
+.. code-block:: c
+
+   #if NOTECARD_USE_I2C
+      NoteSetFnI2C(NOTE_I2C_ADDR_DEFAULT, NOTE_I2C_MAX_DEFAULT, noteI2CReset, noteI2CTransmit, noteI2CReceive);
+   #else
+      NoteSetFnSerial(noteSerialReset, noteSerialTransmit, noteSerialAvailable, noteSerialReceive);
+   #endif
+
+``noteSerialReset``
+^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   bool noteSerialReset() {
+      MX_USART1_UART_DeInit();
+      MX_USART1_UART_Init();
+
+      return true;
+   }
+
+The serial reset hook reinitializes the serial peripheral connected to the Notecard.
+
+``noteSerialTransmit``
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   void noteSerialTransmit(uint8_t *text, size_t len, bool flush) {
+       HAL_UART_Transmit(&huart1, text, len, 5000);
+   }
+
+The serial transmit hook uses the HAL to write the data in the buffer to the serial peripheral connected to the Notecard.
+
+``noteSerialAvailable``
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   bool noteSerialAvailable() {
+      return (serialFillIndex != serialDrainIndex);
+   }
+
+For receiving serial data from the Notecard, note-stm32l4 uses a circular buffer. In the receive interrupt handler for the UART peripheral, this buffer gets populated with the received data. ``serialFillIndex`` is the write index into that buffer, and ``serialDrainIndex`` is the read index. If the two indices are equal, there's nothing new to read. If they aren't equal, there is something to read.
+
+``noteSerialReceive``
+^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   char noteSerialReceive() {
+       char data;
+       while (!noteSerialAvailable()) ;
+       if (serialDrainIndex < sizeof(serialBuffer))
+           data = serialBuffer[serialDrainIndex++];
+       else {
+           data = serialBuffer[0];
+           serialDrainIndex = 1;
+       }
+       return data;
+   }
+
+The serial receive hook returns the byte from the circular receive buffer at the read index, handling the case where the index wraps around to 0.
+
+``noteI2CReset``
+^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   bool noteI2CReset(uint16_t DevAddress) {
+       MX_I2C1_DeInit();
+       MX_I2C1_Init();
+
+       return true;
+   }
+
+The I2C reset hook reinitializes the I2C peripheral used to communicate with the Notecard.
+
+``noteI2CTransmit``
+^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   const char *noteI2CTransmit(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size) {
+       char *errstr = NULL;
+       int writelen = sizeof(uint8_t) + Size;
+       uint8_t *writebuf = malloc(writelen);
+       if (writebuf == NULL) {
+           errstr = "i2c: insufficient memory (write)";
+       } else {
+           writebuf[0] = Size;
+           memcpy(&writebuf[1], pBuffer, Size);
+           HAL_StatusTypeDef err_code = HAL_I2C_Master_Transmit(&hi2c1, DevAddress<<1, writebuf, writelen, 250);
+           free(writebuf);
+           if (err_code != HAL_OK) {
+               errstr = "i2c: HAL_I2C_Master_Transmit error";
+           }
+       }
+       return errstr;
+   }
+
+To frame the data to transmit to the Notecard using the serial-over-I2C protocol, the host first adds a byte indicating the number of bytes in the payload, which is ``Size``:
+
+.. code-block:: c
+
+   writebuf[0] = Size;
+
+Then, it adds on the payload of ``Size`` bytes, which is pointed to by ``pBuffer``:
+
+.. code-block:: c
+
+   memcpy(&writebuf[1], pBuffer, Size);
+
+Then the host calls the platform-specific method to send those bytes over I2C, which is ``HAL_I2C_Master_Transmit`` in this case.
+
+``noteI2CReceive``
+^^^^^^^^^^^^^^^^^^
+
+.. code-block:: c
+
+   const char *noteI2CReceive(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size, uint32_t *available) {
+       const char *errstr = NULL;
+       HAL_StatusTypeDef err_code;
+
+       // Retry transmit errors several times, because it's harmless to do so
+       for (int i=0; i<3; i++) {
+           uint8_t hdr[2];
+           hdr[0] = (uint8_t) 0;
+           hdr[1] = (uint8_t) Size;
+           HAL_StatusTypeDef err_code = HAL_I2C_Master_Transmit(&hi2c1, DevAddress<<1, hdr, sizeof(hdr), 250);
+           if (err_code == HAL_OK) {
+               errstr = NULL;
+               break;
+           }
+           errstr = "i2c: HAL_I2C_Master_Transmit error";
+       }
+
+       // Only receive if we successfully began transmission
+       if (errstr == NULL) {
+
+           int readlen = Size + (sizeof(uint8_t)*2);
+           uint8_t *readbuf = malloc(readlen);
+           if (readbuf == NULL) {
+               errstr = "i2c: insufficient memory (read)";
+           } else {
+               err_code = HAL_I2C_Master_Receive(&hi2c1, DevAddress<<1, readbuf, readlen, 10);
+               if (err_code != HAL_OK) {
+                   errstr = "i2c: HAL_I2C_Master_Receive error";
+               } else {
+                   uint8_t availbyte = readbuf[0];
+                   uint8_t goodbyte = readbuf[1];
+                   if (goodbyte != Size) {
+                       errstr = "i2c: incorrect amount of data";
+                   } else {
+                       *available = availbyte;
+                       memcpy(pBuffer, &readbuf[2], Size);
+                   }
+               }
+               free(readbuf);
+           }
+       }
+
+       // Done
+       return errstr;
+
+   }
+
+Setting aside the retry logic at the start and the error checking, the above code is simpler than it initially appears. To initiate a read with the Notecard, the serial-over-I2C protocol specifies that the host first send a 2-byte packet: a 0 followed by a byte indicating the max amount of data the host is prepared to receive. That's ``Size`` in this case, which is the available space in the receive buffer ``pBuffer``.
+
+.. code-block:: c
+
+   hdr[0] = (uint8_t) 0;
+   hdr[1] = (uint8_t) Size;
+
+Then, the host calls the platform-specific method to send those bytes over I2C.
+
+Now, to read the data from the Notecard, the host calls the platform-specific method for an I2C read (``HAL_I2C_Master_Receive``). The packet it receives from the Notecard has a 2-byte header. The first byte indicates the number of bytes still available to read from the Notecard after this packet:
+
+.. code-block:: c
+
+   uint8_t availbyte = readbuf[0];
+
+The second byte is the number of bytes in the current packet:
+
+.. code-block:: c
+
+   uint8_t goodbyte = readbuf[1];
+
+The rest of the packet is the payload:
+
+.. code-block:: c
+
+   memcpy(pBuffer, &readbuf[2], Size);
+
+Note that the number of bytes still available is returned to the caller via the ``available`` parameter:
+
+.. code-block:: c
+
+   *available = availbyte;
+
+This lets note-c know if it should call this hook again to keep reading.
diff --git a/src/note-c/docs/ports.rst b/src/note-c/docs/ports.rst
new file mode 100644
index 0000000..296ba7b
--- /dev/null
+++ b/src/note-c/docs/ports.rst
@@ -0,0 +1,28 @@
+Ports
+=====
+
+This is a listing of all the open source note-c ports developed by Blues.
+
+.. list-table::
+    :header-rows: 1
+
+    * - Name
+      - Description
+    * - `note-arduino <https://github.com/blues/note-arduino>`_
+      - Arduino library wrapper.
+    * - `note-zephyr <https://github.com/blues/note-zephyr>`_
+      - Port for the Zephyr RTOS.
+    * - `note-mbed <https://github.com/blues/note-mbed>`_
+      - Port for the Mbed RTOS.
+    * - `note-stm32g0 <https://github.com/blues/note-stm32g0>`_
+      - Port for STM32G0.
+    * - `note-stm32f1 <https://github.com/blues/note-stm32f1>`_
+      - Port for STM32F1.
+    * - `note-stm32l0 <https://github.com/blues/note-stm32l0>`_
+      - Port for STM32L0.
+    * - `note-stm32l4 <https://github.com/blues/note-stm32l4>`_
+      - Port for STM32L4.
+    * - `note-msp430 <https://github.com/blues/note-msp430>`_
+      - Port for TI MSP430.
+    * - `note-nrf52 <https://github.com/blues/note-nrf52>`_
+      - Port for nRF52.
diff --git a/src/note-c/n_atof.c b/src/note-c/n_atof.c
new file mode 100644
index 0000000..d465dec
--- /dev/null
+++ b/src/note-c/n_atof.c
@@ -0,0 +1,292 @@
+/*!
+ * @file n_atof.c
+ *
+ * Derived from the "strtod" library procedure to be locale-independent
+ *
+ * Copyright (c) 1988-1993 The Regents of the University of California.
+ * Copyright (c) 1994 Sun Microsystems, Inc.
+ *
+ * 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.  The University of California
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ *
+ * RCS: @(#) $Id$
+ */
+
+#ifdef HAVE_STDLIB_H
+#   include <stdlib.h>
+#endif
+#include <ctype.h>
+
+#include "n_lib.h"
+
+#ifndef __STDC__
+# ifdef __GNUC__
+#  define const __const__
+# else
+#  define const
+# endif
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define MAX_EXPONENT 511    /* Largest possible base 10 exponent.  Any
+                                 * exponent larger than this will already
+                                 * produce underflow or overflow, so there's
+                                 * no need to worry about additional digits.
+                                 */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * atof -- a LOCALE-INDEPENDENT string to floating point
+ *
+ *      This procedure converts a floating-point number from an ASCII
+ *      decimal representation to internal double-precision format.
+ *
+ * Results:
+ *      The return value is the double-precision floating-point
+ *      representation of the characters in string.  If endPtr isn't
+ *      NULL, then *endPtr is filled in with the address of the
+ *      next character after the last one that was part of the
+ *      floating-point number.
+ *
+ * Side effects:
+ *      None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+JNUMBER
+JAtoN(string, endPtr)
+const char *string;         /* A decimal ASCII floating-point number,
+                                 * optionally preceded by white space.
+                                 * Must have form "-I.FE-X", where I is the
+                                 * integer part of the mantissa, F is the
+                                 * fractional part of the mantissa, and X
+                                 * is the exponent.  Either of the signs
+                                 * may be "+", "-", or omitted.  Either I
+                                 * or F may be omitted, or both.  The decimal
+                                 * point isn't necessary unless F is present.
+                                 * The "E" may actually be an "e".  E and X
+                                 * may both be omitted (but not just one).
+                                 */
+char **endPtr;              /* If non-NULL, store terminating character's
+                                 * address here. */
+{
+    int sign, expSign = FALSE;
+    JNUMBER fraction;
+    register const char *p;
+    register int c;
+    int exp = 0;                /* Exponent read from "EX" field. */
+    int fracExp = 0;            /* Exponent that derives from the fractional
+                                 * part.  Under normal circumstatnces, it is
+                                 * the negative of the number of digits in F.
+                                 * However, if I is very long, the last digits
+                                 * of I get dropped (otherwise a long I with a
+                                 * large negative exponent could cause an
+                                 * unnecessary overflow on I alone).  In this
+                                 * case, fracExp is incremented one for each
+                                 * dropped digit. */
+    int mantSize;               /* Number of digits in mantissa. */
+    int decPt;                  /* Number of mantissa digits BEFORE decimal
+                                 * point. */
+    const char *pExp;           /* Temporarily holds location of exponent
+                                 * in string. */
+
+    /*
+     * Strip off leading blanks and check for a sign.
+     */
+
+    p = string;
+    while (*p == ' ') {
+        p += 1;
+    }
+    if (*p == '-') {
+        sign = TRUE;
+        p += 1;
+    } else {
+        if (*p == '+') {
+            p += 1;
+        }
+        sign = FALSE;
+    }
+
+    /*
+     * Count the number of digits in the mantissa (including the decimal
+     * point), and also locate the decimal point.
+     */
+
+    decPt = -1;
+    for (mantSize = 0; ; mantSize += 1) {
+        c = *p;
+        if (c < '0' || c > '9') {
+            if ((c != '.') || (decPt >= 0)) {
+                break;
+            }
+            decPt = mantSize;
+        }
+        p += 1;
+    }
+
+    /*
+     * Now suck up the digits in the mantissa.  Use two integers to
+     * collect 9 digits each (this is faster than using floating-point).
+     * If the mantissa has more than 18 digits, ignore the extras, since
+     * they can't affect the value anyway.
+     */
+
+    pExp  = p;
+    p -= mantSize;
+    if (decPt < 0) {
+        decPt = mantSize;
+    } else {
+        mantSize -= 1;                  /* One of the digits was the point. */
+    }
+    if (mantSize > 18) {
+        fracExp = decPt - 18;
+        mantSize = 18;
+    } else {
+        fracExp = decPt - mantSize;
+    }
+    if (mantSize == 0) {
+        fraction = 0.0;
+        p = string;
+        goto done;
+    } else {
+        long frac1, frac2;
+        frac1 = 0L;
+        for ( ; mantSize > 9; mantSize -= 1) {
+            c = *p;
+            p += 1;
+            if (c == '.') {
+                c = *p;
+                p += 1;
+            }
+            frac1 = 10*frac1 + (c - '0');
+        }
+        frac2 = 0L;
+        for (; mantSize > 0; mantSize -= 1) {
+            c = *p;
+            p += 1;
+            if (c == '.') {
+                c = *p;
+                p += 1;
+            }
+            frac2 = 10*frac2 + (c - '0');
+        }
+        fraction = (1.0e9 * frac1) + frac2;
+    }
+
+    /*
+     * Skim off the exponent.
+     */
+
+    p = pExp;
+    if ((*p == 'E') || (*p == 'e')) {
+        p += 1;
+        if (*p == '-') {
+            expSign = TRUE;
+            p += 1;
+        } else {
+            if (*p == '+') {
+                p += 1;
+            }
+            expSign = FALSE;
+        }
+        while (*p >= '0' && *p <= '9') {
+            exp = exp * 10 + (*p - '0');
+            p += 1;
+        }
+    }
+    if (expSign) {
+        exp = fracExp - exp;
+    } else {
+        exp = fracExp + exp;
+    }
+
+    /*
+     * Generate a floating-point number that represents the exponent.
+     * Do this by processing the exponent one bit at a time to combine
+     * many powers of 2 of 10. Then combine the exponent with the
+     * fraction.
+     */
+
+    if (exp < 0) {
+        expSign = TRUE;
+        exp = -exp;
+    } else {
+        expSign = FALSE;
+    }
+    if (exp > MAX_EXPONENT) {
+        exp = MAX_EXPONENT;
+    }
+    int d;
+    for (d = 0; exp != 0; exp >>= 1, d += 1) {
+        /* Table giving binary powers of 10.  Entry */
+        /* is 10^2^i.  Used to convert decimal */
+        /* exponents into floating-point numbers. */
+        JNUMBER p10 = 0.0;
+        switch (d) {
+        case 0:
+            p10 = 10.0;
+            break;
+        case 1:
+            p10 = 100.0;
+            break;
+        case 2:
+            p10 = 1.0e4;
+            break;
+        case 3:
+            p10 = 1.0e8;
+            break;
+        case 4:
+            p10 = 1.0e16;
+            break;
+        case 5:
+            p10 = 1.0e32;
+            break;
+#ifndef NOTE_C_LOW_MEM
+        case 6:
+            p10 = 1.0e64;
+            break;
+        case 7:
+            p10 = 1.0e128;
+            break;
+        case 8:
+            p10 = 1.0e256;
+            break;
+#endif
+        }
+        if (p10 == 0.0) {
+            break;
+        }
+        if (exp & 01) {
+            if (expSign) {
+                fraction /= p10;
+            } else {
+                fraction *= p10;
+            }
+        }
+    }
+
+done:
+    if (endPtr != NULL) {
+        *endPtr = (char *) p;
+    }
+
+    if (sign) {
+        return -fraction;
+    }
+    return fraction;
+}
diff --git a/src/note-c/n_b64.c b/src/note-c/n_b64.c
new file mode 100644
index 0000000..e718ce6
--- /dev/null
+++ b/src/note-c/n_b64.c
@@ -0,0 +1,200 @@
+/*!
+ * @file n_b64.c
+ *
+ * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
+ * *
+ * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ */
+/* ====================================================================
+ * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the Apache Group
+ *    for use in the Apache HTTP server project (http://www.apache.org/)."
+ *
+ * 4. The names "Apache Server" and "Apache Group" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache"
+ *    nor may "Apache" appear in their names without prior written
+ *    permission of the Apache Group.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the Apache Group
+ *    for use in the Apache HTTP server project (http://www.apache.org/)."
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
+ * EXPRESSED 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 APACHE GROUP OR
+ * ITS 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Group and was originally based
+ * on public domain software written at the National Center for
+ * Supercomputing Applications, University of Illinois, Urbana-Champaign.
+ * For more information on the Apache Group and the Apache HTTP server
+ * project, please see <http://www.apache.org/>.
+ *
+ * Base64 encoder/decoder. Originally Apache file ap_base64.c
+ */
+
+#include <string.h>
+#include "n_lib.h"
+
+/* aaaack but it's fast and const should make it shared text page. */
+static const unsigned char pr2six[256] = {
+    /* ASCII table */
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
+    64,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
+    64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
+};
+
+int JB64DecodeLen(const char *bufcoded)
+{
+    int nbytesdecoded;
+    register const unsigned char *bufin;
+    register int nprbytes;
+
+    bufin = (const unsigned char *) bufcoded;
+    while (pr2six[*(bufin++)] <= 63);
+
+    nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
+    nbytesdecoded = ((nprbytes + 3) / 4) * 3;
+
+    return nbytesdecoded + 1;
+}
+
+int JB64Decode(char *bufplain, const char *bufcoded)
+{
+    int nbytesdecoded;
+    register const unsigned char *bufin;
+    register unsigned char *bufout;
+    register int nprbytes;
+
+    bufin = (const unsigned char *) bufcoded;
+    while (pr2six[*(bufin++)] <= 63);
+    nprbytes = (bufin - (const unsigned char *) bufcoded) - 1;
+    nbytesdecoded = ((nprbytes + 3) / 4) * 3;
+
+    bufout = (unsigned char *) bufplain;
+    bufin = (const unsigned char *) bufcoded;
+
+    while (nprbytes > 4) {
+        *(bufout++) =
+            (unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
+        *(bufout++) =
+            (unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
+        *(bufout++) =
+            (unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
+        bufin += 4;
+        nprbytes -= 4;
+    }
+
+    /* Note: (nprbytes == 1) would be an error, so just ingore that case */
+    if (nprbytes > 1) {
+        *(bufout++) =
+            (unsigned char) (pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4);
+    }
+    if (nprbytes > 2) {
+        *(bufout++) =
+            (unsigned char) (pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2);
+    }
+    if (nprbytes > 3) {
+        *(bufout++) =
+            (unsigned char) (pr2six[bufin[2]] << 6 | pr2six[bufin[3]]);
+    }
+
+    *(bufout++) = '\0';
+    nbytesdecoded -= (4 - nprbytes) & 3;
+    return nbytesdecoded;
+}
+
+static const char basis_64[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+int JB64EncodeLen(int len)
+{
+    return ((len + 2) / 3 * 4) + 1;
+}
+
+int JB64Encode(char *encoded, const char *string, int len)
+{
+    int i;
+    char *p;
+
+    p = encoded;
+    for (i = 0; i < len - 2; i += 3) {
+        *p++ = basis_64[(string[i] >> 2) & 0x3F];
+        *p++ = basis_64[((string[i] & 0x3) << 4) | ((int) (string[i + 1] & 0xF0) >> 4)];
+        *p++ = basis_64[((string[i + 1] & 0xF) << 2) | ((int) (string[i + 2] & 0xC0) >> 6)];
+        *p++ = basis_64[string[i + 2] & 0x3F];
+    }
+    if (i < len) {
+        *p++ = basis_64[(string[i] >> 2) & 0x3F];
+        if (i == (len - 1)) {
+            *p++ = basis_64[((string[i] & 0x3) << 4)];
+            *p++ = '=';
+        } else {
+            *p++ = basis_64[((string[i] & 0x3) << 4) | ((int) (string[i + 1] & 0xF0) >> 4)];
+            *p++ = basis_64[((string[i + 1] & 0xF) << 2)];
+        }
+        *p++ = '=';
+    }
+
+    *p++ = '\0';
+    return p - encoded;
+}
diff --git a/src/note-c/n_cjson.c b/src/note-c/n_cjson.c
new file mode 100644
index 0000000..365742b
--- /dev/null
+++ b/src/note-c/n_cjson.c
@@ -0,0 +1,2787 @@
+/*!
+ * @file n_cjson.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Portions Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ * MODIFIED for use in notecard primarily by altering default memory allocator
+ * and by renaming the functions so that they won't conflict with a developer's
+ * own decision to incorporate the actual production cJSON into their own app.
+ * In no way shall this interfere with a production cJSON.
+ *
+ * Renaming was done as follows:
+ * CJSON_ -> N_CJSON_
+ * cJSON_ -> J
+ * cJSON -> J
+ *
+ * Portions Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+ *
+ * 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 i
+ * 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
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+/* disable warnings about old C89 functions in MSVC */
+#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#ifdef __GNUC__
+#pragma GCC visibility push(default)
+#endif
+#if defined(_MSC_VER)
+#pragma warning (push)
+/* disable warning about single line comments in system headers */
+#pragma warning (disable : 4001)
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <ctype.h>
+
+// For Note, disable dependencies
+#undef ENABLE_LOCALES
+
+#include "n_lib.h"
+
+#ifdef ENABLE_LOCALES
+#include <locale.h>
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning (pop)
+#endif
+#ifdef __GNUC__
+#pragma GCC visibility pop
+#endif
+
+#define PRINT_TAB_CHARS     4
+
+#ifdef NOTE_C_TEST
+#include "test_static.h"
+#else
+#define NOTE_C_STATIC static
+#endif
+
+typedef struct {
+    const unsigned char *json;
+    size_t position;
+} error;
+static error global_error = { NULL, 0 };
+
+// Forwards
+static J *JNew_Item(void);
+
+N_CJSON_PUBLIC(const char *) JGetErrorPtr(void)
+{
+    return (const char*) (global_error.json + global_error.position);
+}
+
+N_CJSON_PUBLIC(char *) JGetStringValue(J *item)
+{
+    if (!JIsString(item)) {
+        return NULL;
+    }
+
+    return item->valuestring;
+}
+
+/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */
+#if (N_CJSON_VERSION_MAJOR != 1) || (N_CJSON_VERSION_MINOR != 7) || (N_CJSON_VERSION_PATCH != 7)
+#error J.h and J.c have different versions. Make sure that both have the same.
+#endif
+
+N_CJSON_PUBLIC(const char*) JVersion(void)
+{
+    return NOTE_C_STRINGIZE(N_CJSON_VERSION_MAJOR) "." NOTE_C_STRINGIZE(N_CJSON_VERSION_MINOR) "." NOTE_C_STRINGIZE(N_CJSON_VERSION_PATCH);
+}
+
+NOTE_C_STATIC char Jtolower(char c)
+{
+    if (c < 'A' || c > 'Z') {
+        return c;
+    }
+
+    // 32 is the distance between any ASCII uppercase letter and its lowercase
+    // counterpart.
+    return c + 32;
+}
+
+/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */
+static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2)
+{
+    if ((string1 == NULL) || (string2 == NULL)) {
+        return 1;
+    }
+
+    if (string1 == string2) {
+        return 0;
+    }
+
+    for(; Jtolower(*string1) == Jtolower(*string2); (void)string1++, string2++) {
+        if (*string1 == '\0') {
+            return 0;
+        }
+    }
+
+    return Jtolower(*string1) - Jtolower(*string2);
+}
+
+static unsigned char* Jstrdup(const unsigned char* string)
+{
+    size_t length = 0;
+    unsigned char *copy = NULL;
+
+    if (string == NULL) {
+        return NULL;
+    }
+
+    length = strlen((const char*)string) + sizeof("");
+    copy = (unsigned char*)_Malloc(length);
+    if (copy == NULL) {
+        return NULL;
+    }
+    memcpy(copy, string, length);
+
+    return copy;
+}
+
+/*!
+ @brief Dynamically allocate a block of memory of the given size.
+
+ This is simply a wrapper around the memory allocation function provided by the
+ user via `NoteSetFn`.
+
+ @param size The number of bytes to allocate.
+
+ @returns A pointer to the first byte of the allocated memory or NULL on error.
+ */
+N_CJSON_PUBLIC(void *) JMalloc(size_t size)
+{
+    return _Malloc(size);
+}
+
+/*!
+ @brief Free a block of dynamically allocated memory.
+
+ This is simply a wrapper around the memory free function provided by the user
+ via `NoteSetFn`.
+
+ @param p A pointer to the block of memory to free.
+ */
+N_CJSON_PUBLIC(void) JFree(void *p)
+{
+    _Free(p);
+}
+
+/* Internal constructor. */
+static J *JNew_Item(void)
+{
+    J* node = (J*)_Malloc(sizeof(J));
+    if (node) {
+        memset(node, '\0', sizeof(J));
+    }
+
+    return node;
+}
+
+/*!
+ @brief Free a `J` object.
+
+ @param item A pointer to the object.
+ */
+N_CJSON_PUBLIC(void) JDelete(J *item)
+{
+    J *next = NULL;
+    while (item != NULL) {
+        next = item->next;
+        if (!(item->type & JIsReference) && (item->child != NULL)) {
+            JDelete(item->child);
+        }
+        if (!(item->type & JIsReference) && (item->valuestring != NULL)) {
+            _Free(item->valuestring);
+        }
+        if (!(item->type & JStringIsConst) && (item->string != NULL)) {
+            _Free(item->string);
+        }
+        _Free(item);
+        item = next;
+    }
+}
+
+/* get the decimal point character of the current locale */
+static unsigned char get_decimal_point(void)
+{
+#ifdef ENABLE_LOCALES
+    struct lconv *lconv = localeconv();
+    return (unsigned char) lconv->decimal_point[0];
+#else
+    return '.';
+#endif
+}
+
+typedef struct {
+    const unsigned char *content;
+    size_t length;
+    size_t offset;
+    size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */
+} parse_buffer;
+
+/* check if the given size is left to read in a given parse buffer (starting with 1) */
+#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
+/* check if the buffer can be accessed at the given index (starting with 0) */
+#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
+#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
+/* get a pointer to the buffer at the position */
+#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
+
+/* Parse the input text to generate a number, and populate the result into item. */
+static Jbool parse_number(J * const item, parse_buffer * const input_buffer)
+{
+    JNUMBER number = 0;
+    unsigned char *after_end = NULL;
+    unsigned char number_c_string[64];
+    unsigned char decimal_point = get_decimal_point();
+    size_t i = 0;
+
+    if ((input_buffer == NULL) || (input_buffer->content == NULL)) {
+        return false;
+    }
+
+    /* copy the number into a temporary buffer and replace '.' with the decimal point
+     * of the current locale (for strtod)
+     * This also takes care of '\0' not necessarily being available for marking the end of the input */
+    for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) {
+        switch (buffer_at_offset(input_buffer)[i]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case '+':
+        case '-':
+        case 'e':
+        case 'E':
+            number_c_string[i] = buffer_at_offset(input_buffer)[i];
+            break;
+
+        case '.':
+            number_c_string[i] = decimal_point;
+            break;
+
+        default:
+            goto loop_end;
+        }
+    }
+loop_end:
+    number_c_string[i] = '\0';
+
+    number = JAtoN((const char*)number_c_string, (char**)&after_end);
+    if (number_c_string == after_end) {
+        return false; /* parse_error */
+    }
+    item->valuenumber = number;
+
+    // Saturate valueint in the case of overflow.
+    if (number >= JINTEGER_MAX) {
+        item->valueint = JINTEGER_MAX;
+    } else if (number <= JINTEGER_MIN) {
+        item->valueint = JINTEGER_MIN;
+    } else {
+        item->valueint = JAtoI((const char*)number_c_string);
+    }
+
+    item->type = JNumber;
+
+    input_buffer->offset += (size_t)(after_end - number_c_string);
+    return true;
+}
+
+/* don't ask me, but the original JSetNumberValue returns an integer or JNUMBER */
+N_CJSON_PUBLIC(JNUMBER) JSetNumberHelper(J *object, JNUMBER number)
+{
+    if (object == NULL) {
+        return number;
+    }
+
+    // Saturate valueint in the case of overflow.
+    if (number >= JINTEGER_MAX) {
+        object->valueint = JINTEGER_MAX;
+    } else if (number <= JINTEGER_MIN) {
+        object->valueint = JINTEGER_MIN;
+    } else {
+        object->valueint = (JINTEGER)number;
+    }
+
+    return object->valuenumber = number;
+}
+
+typedef struct {
+    unsigned char *buffer;
+    size_t length;
+    size_t offset;
+    size_t depth; /* current nesting depth (for formatted printing) */
+    Jbool noalloc;
+    Jbool format; /* is this print a formatted print */
+    Jbool omitempty;
+} printbuffer;
+
+/* realloc printbuffer if necessary to have at least "needed" bytes more */
+static unsigned char* ensure(printbuffer * const p, size_t needed)
+{
+    unsigned char *newbuffer = NULL;
+    size_t newsize = 0;
+
+    if ((p == NULL) || (p->buffer == NULL)) {
+        return NULL;
+    }
+
+    if ((p->length > 0) && (p->offset >= p->length)) {
+        /* make sure that offset is valid */
+        return NULL;
+    }
+
+    if (needed > INT_MAX) {
+        /* sizes bigger than INT_MAX are currently not supported */
+        return NULL;
+    }
+
+    needed += p->offset + 1;
+    if (needed <= p->length) {
+        return p->buffer + p->offset;
+    }
+
+    if (p->noalloc) {
+        return NULL;
+    }
+
+    /* calculate new buffer size */
+    if (needed > (INT_MAX / 2)) {
+        /* overflow of int, use INT_MAX if possible */
+        if (needed <= INT_MAX) {
+            newsize = INT_MAX;
+        } else {
+            return NULL;
+        }
+    } else {
+        newsize = needed * 2;
+    }
+
+    /* otherwise reallocate manually */
+    newbuffer = (unsigned char*)_Malloc(newsize);
+    if (!newbuffer) {
+        _Free(p->buffer);
+        p->length = 0;
+        p->buffer = NULL;
+        return NULL;
+    }
+    if (newbuffer) {
+        memcpy(newbuffer, p->buffer, p->offset + 1);
+    }
+    _Free(p->buffer);
+
+    p->length = newsize;
+    p->buffer = newbuffer;
+
+    return newbuffer + p->offset;
+}
+
+/* calculate the new length of the string in a printbuffer and update the offset */
+static void update_offset(printbuffer * const buffer)
+{
+    const unsigned char *buffer_pointer = NULL;
+    if ((buffer == NULL) || (buffer->buffer == NULL)) {
+        return;
+    }
+    buffer_pointer = buffer->buffer + buffer->offset;
+
+    buffer->offset += strlen((const char*)buffer_pointer);
+}
+
+/* Render the number nicely from the given item into a string. */
+static Jbool print_number(const J * const item, printbuffer * const output_buffer)
+{
+    if (item == NULL) {
+        return false;
+    }
+
+    unsigned char *output_pointer = NULL;
+    JNUMBER vnum = item->valuenumber;
+    JINTEGER vint = item->valueint;
+    int length = 0;
+    size_t i = 0;
+    unsigned char number_buffer[JNTOA_MAX]; /* temporary buffer to print the number into */
+    unsigned char decimal_point = get_decimal_point();
+
+    if (output_buffer == NULL) {
+        return false;
+    }
+
+    /* This checks for NaN and Infinity */
+    if ((vnum * 0) != 0) {
+        char *nbuf = (char *) number_buffer;
+        strlcpy(nbuf, "null", JNTOA_MAX);
+        length = strlen(nbuf);
+    } else {
+        char *nbuf = (char *) number_buffer;
+
+        if (vnum != (JNUMBER)vint) {
+            JNtoA(vnum, nbuf, -1);
+        } else {
+            JItoA(vint, nbuf);
+        }
+
+        length = strlen(nbuf);
+    }
+
+    /* conversion failed or buffer overrun occured */
+    if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) {
+        return false;
+    }
+
+    /* reserve appropriate space in the output */
+    output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
+    if (output_pointer == NULL) {
+        return false;
+    }
+
+    /* copy the printed number to the output and replace locale
+     * dependent decimal point with '.' */
+    for (i = 0; i < ((size_t)length); i++) {
+        if (number_buffer[i] == decimal_point) {
+            output_pointer[i] = '.';
+            continue;
+        }
+
+        output_pointer[i] = number_buffer[i];
+    }
+    output_pointer[i] = '\0';
+
+    output_buffer->offset += (size_t)length;
+
+    return true;
+}
+
+/* parse 4 digit hexadecimal number */
+static unsigned long parse_hex4(const unsigned char * const input)
+{
+    unsigned long int h = 0;
+    size_t i = 0;
+
+    for (i = 0; i < 4; i++) {
+        /* parse digit */
+        if ((input[i] >= '0') && (input[i] <= '9')) {
+            h += (unsigned int) input[i] - '0';
+        } else if ((input[i] >= 'A') && (input[i] <= 'F')) {
+            h += (unsigned int) 10 + input[i] - 'A';
+        } else if ((input[i] >= 'a') && (input[i] <= 'f')) {
+            h += (unsigned int) 10 + input[i] - 'a';
+        } else { /* invalid */
+            return 0;
+        }
+
+        if (i < 3) {
+            /* shift left to make place for the next nibble */
+            h = h << 4;
+        }
+    }
+
+    return h;
+}
+
+/* converts a UTF-16 literal to UTF-8
+ * A literal can be one or two sequences of the form \uXXXX */
+static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
+{
+    long unsigned int codepoint = 0;
+    unsigned long int first_code = 0;
+    const unsigned char *first_sequence = input_pointer;
+    unsigned char utf8_length = 0;
+    unsigned char utf8_position = 0;
+    unsigned char sequence_length = 0;
+    unsigned char first_byte_mark = 0;
+
+    if ((input_end - first_sequence) < 6) {
+        /* input ends unexpectedly */
+        goto fail;
+    }
+
+    /* get the first utf16 sequence */
+    first_code = parse_hex4(first_sequence + 2);
+
+    /* check that the code is valid */
+    if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) {
+        goto fail;
+    }
+
+    /* UTF16 surrogate pair */
+    if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) {
+        const unsigned char *second_sequence = first_sequence + 6;
+        unsigned int second_code = 0;
+        sequence_length = 12; /* \uXXXX\uXXXX */
+
+        if ((input_end - second_sequence) < 6) {
+            /* input ends unexpectedly */
+            goto fail;
+        }
+
+        if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) {
+            /* missing second half of the surrogate pair */
+            goto fail;
+        }
+
+        /* get the second utf16 sequence */
+        second_code = parse_hex4(second_sequence + 2);
+        /* check that the code is valid */
+        if ((second_code < 0xDC00) || (second_code > 0xDFFF)) {
+            /* invalid second half of the surrogate pair */
+            goto fail;
+        }
+
+
+        /* calculate the unicode codepoint from the surrogate pair */
+        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
+    } else {
+        sequence_length = 6; /* \uXXXX */
+        codepoint = first_code;
+    }
+
+    /* encode as UTF-8
+     * takes at maximum 4 bytes to encode:
+     * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+    if (codepoint < 0x80) {
+        /* normal ascii, encoding 0xxxxxxx */
+        utf8_length = 1;
+    } else if (codepoint < 0x800) {
+        /* two bytes, encoding 110xxxxx 10xxxxxx */
+        utf8_length = 2;
+        first_byte_mark = 0xC0; /* 11000000 */
+    } else if (codepoint < 0x10000) {
+        /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
+        utf8_length = 3;
+        first_byte_mark = 0xE0; /* 11100000 */
+    } else if (codepoint <= 0x10FFFF) {
+        /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
+        utf8_length = 4;
+        first_byte_mark = 0xF0; /* 11110000 */
+    } else {
+        /* invalid unicode codepoint */
+        goto fail;
+    }
+
+    /* encode as utf8 */
+    for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) {
+        /* 10xxxxxx */
+        (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
+        codepoint >>= 6;
+    }
+    /* encode first byte */
+    if (utf8_length > 1) {
+        (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
+    } else {
+        (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
+    }
+
+    *output_pointer += utf8_length;
+
+    return sequence_length;
+
+fail:
+    return 0;
+}
+
+/* Parse the input text into an unescaped cinput, and populate item. */
+static Jbool parse_string(J * const item, parse_buffer * const input_buffer)
+{
+    const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
+    const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
+    unsigned char *output_pointer = NULL;
+    unsigned char *output = NULL;
+
+    /* not a string */
+    if (buffer_at_offset(input_buffer)[0] != '\"') {
+        goto fail;
+    }
+
+    {
+        /* calculate approximate size of the output (overestimate) */
+        size_t allocation_length = 0;
+        size_t skipped_bytes = 0;
+        while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) {
+            /* is escape sequence */
+            if (input_end[0] == '\\') {
+                if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) {
+                    /* prevent buffer overflow when last input character is a backslash */
+                    goto fail;
+                }
+                skipped_bytes++;
+                input_end++;
+            }
+            input_end++;
+        }
+        if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) {
+            goto fail; /* string ended unexpectedly */
+        }
+
+        /* This is at most how much we need for the output */
+        allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
+        output = (unsigned char*)_Malloc(allocation_length + 1);  // trailing '\0'
+        if (output == NULL) {
+            goto fail; /* allocation failure */
+        }
+    }
+
+    output_pointer = output;
+    /* loop through the string literal */
+    while (input_pointer < input_end) {
+        if (*input_pointer != '\\') {
+            *output_pointer++ = *input_pointer++;
+        }
+        /* escape sequence */
+        else {
+            unsigned char sequence_length = 2;
+            if ((input_end - input_pointer) < 1) {
+                goto fail;
+            }
+
+            switch (input_pointer[1]) {
+            case 'b':
+                *output_pointer++ = '\b';
+                break;
+            case 'f':
+                *output_pointer++ = '\f';
+                break;
+            case 'n':
+                *output_pointer++ = '\n';
+                break;
+            case 'r':
+                *output_pointer++ = '\r';
+                break;
+            case 't':
+                *output_pointer++ = '\t';
+                break;
+            case '\"':
+            case '\\':
+            case '/':
+                *output_pointer++ = input_pointer[1];
+                break;
+
+            /* UTF-16 literal */
+            case 'u':
+                sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
+                if (sequence_length == 0) {
+                    /* failed to convert UTF16-literal to UTF-8 */
+                    goto fail;
+                }
+                break;
+
+            default:
+                goto fail;
+            }
+            input_pointer += sequence_length;
+        }
+    }
+
+    /* zero terminate the output */
+    *output_pointer = '\0';
+
+    item->type = JString;
+    item->valuestring = (char*)output;
+
+    input_buffer->offset = (size_t) (input_end - input_buffer->content);
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (output != NULL) {
+        _Free(output);
+    }
+
+    if (input_pointer != NULL) {
+        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
+    }
+
+    return false;
+}
+
+/* Convert a 16-bit number to 4 hex digits, null-terminating it */
+void n_htoa16(uint16_t n, unsigned char *p)
+{
+    int i;
+    for (i=0; i<4; i++) {
+        uint16_t nibble = (n >> 12) & 0xff;
+        n = n << 4;
+        if (nibble >= 10) {
+            *p++ = 'A' + (nibble-10);
+        } else {
+            *p++ = '0' + nibble;
+        }
+    }
+    *p = '\0';
+}
+
+/* Render the cstring provided to an escaped version that can be printed. */
+static Jbool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
+{
+    const unsigned char *input_pointer = NULL;
+    unsigned char *output = NULL;
+    unsigned char *output_pointer = NULL;
+    size_t output_length = 0;
+    /* numbers of additional characters needed for escaping */
+    size_t escape_characters = 0;
+
+    if (output_buffer == NULL) {
+        return false;
+    }
+
+    /* empty string */
+    if (input == NULL) {
+        output = ensure(output_buffer, 2);  // sizeof("\"\"")
+        if (output == NULL) {
+            return false;
+        }
+        output[0] = '"';
+        output[1] = '"';
+        output[2] = '\0';
+
+        return true;
+    }
+
+    /* set "flag" to 1 if something needs to be escaped */
+    for (input_pointer = input; *input_pointer; input_pointer++) {
+        switch (*input_pointer) {
+        case '\"':
+        case '\\':
+        case '\b':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\t':
+            /* one character escape sequence */
+            escape_characters++;
+            break;
+        default:
+            if (*input_pointer < 32) {
+                /* UTF-16 escape sequence uXXXX */
+                escape_characters += 5;
+            }
+            break;
+        }
+    }
+    output_length = (size_t)(input_pointer - input) + escape_characters;
+
+    output = ensure(output_buffer, output_length + 2);  // sizeof("\"\"")
+    if (output == NULL) {
+        return false;
+    }
+
+    /* no characters have to be escaped */
+    if (escape_characters == 0) {
+        output[0] = '\"';
+        memcpy(output + 1, input, output_length);
+        output[output_length + 1] = '\"';
+        output[output_length + 2] = '\0';
+
+        return true;
+    }
+
+    output[0] = '\"';
+    output_pointer = output + 1;
+    /* copy the string */
+    for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) {
+        if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) {
+            /* normal character, copy */
+            *output_pointer = *input_pointer;
+        } else {
+            /* character needs to be escaped */
+            *output_pointer++ = '\\';
+            switch (*input_pointer) {
+            case '\\':
+                *output_pointer = '\\';
+                break;
+            case '\"':
+                *output_pointer = '\"';
+                break;
+            case '\b':
+                *output_pointer = 'b';
+                break;
+            case '\f':
+                *output_pointer = 'f';
+                break;
+            case '\n':
+                *output_pointer = 'n';
+                break;
+            case '\r':
+                *output_pointer = 'r';
+                break;
+            case '\t':
+                *output_pointer = 't';
+                break;
+            default:
+                /* escape and print as unicode codepoint */
+                *output_pointer++ = 'u';
+                n_htoa16(*input_pointer, output_pointer);
+                output_pointer += 4;
+                break;
+            }
+        }
+    }
+    output[output_length + 1] = '\"';
+    output[output_length + 2] = '\0';
+
+    return true;
+}
+
+/* Invoke print_string_ptr (which is useful) on an item. */
+static Jbool print_string(const J * const item, printbuffer * const p)
+{
+    return print_string_ptr((unsigned char*)item->valuestring, p);
+}
+
+/* Predeclare these prototypes. */
+static Jbool parse_value(J * const item, parse_buffer * const input_buffer);
+static Jbool print_value(const J * const item, printbuffer * const output_buffer);
+static Jbool parse_array(J * const item, parse_buffer * const input_buffer);
+static Jbool print_array(const J * const item, printbuffer * const output_buffer);
+static Jbool parse_object(J * const item, parse_buffer * const input_buffer);
+static Jbool print_object(const J * const item, printbuffer * const output_buffer);
+
+/* Utility to jump whitespace and cr/lf */
+static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL)) {
+        return NULL;
+    }
+
+    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) {
+        buffer->offset++;
+    }
+
+    if (buffer->offset == buffer->length) {
+        buffer->offset--;
+    }
+
+    return buffer;
+}
+
+/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */
+static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
+{
+    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) {
+        return NULL;
+    }
+
+    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) {
+        buffer->offset += 3;
+    }
+
+    return buffer;
+}
+
+/* Parse an object - create a new root, and populate. */
+N_CJSON_PUBLIC(J *) JParseWithOpts(const char *value, const char **return_parse_end, Jbool require_null_terminated)
+{
+    parse_buffer buffer = { 0, 0, 0, 0 };
+    J *item = NULL;
+
+    /* reset error position */
+    global_error.json = NULL;
+    global_error.position = 0;
+
+    if (value == NULL) {
+        goto fail;
+    }
+
+    buffer.content = (const unsigned char*)value;
+    buffer.length = strlen((const char*)value) + 1;   // Trailing '\0'
+    buffer.offset = 0;
+
+    item = JNew_Item();
+    if (item == NULL) { /* memory fail */
+        goto fail;
+    }
+
+    if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) {
+        /* parse failure. ep is set. */
+        goto fail;
+    }
+
+    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
+    if (require_null_terminated) {
+        buffer_skip_whitespace(&buffer);
+        if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') {
+            goto fail;
+        }
+    }
+    if (return_parse_end) {
+        *return_parse_end = (const char*)buffer_at_offset(&buffer);
+    }
+
+    return item;
+
+fail:
+    if (item != NULL) {
+        JDelete(item);
+    }
+
+    if (value != NULL) {
+        error local_error;
+        local_error.json = (const unsigned char*)value;
+        local_error.position = 0;
+
+        if (buffer.offset < buffer.length) {
+            local_error.position = buffer.offset;
+        } else if (buffer.length > 0) {
+            local_error.position = buffer.length - 1;
+        }
+
+        if (return_parse_end != NULL) {
+            *return_parse_end = (const char*)local_error.json + local_error.position;
+        }
+
+        global_error = local_error;
+    }
+
+    return NULL;
+}
+
+/*!
+ @brief Parse the passed in C-string as JSON and return a `J` object
+        representing it.
+
+ @param value The JSON object as a C-string.
+
+ @returns A `J` object or NULL on error (e.g. the string was invalid JSON).
+ */
+N_CJSON_PUBLIC(J *) JParse(const char *value)
+{
+    return JParseWithOpts(value, 0, 0);
+}
+
+#define cjson_min(a, b) ((a < b) ? a : b)
+
+static unsigned char *print(const J * const item, Jbool format, Jbool omitempty)
+{
+    static const size_t default_buffer_size = 128;
+    printbuffer buffer[1];
+    unsigned char *printed = NULL;
+
+    memset(buffer, 0, sizeof(buffer));
+
+    /* create buffer */
+    buffer->buffer = (unsigned char*) _Malloc(default_buffer_size);
+    buffer->length = default_buffer_size;
+    buffer->format = format;
+    buffer->omitempty = omitempty;
+    if (buffer->buffer == NULL) {
+        goto fail;
+    }
+
+    /* print the value */
+    if (!print_value(item, buffer)) {
+        goto fail;
+    }
+    update_offset(buffer);
+
+    /* copy the JSON over to a new buffer */
+    printed = (unsigned char*) _Malloc(buffer->offset + 1);
+    if (printed == NULL) {
+        goto fail;
+    }
+    memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
+    printed[buffer->offset] = '\0'; /* just to be sure */
+
+    /* free the buffer */
+    _Free(buffer->buffer);
+
+    return printed;
+
+fail:
+    if (buffer->buffer != NULL) {
+        _Free(buffer->buffer);
+    }
+
+    if (printed != NULL) {
+        _Free(printed);
+    }
+
+    return NULL;
+}
+
+/* Render a J item/entity/structure to text. */
+N_CJSON_PUBLIC(char *) JPrint(const J *item)
+{
+    if (item == NULL) {
+        return NULL;
+    }
+    return (char*)print(item, true, false);
+}
+
+/*!
+ @brief Get the unformatted string representation of a `J` object.
+
+ The string returned by this function is dynamically allocated and MUST be freed
+ by the caller with `JFree`. Unformatted means that the minimum JSON string
+ is produced, without any additional whitespace.
+
+ @param item The JSON object to get the unformatted string representation of.
+
+ @returns The string or NULL on error.
+ */
+N_CJSON_PUBLIC(char *) JPrintUnformatted(const J *item)
+{
+    if (item == NULL) {
+        return NULL;
+    }
+    return (char*)print(item, false, false);
+}
+
+N_CJSON_PUBLIC(char *) JPrintUnformattedOmitEmpty(const J *item)
+{
+    if (item == NULL) {
+        return NULL;
+    }
+    return (char*)print(item, false, true);
+}
+
+N_CJSON_PUBLIC(char *) JPrintBuffered(const J *item, int prebuffer, Jbool fmt)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, 0 };
+
+    if (item == NULL) {
+        return NULL;
+    }
+
+    if (prebuffer < 0) {
+        return NULL;
+    }
+
+    p.buffer = (unsigned char*)_Malloc((size_t)prebuffer);
+    if (!p.buffer) {
+        return NULL;
+    }
+
+    p.length = (size_t)prebuffer;
+    p.offset = 0;
+    p.noalloc = false;
+    p.format = fmt;
+
+    if (!print_value(item, &p)) {
+        _Free(p.buffer);
+        return NULL;
+    }
+
+    return (char*)p.buffer;
+}
+
+static Jbool printPreallocated(J *item, char *buf, const int len, const Jbool fmt, const Jbool omit)
+{
+    printbuffer p = { 0, 0, 0, 0, 0, 0, 0 };
+
+    if (item == NULL) {
+        return false;
+    }
+    if ((len < 0) || (buf == NULL)) {
+        return false;
+    }
+
+    p.buffer = (unsigned char*)buf;
+    p.length = (size_t)len;
+    p.offset = 0;
+    p.noalloc = true;
+    p.format = fmt;
+    p.omitempty = omit;
+
+    return print_value(item, &p);
+}
+
+N_CJSON_PUBLIC(Jbool) JPrintPreallocatedOmitEmpty(J *item, char *buf, const int len, const Jbool fmt)
+{
+    return printPreallocated(item, buf, len, fmt, true);
+}
+
+N_CJSON_PUBLIC(Jbool) JPrintPreallocated(J *item, char *buf, const int len, const Jbool fmt)
+{
+    return printPreallocated(item, buf, len, fmt, false);
+}
+
+/* Parser core - when encountering text, process appropriately. */
+static Jbool parse_value(J * const item, parse_buffer * const input_buffer)
+{
+    if (item == NULL) {
+        return false;
+    }
+    if ((input_buffer == NULL) || (input_buffer->content == NULL)) {
+        return false; /* no input */
+    }
+
+    /* parse the different types of values */
+    /* null */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), c_null, c_null_len) == 0)) {
+        item->type = JNULL;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* false */
+    if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), c_false, c_false_len) == 0)) {
+        item->type = JFalse;
+        input_buffer->offset += 5;
+        return true;
+    }
+    /* true */
+    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), c_true, c_true_len) == 0)) {
+        item->type = JTrue;
+        item->valueint = 1;
+        input_buffer->offset += 4;
+        return true;
+    }
+    /* string */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) {
+        return parse_string(item, input_buffer);
+    }
+    /* number */
+    if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) {
+        return parse_number(item, input_buffer);
+    }
+    /* array */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) {
+        return parse_array(item, input_buffer);
+    }
+    /* object */
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) {
+        return parse_object(item, input_buffer);
+    }
+
+    return false;
+}
+
+/* Render a value to text. */
+static Jbool print_value(const J * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output = NULL;
+
+    if ((item == NULL) || (output_buffer == NULL)) {
+        return false;
+    }
+
+    switch ((item->type) & 0xFF) {
+    case JNULL:
+        output = ensure(output_buffer, c_null_len+1);
+        if (output == NULL) {
+            return false;
+        }
+        strlcpy((char*)output, c_null, c_null_len+1);
+        return true;
+
+    case JFalse:
+        output = ensure(output_buffer, c_false_len+1);
+        if (output == NULL) {
+            return false;
+        }
+        strlcpy((char*)output, c_false, c_false_len+1);
+        return true;
+
+    case JTrue:
+        output = ensure(output_buffer, c_true_len+1);
+        if (output == NULL) {
+            return false;
+        }
+        strlcpy((char*)output, c_true, c_true_len+1);
+        return true;
+
+    case JNumber:
+        return print_number(item, output_buffer);
+
+    case JRaw: {
+        size_t raw_length = 0;
+        if (item->valuestring == NULL) {
+            return false;
+        }
+
+        raw_length = strlen(item->valuestring) + 1;   // Trailing '\0';
+        output = ensure(output_buffer, raw_length);
+        if (output == NULL) {
+            return false;
+        }
+        memcpy(output, item->valuestring, raw_length);
+        return true;
+    }
+
+    case JString:
+        return print_string(item, output_buffer);
+
+    case JArray:
+        return print_array(item, output_buffer);
+
+    case JObject:
+        return print_object(item, output_buffer);
+
+    default:
+        return false;
+    }
+}
+
+/* Build an array from input text. */
+static Jbool parse_array(J * const item, parse_buffer * const input_buffer)
+{
+    J *head = NULL; /* head of the linked list */
+    J *current_item = NULL;
+
+    if (input_buffer->depth >= N_CJSON_NESTING_LIMIT) {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (buffer_at_offset(input_buffer)[0] != '[') {
+        /* not an array */
+        goto fail;
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) {
+        /* empty array */
+        goto success;
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0)) {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do {
+        /* allocate next item */
+        J *new_item = JNew_Item();
+        if (new_item == NULL) {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL) {
+            /* start the linked list */
+            current_item = head = new_item;
+        } else {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        /* parse next value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer)) {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    } while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') {
+        goto fail; /* expected end of array */
+    }
+
+success:
+    input_buffer->depth--;
+
+    item->type = JArray;
+    item->child = head;
+
+    input_buffer->offset++;
+
+    return true;
+
+fail:
+    if (head != NULL) {
+        JDelete(head);
+    }
+
+    return false;
+}
+
+/* Render an array to text */
+static Jbool print_array(const J * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    J *current_element = item->child;
+
+    if (output_buffer == NULL) {
+        return false;
+    }
+
+    /* Compose the output array. */
+    /* opening square bracket */
+    output_pointer = ensure(output_buffer, 1);
+    if (output_pointer == NULL) {
+        return false;
+    }
+
+    *output_pointer = '[';
+    output_buffer->offset++;
+    output_buffer->depth++;
+
+    while (current_element != NULL) {
+        if (!print_value(current_element, output_buffer)) {
+            return false;
+        }
+        update_offset(output_buffer);
+        if (current_element->next) {
+            length = (size_t) (output_buffer->format ? 2 : 1);
+            output_pointer = ensure(output_buffer, length + 1);
+            if (output_pointer == NULL) {
+                return false;
+            }
+            *output_pointer++ = ',';
+            if(output_buffer->format) {
+                *output_pointer++ = ' ';
+            }
+            *output_pointer = '\0';
+            output_buffer->offset += length;
+        }
+        current_element = current_element->next;
+    }
+
+    output_pointer = ensure(output_buffer, 2);
+    if (output_pointer == NULL) {
+        return false;
+    }
+    *output_pointer++ = ']';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Build an object from the text. */
+static Jbool parse_object(J * const item, parse_buffer * const input_buffer)
+{
+    J *head = NULL; /* linked list head */
+    J *current_item = NULL;
+
+    if (input_buffer->depth >= N_CJSON_NESTING_LIMIT) {
+        return false; /* to deeply nested */
+    }
+    input_buffer->depth++;
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) {
+        goto fail; /* not an object */
+    }
+
+    input_buffer->offset++;
+    buffer_skip_whitespace(input_buffer);
+    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) {
+        goto success; /* empty object */
+    }
+
+    /* check if we skipped to the end of the buffer */
+    if (cannot_access_at_index(input_buffer, 0)) {
+        input_buffer->offset--;
+        goto fail;
+    }
+
+    /* step back to character in front of the first element */
+    input_buffer->offset--;
+    /* loop through the comma separated array elements */
+    do {
+        /* allocate next item */
+        J *new_item = JNew_Item();
+        if (new_item == NULL) {
+            goto fail; /* allocation failure */
+        }
+
+        /* attach next item to list */
+        if (head == NULL) {
+            /* start the linked list */
+            current_item = head = new_item;
+        } else {
+            /* add to the end and advance */
+            current_item->next = new_item;
+            new_item->prev = current_item;
+            current_item = new_item;
+        }
+
+        /* parse the name of the child */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_string(current_item, input_buffer)) {
+            goto fail; /* faile to parse name */
+        }
+        buffer_skip_whitespace(input_buffer);
+
+        /* swap valuestring and string, because we parsed the name */
+        current_item->string = current_item->valuestring;
+        current_item->valuestring = NULL;
+
+        if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) {
+            goto fail; /* invalid object */
+        }
+
+        /* parse the value */
+        input_buffer->offset++;
+        buffer_skip_whitespace(input_buffer);
+        if (!parse_value(current_item, input_buffer)) {
+            goto fail; /* failed to parse value */
+        }
+        buffer_skip_whitespace(input_buffer);
+    } while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
+
+    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) {
+        goto fail; /* expected end of object */
+    }
+
+success:
+    input_buffer->depth--;
+
+    item->type = JObject;
+    item->child = head;
+
+    input_buffer->offset++;
+    return true;
+
+fail:
+    if (head != NULL) {
+        JDelete(head);
+    }
+
+    return false;
+}
+
+/* See if there is another non-omitted item looking forward */
+static bool last_non_omitted_object(J * item, printbuffer * const output_buffer)
+{
+    if (!output_buffer->omitempty) {
+        return (item->next == 0);
+    }
+    while (item->next != 0) {
+        item = item->next;
+        int type = JGetItemType(item);
+        if (type != JTYPE_BOOL_FALSE && type != JTYPE_NUMBER_ZERO && type != JTYPE_STRING_BLANK) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/* Render an object to text. */
+static Jbool print_object(const J * const item, printbuffer * const output_buffer)
+{
+    unsigned char *output_pointer = NULL;
+    size_t length = 0;
+    J *current_item = item->child;
+
+    if (output_buffer == NULL) {
+        return false;
+    }
+
+    /* Compose the output: */
+    length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
+    output_pointer = ensure(output_buffer, length + 1);
+    if (output_pointer == NULL) {
+        return false;
+    }
+
+    *output_pointer++ = '{';
+    output_buffer->depth++;
+    if (output_buffer->format) {
+        *output_pointer++ = '\n';
+    }
+    output_buffer->offset += length;
+
+    while (current_item) {
+        if (output_buffer->format) {
+            size_t i;
+#if (PRINT_TAB_CHARS == 0)
+            int needed = output_buffer->depth;
+#else
+            int needed = output_buffer->depth * PRINT_TAB_CHARS;
+#endif
+            output_pointer = ensure(output_buffer, needed);
+            if (output_pointer == NULL) {
+                return false;
+            }
+            for (i = 0; i < output_buffer->depth; i++) {
+#if (PRINT_TAB_CHARS == 0)
+                *output_pointer++ = '\t';
+                output_buffer_offset++;
+#else
+                for (int tc=0; tc<PRINT_TAB_CHARS; tc++) {
+                    *output_pointer++ = ' ';
+                    output_buffer->offset++;
+                }
+#endif
+            }
+        }
+
+        /* See if it should be eliminated becase of omitempty */
+        bool omit = false;
+        if (output_buffer->omitempty) {
+            int type = JGetItemType(current_item);
+            omit =(type == JTYPE_BOOL_FALSE || type == JTYPE_NUMBER_ZERO || type == JTYPE_STRING_BLANK);
+        }
+
+        /* print item only if not omitted */
+        if (!omit) {
+
+            /* print key */
+            if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) {
+                return false;
+            }
+            update_offset(output_buffer);
+
+            length = (size_t) (output_buffer->format ? 2 : 1);
+            output_pointer = ensure(output_buffer, length);
+            if (output_pointer == NULL) {
+                return false;
+            }
+            *output_pointer++ = ':';
+            if (output_buffer->format) {
+#if (PRINT_TAB_CHARS == 0)
+                *output_pointer++ = '\t';
+#else
+                *output_pointer++ = ' ';
+#endif
+            }
+            output_buffer->offset += length;
+
+            /* print value */
+            if (!print_value(current_item, output_buffer)) {
+                return false;
+            }
+            update_offset(output_buffer);
+
+            /* print comma if not last */
+            bool more_fields_coming = !last_non_omitted_object(current_item, output_buffer);
+            length = (size_t) ((output_buffer->format ? 1 : 0) + (more_fields_coming ? 1 : 0));
+            output_pointer = ensure(output_buffer, length + 1);
+            if (output_pointer == NULL) {
+                return false;
+            }
+            if (more_fields_coming) {
+                *output_pointer++ = ',';
+            }
+
+            if (output_buffer->format) {
+                *output_pointer++ = '\n';
+            }
+            *output_pointer = '\0';
+            output_buffer->offset += length;
+        }
+
+        current_item = current_item->next;
+    }
+
+#if (PRINT_TAB_CHARS == 0)
+    int needed = output_buffer->format ? (output_buffer->depth - 1) : 0;
+#else
+    int needed = output_buffer->format ? ((output_buffer->depth - 1) * PRINT_TAB_CHARS) : 0;
+#endif
+    needed += 2; // }\0
+    output_pointer = ensure(output_buffer, needed);
+    if (output_pointer == NULL) {
+        return false;
+    }
+    if (output_buffer->format) {
+        size_t i;
+        for (i = 0; i < (output_buffer->depth - 1); i++) {
+#if (PRINT_TAB_CHARS == 0)
+            *output_pointer++ = '\t';
+#else
+            for (int tc=0; tc<PRINT_TAB_CHARS; tc++) {
+                *output_pointer++ = ' ';
+            }
+#endif
+        }
+    }
+    *output_pointer++ = '}';
+    *output_pointer = '\0';
+    output_buffer->depth--;
+
+    return true;
+}
+
+/* Get Array size/item / object item. */
+N_CJSON_PUBLIC(int) JGetArraySize(const J *array)
+{
+    J *child = NULL;
+    size_t size = 0;
+
+    if (array == NULL) {
+        return 0;
+    }
+
+    child = array->child;
+
+    while(child != NULL) {
+        size++;
+        child = child->next;
+    }
+
+    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */
+
+    return (int)size;
+}
+
+static J* get_array_item(const J *array, size_t index)
+{
+    J *current_child = NULL;
+
+    if (array == NULL) {
+        return NULL;
+    }
+
+    current_child = array->child;
+    while ((current_child != NULL) && (index > 0)) {
+        index--;
+        current_child = current_child->next;
+    }
+
+    return current_child;
+}
+
+N_CJSON_PUBLIC(J *) JGetArrayItem(const J *array, int index)
+{
+    if (array == NULL) {
+        return NULL;
+    }
+    if (index < 0) {
+        return NULL;
+    }
+
+    return get_array_item(array, (size_t)index);
+}
+
+static J *get_object_item(const J * const object, const char * const name, const Jbool case_sensitive)
+{
+    J *current_element = NULL;
+
+    if ((object == NULL) || (name == NULL)) {
+        return NULL;
+    }
+
+    current_element = object->child;
+    if (case_sensitive) {
+        while ((current_element != NULL) && (strcmp(name, current_element->string) != 0)) {
+            current_element = current_element->next;
+        }
+    } else {
+        while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) {
+            current_element = current_element->next;
+        }
+    }
+
+    return current_element;
+}
+
+N_CJSON_PUBLIC(J *) JGetObjectItem(const J * const object, const char * const string)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+    return get_object_item(object, string, false);
+}
+
+N_CJSON_PUBLIC(J *) JGetObjectItemCaseSensitive(const J * const object, const char * const string)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+    return get_object_item(object, string, true);
+}
+
+N_CJSON_PUBLIC(Jbool) JHasObjectItem(const J *object, const char *string)
+{
+    if (object == NULL) {
+        return false;
+    }
+    return JGetObjectItem(object, string) ? 1 : 0;
+}
+
+/* Utility for array list handling. */
+static void suffix_object(J *prev, J *item)
+{
+    prev->next = item;
+    item->prev = prev;
+}
+
+/* Utility for handling references. */
+static J *create_reference(const J *item)
+{
+    J *reference = NULL;
+    if (item == NULL) {
+        return NULL;
+    }
+
+    reference = JNew_Item();
+    if (reference == NULL) {
+        return NULL;
+    }
+
+    memcpy(reference, item, sizeof(J));
+    reference->string = NULL;
+    reference->type |= JIsReference;
+    reference->next = reference->prev = NULL;
+    return reference;
+}
+
+static Jbool add_item_to_array(J *array, J *item)
+{
+    J *child = NULL;
+
+    if ((item == NULL) || (array == NULL)) {
+        return false;
+    }
+
+    child = array->child;
+
+    if (child == NULL) {
+        /* list is empty, start new one */
+        array->child = item;
+    } else {
+        /* append to the end */
+        while (child->next) {
+            child = child->next;
+        }
+        suffix_object(child, item);
+    }
+
+    return true;
+}
+
+/* Add item to array/object. */
+N_CJSON_PUBLIC(void) JAddItemToArray(J *array, J *item)
+{
+    if (array == NULL || item == NULL) {
+        return;
+    }
+    add_item_to_array(array, item);
+}
+
+#if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+#pragma GCC diagnostic push
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#endif
+/* helper function to cast away const */
+static void* cast_away_const(const void* string)
+{
+    return (void*)string;
+}
+#if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
+#pragma GCC diagnostic pop
+#endif
+
+
+static Jbool add_item_to_object(J * const object, const char * const string, J * const item, const Jbool constant_key)
+{
+    char *new_key = NULL;
+    int new_type = JInvalid;
+
+    if ((object == NULL) || (string == NULL) || (item == NULL)) {
+        return false;
+    }
+
+    if (constant_key) {
+        new_key = (char*)cast_away_const(string);
+        new_type = item->type | JStringIsConst;
+    } else {
+        new_key = (char*)Jstrdup((const unsigned char*)string);
+        if (new_key == NULL) {
+            return false;
+        }
+
+        new_type = item->type & ~JStringIsConst;
+    }
+
+    if (!(item->type & JStringIsConst) && (item->string != NULL)) {
+        _Free(item->string);
+    }
+
+    item->string = new_key;
+    item->type = new_type;
+
+    return add_item_to_array(object, item);
+}
+
+N_CJSON_PUBLIC(void) JAddItemToObject(J *object, const char *string, J *item)
+{
+    if (object == NULL || string == NULL || item == NULL) {
+        return;
+    }
+    add_item_to_object(object, string, item, false);
+}
+
+/* Add an item to an object with constant string as key */
+N_CJSON_PUBLIC(void) JAddItemToObjectCS(J *object, const char *string, J *item)
+{
+    if (object == NULL || string == NULL || item == NULL) {
+        return;
+    }
+    add_item_to_object(object, string, item, true);
+}
+
+N_CJSON_PUBLIC(void) JAddItemReferenceToArray(J *array, J *item)
+{
+    if (array == NULL || item == NULL) {
+        return;
+    }
+    add_item_to_array(array, create_reference(item));
+}
+
+N_CJSON_PUBLIC(void) JAddItemReferenceToObject(J *object, const char *string, J *item)
+{
+    if (object == NULL || string == NULL || item == NULL) {
+        return;
+    }
+    add_item_to_object(object, string, create_reference(item), false);
+}
+
+N_CJSON_PUBLIC(J*) JAddTrueToObject(J * const object, const char * const name)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *true_item = JCreateTrue();
+    if (add_item_to_object(object, name, true_item, false)) {
+        return true_item;
+    }
+
+    JDelete(true_item);
+    return NULL;
+}
+
+N_CJSON_PUBLIC(J*) JAddFalseToObject(J * const object, const char * const name)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *false_item = JCreateFalse();
+    if (add_item_to_object(object, name, false_item, false)) {
+        return false_item;
+    }
+
+    JDelete(false_item);
+    return NULL;
+}
+
+/*!
+ @brief Add a boolean field to a `J` object.
+
+ @param object The object to add the field to.
+ @param name The name of the field.
+ @param boolean The value of the field.
+
+ @returns A pointer to the newly-added boolean field or NULL on error.
+ */
+N_CJSON_PUBLIC(J*) JAddBoolToObject(J * const object, const char * const name, const Jbool boolean)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *bool_item = JCreateBool(boolean);
+    if (add_item_to_object(object, name, bool_item, false)) {
+        return bool_item;
+    }
+
+    JDelete(bool_item);
+    return NULL;
+}
+
+/*!
+ @brief Add a number field to a `J` object.
+
+ @param object The object to add the field to.
+ @param name The name of the field.
+ @param number The value of the field.
+
+ @returns A pointer to the newly-added number field or NULL on error.
+ */
+N_CJSON_PUBLIC(J*) JAddNumberToObject(J * const object, const char * const name, const JNUMBER number)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *number_item = JCreateNumber(number);
+    if (add_item_to_object(object, name, number_item, false)) {
+        return number_item;
+    }
+
+    JDelete(number_item);
+    return NULL;
+}
+
+N_CJSON_PUBLIC(J*) JAddIntToObject(J * const object, const char * const name, const JINTEGER integer)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *integer_item = JCreateInteger(integer);
+    if (add_item_to_object(object, name, integer_item, false)) {
+        return integer_item;
+    }
+
+    JDelete(integer_item);
+    return NULL;
+}
+
+/*!
+ @brief Add a string field to a `J` object.
+
+ @param object The object to add the field to.
+ @param name The name of the field.
+ @param string The value of the field.
+
+ @returns A pointer to the newly-added string field or NULL on error.
+ */
+N_CJSON_PUBLIC(J*) JAddStringToObject(J * const object, const char * const name, const char * const string)
+{
+    if (object == NULL || string == NULL) {
+        return NULL;
+    }
+
+    J *string_item = JCreateString(string);
+    if (add_item_to_object(object, name, string_item, false)) {
+        return string_item;
+    }
+
+    JDelete(string_item);
+    return NULL;
+}
+
+N_CJSON_PUBLIC(J*) JAddRawToObject(J * const object, const char * const name, const char * const raw)
+{
+    if (object == NULL || raw == NULL) {
+        return NULL;
+    }
+
+    J *raw_item = JCreateRaw(raw);
+    if (add_item_to_object(object, name, raw_item, false)) {
+        return raw_item;
+    }
+
+    JDelete(raw_item);
+    return NULL;
+}
+
+/*!
+ @brief Add an object field to another `J` object.
+
+ @param object The object to add the field to.
+ @param name The name of the field.
+
+ @returns A pointer to the newly-added object field or NULL on error.
+ */
+N_CJSON_PUBLIC(J*) JAddObjectToObject(J * const object, const char * const name)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *object_item = JCreateObject();
+    if (add_item_to_object(object, name, object_item, false)) {
+        return object_item;
+    }
+
+    JDelete(object_item);
+    return NULL;
+}
+
+/*!
+ @brief Add an array field to a `J` object.
+
+ @param object The object to add the field to.
+ @param name The name of the field.
+
+ @returns A pointer to the newly-added array field or NULL on error.
+ */
+N_CJSON_PUBLIC(J*) JAddArrayToObject(J * const object, const char * const name)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *array = JCreateArray();
+    if (add_item_to_object(object, name, array, false)) {
+        return array;
+    }
+
+    JDelete(array);
+    return NULL;
+}
+
+N_CJSON_PUBLIC(J *) JDetachItemViaPointer(J *parent, J * const item)
+{
+    if (parent == NULL || item == NULL) {
+        return NULL;
+    }
+
+    if (item->prev != NULL) {
+        /* not the first element */
+        item->prev->next = item->next;
+    }
+    if (item->next != NULL) {
+        /* not the last element */
+        item->next->prev = item->prev;
+    }
+
+    if (item == parent->child) {
+        /* first element */
+        parent->child = item->next;
+    }
+    /* make sure the detached item doesn't point anywhere anymore */
+    item->prev = NULL;
+    item->next = NULL;
+
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JDetachItemFromArray(J *array, int which)
+{
+    if (array == NULL) {
+        return NULL;
+    }
+    if (which < 0) {
+        return NULL;
+    }
+
+    return JDetachItemViaPointer(array, get_array_item(array, (size_t)which));
+}
+
+N_CJSON_PUBLIC(void) JDeleteItemFromArray(J *array, int which)
+{
+    if (array == NULL) {
+        return;
+    }
+    JDelete(JDetachItemFromArray(array, which));
+}
+
+N_CJSON_PUBLIC(J *) JDetachItemFromObject(J *object, const char *string)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *to_detach = JGetObjectItem(object, string);
+
+    return JDetachItemViaPointer(object, to_detach);
+}
+
+N_CJSON_PUBLIC(J *) JDetachItemFromObjectCaseSensitive(J *object, const char *string)
+{
+    if (object == NULL) {
+        return NULL;
+    }
+
+    J *to_detach = JGetObjectItemCaseSensitive(object, string);
+
+    return JDetachItemViaPointer(object, to_detach);
+}
+
+N_CJSON_PUBLIC(void) JDeleteItemFromObject(J *object, const char *string)
+{
+    if (object == NULL) {
+        return;
+    }
+    JDelete(JDetachItemFromObject(object, string));
+}
+
+N_CJSON_PUBLIC(void) JDeleteItemFromObjectCaseSensitive(J *object, const char *string)
+{
+    if (object == NULL) {
+        return;
+    }
+    JDelete(JDetachItemFromObjectCaseSensitive(object, string));
+}
+
+/* Replace array/object items with new ones. */
+N_CJSON_PUBLIC(void) JInsertItemInArray(J *array, int which, J *newitem)
+{
+    if (array == NULL || newitem == NULL) {
+        return;
+    }
+
+    J *after_inserted = NULL;
+
+    if (which < 0) {
+        return;
+    }
+
+    after_inserted = get_array_item(array, (size_t)which);
+    if (after_inserted == NULL) {
+        add_item_to_array(array, newitem);
+        return;
+    }
+
+    newitem->next = after_inserted;
+    newitem->prev = after_inserted->prev;
+    after_inserted->prev = newitem;
+    if (after_inserted == array->child) {
+        array->child = newitem;
+    } else {
+        newitem->prev->next = newitem;
+    }
+}
+
+N_CJSON_PUBLIC(Jbool) JReplaceItemViaPointer(J * const parent, J * const item, J * replacement)
+{
+    if (parent == NULL || replacement == NULL || item == NULL) {
+        return false;
+    }
+
+    if (replacement == item) {
+        return true;
+    }
+
+    replacement->next = item->next;
+    replacement->prev = item->prev;
+
+    if (replacement->next != NULL) {
+        replacement->next->prev = replacement;
+    }
+    if (replacement->prev != NULL) {
+        replacement->prev->next = replacement;
+    }
+    if (parent->child == item) {
+        parent->child = replacement;
+    }
+
+    item->next = NULL;
+    item->prev = NULL;
+    JDelete(item);
+
+    return true;
+}
+
+N_CJSON_PUBLIC(void) JReplaceItemInArray(J *array, int which, J *newitem)
+{
+    if (array == NULL || newitem == NULL) {
+        return;
+    }
+
+    if (which < 0) {
+        return;
+    }
+
+    JReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem);
+}
+
+static Jbool replace_item_in_object(J *object, const char *string, J *replacement, Jbool case_sensitive)
+{
+    if (object == NULL || replacement == NULL || string == NULL) {
+        return false;
+    }
+
+    /* replace the name in the replacement */
+    if (!(replacement->type & JStringIsConst) && (replacement->string != NULL)) {
+        _Free(replacement->string);
+    }
+    replacement->string = (char*)Jstrdup((const unsigned char*)string);
+    replacement->type &= ~JStringIsConst;
+
+    JReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
+
+    return true;
+}
+
+N_CJSON_PUBLIC(void) JReplaceItemInObject(J *object, const char *string, J *newitem)
+{
+    if (object == NULL || newitem == NULL) {
+        return;
+    }
+    replace_item_in_object(object, string, newitem, false);
+}
+
+N_CJSON_PUBLIC(void) JReplaceItemInObjectCaseSensitive(J *object, const char *string, J *newitem)
+{
+    if (object == NULL || newitem == NULL) {
+        return;
+    }
+    replace_item_in_object(object, string, newitem, true);
+}
+
+N_CJSON_PUBLIC(J *) JCreateTrue(void)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = JTrue;
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateFalse(void)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = JFalse;
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateBool(Jbool b)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = b ? JTrue : JFalse;
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateNumber(JNUMBER num)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = JNumber;
+        item->valuenumber = num;
+
+        // Saturate valueint in the case of overflow.
+        if (num >= JINTEGER_MAX) {
+            item->valueint = JINTEGER_MAX;
+        } else if (num <= JINTEGER_MIN) {
+            item->valueint = JINTEGER_MIN;
+        } else {
+            item->valueint = (JINTEGER)num;
+        }
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateInteger(JINTEGER integer)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = JNumber;
+        item->valuenumber = (JNUMBER)integer;
+        item->valueint = integer;
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateString(const char *string)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = JString;
+        item->valuestring = (char*)Jstrdup((const unsigned char*)string);
+        if(!item->valuestring) {
+            JDelete(item);
+            return NULL;
+        }
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateStringValue(const char *string)
+{
+    J *item = JNew_Item();
+    if (item != NULL) {
+        item->type = JString;
+        item->valuestring = (char*)cast_away_const(string);
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateStringReference(const char *string)
+{
+    J *item = JNew_Item();
+    if (item != NULL) {
+        item->type = JString | JIsReference;
+        item->valuestring = (char*)cast_away_const(string);
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateObjectReference(const J *child)
+{
+    if (child == NULL) {
+        return NULL;
+    }
+    J *item = JNew_Item();
+    if (item != NULL) {
+        item->type = JObject | JIsReference;
+        item->child = (J*)cast_away_const(child);
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateArrayReference(const J *child)
+{
+    if (child == NULL) {
+        return NULL;
+    }
+    J *item = JNew_Item();
+    if (item != NULL) {
+        item->type = JArray | JIsReference;
+        item->child = (J*)cast_away_const(child);
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateRaw(const char *raw)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type = JRaw;
+        item->valuestring = (char*)Jstrdup((const unsigned char*)raw);
+        if(!item->valuestring) {
+            JDelete(item);
+            return NULL;
+        }
+    }
+    return item;
+}
+
+N_CJSON_PUBLIC(J *) JCreateArray(void)
+{
+    J *item = JNew_Item();
+    if(item) {
+        item->type=JArray;
+    }
+    return item;
+}
+
+/*!
+ @brief Create a new `J` object.
+
+ To free the object, use `JDelete`.
+
+ @returns A pointer to the newly-created object.
+ */
+N_CJSON_PUBLIC(J *) JCreateObject(void)
+{
+    J *item = JNew_Item();
+    if (item) {
+        item->type = JObject;
+    }
+    return item;
+}
+
+/* Create Arrays: */
+N_CJSON_PUBLIC(J *) JCreateIntArray(const long int *numbers, int count)
+{
+    size_t i = 0;
+    J *n = NULL;
+    J *p = NULL;
+    J *a = NULL;
+
+    if ((count < 0) || (numbers == NULL)) {
+        return NULL;
+    }
+
+    a = JCreateArray();
+    for(i = 0; a && (i < (size_t)count); i++) {
+        n = JCreateNumber(numbers[i]);
+        if (!n) {
+            JDelete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        } else {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+N_CJSON_PUBLIC(J *) JCreateNumberArray(const JNUMBER *numbers, int count)
+{
+    size_t i = 0;
+    J *n = NULL;
+    J *p = NULL;
+    J *a = NULL;
+
+    if ((count < 0) || (numbers == NULL)) {
+        return NULL;
+    }
+
+    a = JCreateArray();
+
+    for(i = 0; a && (i < (size_t)count); i++) {
+        n = JCreateNumber(numbers[i]);
+        if(!n) {
+            JDelete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        } else {
+            suffix_object(p, n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+N_CJSON_PUBLIC(J *) JCreateStringArray(const char **strings, int count)
+{
+    size_t i = 0;
+    J *n = NULL;
+    J *p = NULL;
+    J *a = NULL;
+
+    if ((count < 0) || (strings == NULL)) {
+        return NULL;
+    }
+
+    a = JCreateArray();
+
+    for (i = 0; a && (i < (size_t)count); i++) {
+        n = JCreateString(strings[i]);
+        if(!n) {
+            JDelete(a);
+            return NULL;
+        }
+        if(!i) {
+            a->child = n;
+        } else {
+            suffix_object(p,n);
+        }
+        p = n;
+    }
+
+    return a;
+}
+
+/* Duplication */
+N_CJSON_PUBLIC(J *) JDuplicate(const J *item, Jbool recurse)
+{
+    J *newitem = NULL;
+    J *child = NULL;
+    J *next = NULL;
+    J *newchild = NULL;
+
+    /* Bail on bad ptr */
+    if (!item) {
+        goto fail;
+    }
+    /* Create new item */
+    newitem = JNew_Item();
+    if (!newitem) {
+        goto fail;
+    }
+    /* Copy over all vars */
+    newitem->type = item->type & (~JIsReference);
+    newitem->valueint = item->valueint;
+    newitem->valuenumber = item->valuenumber;
+    if (item->valuestring) {
+        newitem->valuestring = (char*)Jstrdup((unsigned char*)item->valuestring);
+        if (!newitem->valuestring) {
+            goto fail;
+        }
+    }
+    if (item->string) {
+        newitem->string = (item->type&JStringIsConst) ? item->string : (char*)Jstrdup((unsigned char*)item->string);
+        if (!newitem->string) {
+            goto fail;
+        }
+    }
+    /* If non-recursive, then we're done! */
+    if (!recurse) {
+        return newitem;
+    }
+    /* Walk the ->next chain for the child. */
+    child = item->child;
+    while (child != NULL) {
+        newchild = JDuplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */
+        if (!newchild) {
+            goto fail;
+        }
+        if (next != NULL) {
+            /* If newitem->child already set, then crosswire ->prev and ->next and move on */
+            next->next = newchild;
+            newchild->prev = next;
+            next = newchild;
+        } else {
+            /* Set newitem->child and move to it */
+            newitem->child = newchild;
+            next = newchild;
+        }
+        child = child->next;
+    }
+
+    return newitem;
+
+fail:
+    if (newitem != NULL) {
+        JDelete(newitem);
+    }
+
+    return NULL;
+}
+
+N_CJSON_PUBLIC(void) JMinify(char *json)
+{
+    unsigned char *into = (unsigned char*)json;
+
+    if (json == NULL) {
+        return;
+    }
+
+    while (*json) {
+        if (*json == ' ') {
+            json++;
+        } else if (*json == '\t') {
+            /* Whitespace characters. */
+            json++;
+        } else if (*json == '\r') {
+            json++;
+        } else if (*json=='\n') {
+            json++;
+        } else if ((*json == '/') && (json[1] == '/')) {
+            /* double-slash comments, to end of line. */
+            while (*json && (*json != '\n')) {
+                json++;
+            }
+        } else if ((*json == '/') && (json[1] == '*')) {
+            /* multiline comments. */
+            while (*json && !((*json == '*') && (json[1] == '/'))) {
+                json++;
+            }
+            json += 2;
+        } else if (*json == '\"') {
+            /* string literals, which are \" sensitive. */
+            *into++ = (unsigned char)*json++;
+            while (*json && (*json != '\"')) {
+                if (*json == '\\') {
+                    *into++ = (unsigned char)*json++;
+                }
+                *into++ = (unsigned char)*json++;
+            }
+            *into++ = (unsigned char)*json++;
+        } else {
+            /* All other characters. */
+            *into++ = (unsigned char)*json++;
+        }
+    }
+
+    /* and null-terminate. */
+    *into = '\0';
+}
+
+N_CJSON_PUBLIC(Jbool) JIsInvalid(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JInvalid;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsFalse(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JFalse;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsTrue(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xff) == JTrue;
+}
+
+
+N_CJSON_PUBLIC(Jbool) JIsBool(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & (JTrue | JFalse)) != 0;
+}
+N_CJSON_PUBLIC(Jbool) JIsNull(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JNULL;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsNumber(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JNumber;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsString(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JString;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsArray(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JArray;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsObject(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JObject;
+}
+
+N_CJSON_PUBLIC(Jbool) JIsRaw(const J * const item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return (item->type & 0xFF) == JRaw;
+}
+
+N_CJSON_PUBLIC(Jbool) JCompare(const J * const a, const J * const b, const Jbool case_sensitive)
+{
+    if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || JIsInvalid(a)) {
+        return false;
+    }
+
+    /* check if type is valid */
+    switch (a->type & 0xFF) {
+    case JFalse:
+    case JTrue:
+    case JNULL:
+    case JNumber:
+    case JString:
+    case JRaw:
+    case JArray:
+    case JObject:
+        break;
+
+    default:
+        return false;
+    }
+
+    /* identical objects are equal */
+    if (a == b) {
+        return true;
+    }
+
+    switch (a->type & 0xFF) {
+    /* in these cases and equal type is enough */
+    case JFalse:
+    case JTrue:
+    case JNULL:
+        return true;
+
+    case JNumber:
+        if (a->valuenumber == b->valuenumber) {
+            return true;
+        }
+        return false;
+
+    case JString:
+    case JRaw:
+        if ((a->valuestring == NULL) || (b->valuestring == NULL)) {
+            return false;
+        }
+        if (strcmp(a->valuestring, b->valuestring) == 0) {
+            return true;
+        }
+
+        return false;
+
+    case JArray: {
+        J *a_element = a->child;
+        J *b_element = b->child;
+
+        for (; (a_element != NULL) && (b_element != NULL);) {
+            if (!JCompare(a_element, b_element, case_sensitive)) {
+                return false;
+            }
+
+            a_element = a_element->next;
+            b_element = b_element->next;
+        }
+
+        /* one of the arrays is longer than the other */
+        if (a_element != b_element) {
+            return false;
+        }
+
+        return true;
+    }
+
+    case JObject: {
+        J *a_element = NULL;
+        J *b_element = NULL;
+        JArrayForEach(a_element, a) {
+            /* TODO This has O(n^2) runtime, which is horrible! */
+            b_element = get_object_item(b, a_element->string, case_sensitive);
+            if (b_element == NULL) {
+                return false;
+            }
+
+            if (!JCompare(a_element, b_element, case_sensitive)) {
+                return false;
+            }
+        }
+
+        /* doing this twice, once on a and b to prevent true comparison if a subset of b
+         * TODO: Do this the proper way, this is just a fix for now */
+        JArrayForEach(b_element, b) {
+            a_element = get_object_item(a, b_element->string, case_sensitive);
+            if (a_element == NULL) {
+                return false;
+            }
+
+            if (!JCompare(b_element, a_element, case_sensitive)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    default:
+        return false;
+    }
+}
diff --git a/src/note-c/n_cjson.h b/src/note-c/n_cjson.h
new file mode 100644
index 0000000..6e85e95
--- /dev/null
+++ b/src/note-c/n_cjson.h
@@ -0,0 +1,332 @@
+/*!
+ * @file n_cjson.h
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Portions Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ * MODIFIED for use in notecard primarily by altering default memory allocator
+ * and by renaming the functions so that they won't conflict with a developer's
+ * own decision to incorporate the actual production cJSON into their own app.
+ * In no way shall this interfere with a production cJSON.
+ *
+ * Renaming was done as follows:
+ * CJSON_ -> N_CJSON_
+ * cJSON_ -> J
+ * cJSON -> J
+ *
+ * Portions Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+ *
+ * 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 i
+ * 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
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#ifndef J_h
+#define J_h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* project version */
+#define N_CJSON_VERSION_MAJOR 1
+#define N_CJSON_VERSION_MINOR 7
+#define N_CJSON_VERSION_PATCH 7
+
+#include <stddef.h>
+
+/* J Types: */
+#define JInvalid (0)
+#define JFalse  (1 << 0)
+#define JTrue   (1 << 1)
+#define JNULL   (1 << 2)
+#define JNumber (1 << 3)
+#define JString (1 << 4)
+#define JArray  (1 << 5)
+#define JObject (1 << 6)
+#define JRaw    (1 << 7) /* raw json */
+
+#define JIsReference 256
+#define JStringIsConst 512
+
+/*!
+ @brief The core JSON object type used by note-c.
+
+ When using note-c, treat this struct as opaque. You should never have to work
+ directly with its members.
+ */
+typedef struct J {
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct J *next;
+    struct J *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct J *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==JString  and type == JRaw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use JSetNumberValue instead */
+    JINTEGER valueint;
+    /* The item's number, if type==JNumber */
+    JNUMBER valuenumber;
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} J;
+
+typedef struct JHooks {
+    void *(*malloc_fn)(size_t sz);
+    void (*free_fn)(void *ptr);
+} JHooks;
+
+typedef int Jbool;
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 2 define options:
+
+N_CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+N_CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+N_CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the N_CJSON_API_VISIBILITY flag to "export" the same symbols the way N_CJSON_EXPORT_SYMBOLS does
+
+*/
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(N_CJSON_HIDE_SYMBOLS) && !defined(N_CJSON_IMPORT_SYMBOLS) && !defined(N_CJSON_EXPORT_SYMBOLS)
+#define N_CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(N_CJSON_HIDE_SYMBOLS)
+#define N_CJSON_PUBLIC(type)   type __stdcall
+#elif defined(N_CJSON_EXPORT_SYMBOLS)
+#define N_CJSON_PUBLIC(type)   __declspec(dllexport) type __stdcall
+#elif defined(N_CJSON_IMPORT_SYMBOLS)
+#define N_CJSON_PUBLIC(type)   __declspec(dllimport) type __stdcall
+#endif
+#else /* !WIN32 */
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(N_CJSON_API_VISIBILITY)
+#define N_CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define N_CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/*!
+  @brief The maximum nesting level for JSON objects before a parsing error.
+
+  Default value: `100`
+
+  For example, if you have a JSON object that contains multiple, nested
+  objects like this
+
+      {
+          "x":
+          {
+              "x:"
+              {
+                  .
+                  .
+                  .
+              }
+          }
+      }
+
+  And the nesting level exceeds `N_CJSON_NESTING_LIMIT`, then calling `JParse` on
+  a `J *` representing this object will return an error (NULL).
+
+  This exists to prevent the cJSON parser from causing a stack overflow. The
+  user may override this macro at build time (e.g.
+  -DN_CJSON_NESTING_LIMIT=200) to increase or reduce the limit.
+ */
+#ifndef N_CJSON_NESTING_LIMIT
+#define N_CJSON_NESTING_LIMIT 100
+#endif
+
+/* returns the version of J as a string */
+N_CJSON_PUBLIC(const char*) JVersion(void);
+
+/* Supply malloc, realloc and free functions to J */
+N_CJSON_PUBLIC(void) JInitHooks(JHooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of JParse (with JDelete) and JPrint (with stdlib free, JHooks.free_fn, or JFree as appropriate). The exception is JPrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a J object you can interrogate. */
+N_CJSON_PUBLIC(J *) JParse(const char *value);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match JGetErrorPtr(). */
+N_CJSON_PUBLIC(J *) JParseWithOpts(const char *value, const char **return_parse_end, Jbool require_null_terminated);
+
+/* Render a J entity to text for transfer/storage. */
+N_CJSON_PUBLIC(char *) JPrint(const J *item);
+/* Render a J entity to text for transfer/storage without any formatting. */
+N_CJSON_PUBLIC(char *) JPrintUnformatted(const J *item);
+/* Render a J entity to text for transfer/storage without any formatting and without fields that are false, 0, or "". */
+N_CJSON_PUBLIC(char *) JPrintUnformattedOmitEmpty(const J *item);
+/* Render a J entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+N_CJSON_PUBLIC(char *) JPrintBuffered(const J *item, int prebuffer, Jbool fmt);
+/* Render a J entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: J is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+N_CJSON_PUBLIC(Jbool) JPrintPreallocated(J *item, char *buffer, const int length, const Jbool format);
+N_CJSON_PUBLIC(Jbool) JPrintPreallocatedOmitEmpty(J *item, char *buffer, const int length, const Jbool format);
+/* Delete a J entity and all subentities. */
+N_CJSON_PUBLIC(void) JDelete(J *c);
+
+/* Returns the number of items in an array (or object). */
+N_CJSON_PUBLIC(int) JGetArraySize(const J *array);
+#define	JGetObjectItems JGetArraySize
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+N_CJSON_PUBLIC(J *) JGetArrayItem(const J *array, int index);
+/* Get item "string" from object. Case insensitive. */
+N_CJSON_PUBLIC(J *) JGetObjectItem(const J * const object, const char * const string);
+N_CJSON_PUBLIC(J *) JGetObjectItemCaseSensitive(const J * const object, const char * const string);
+N_CJSON_PUBLIC(Jbool) JHasObjectItem(const J *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when JParse() returns 0. 0 when JParse() succeeds. */
+N_CJSON_PUBLIC(const char *) JGetErrorPtr(void);
+
+/* Check if the item is a string and return its valuestring */
+N_CJSON_PUBLIC(char *) JGetStringValue(J *item);
+
+/* These functions check the type of an item */
+N_CJSON_PUBLIC(Jbool) JIsInvalid(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsFalse(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsTrue(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsBool(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsNull(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsNumber(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsString(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsArray(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsObject(const J * const item);
+N_CJSON_PUBLIC(Jbool) JIsRaw(const J * const item);
+
+/* These calls create a J item of the appropriate type. */
+N_CJSON_PUBLIC(J *) JCreateTrue(void);
+N_CJSON_PUBLIC(J *) JCreateFalse(void);
+N_CJSON_PUBLIC(J *) JCreateBool(Jbool boolean);
+N_CJSON_PUBLIC(J *) JCreateNumber(JNUMBER num);
+N_CJSON_PUBLIC(J *) JCreateInteger(JINTEGER integer);
+N_CJSON_PUBLIC(J *) JCreateString(const char *string);
+/* raw json */
+N_CJSON_PUBLIC(J *) JCreateRaw(const char *raw);
+N_CJSON_PUBLIC(J *) JCreateArray(void);
+N_CJSON_PUBLIC(J *) JCreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by JDelete */
+N_CJSON_PUBLIC(J *) JCreateStringValue(const char *string);
+N_CJSON_PUBLIC(J *) JCreateStringReference(const char *string);
+/* Create an object/arrray that only references it's elements so
+ * they will not be freed by JDelete */
+N_CJSON_PUBLIC(J *) JCreateObjectReference(const J *child);
+N_CJSON_PUBLIC(J *) JCreateArrayReference(const J *child);
+
+/* These utilities create an Array of count items. */
+N_CJSON_PUBLIC(J *) JCreateIntArray(const long int *numbers, int count);
+N_CJSON_PUBLIC(J *) JCreateNumberArray(const JNUMBER *numbers, int count);
+N_CJSON_PUBLIC(J *) JCreateStringArray(const char **strings, int count);
+
+/* Append item to the specified array/object. */
+N_CJSON_PUBLIC(void) JAddItemToArray(J *array, J *item);
+N_CJSON_PUBLIC(void) JAddItemToObject(J *object, const char *string, J *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the J object.
+ * WARNING: When this function was used, make sure to always check that (item->type & JStringIsConst) is zero before
+ * writing to `item->string` */
+N_CJSON_PUBLIC(void) JAddItemToObjectCS(J *object, const char *string, J *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing J to a new J, but don't want to corrupt your existing J. */
+N_CJSON_PUBLIC(void) JAddItemReferenceToArray(J *array, J *item);
+N_CJSON_PUBLIC(void) JAddItemReferenceToObject(J *object, const char *string, J *item);
+
+/* Remove/Detatch items from Arrays/Objects. */
+N_CJSON_PUBLIC(J *) JDetachItemViaPointer(J *parent, J * const item);
+N_CJSON_PUBLIC(J *) JDetachItemFromArray(J *array, int which);
+N_CJSON_PUBLIC(void) JDeleteItemFromArray(J *array, int which);
+N_CJSON_PUBLIC(J *) JDetachItemFromObject(J *object, const char *string);
+N_CJSON_PUBLIC(J *) JDetachItemFromObjectCaseSensitive(J *object, const char *string);
+N_CJSON_PUBLIC(void) JDeleteItemFromObject(J *object, const char *string);
+N_CJSON_PUBLIC(void) JDeleteItemFromObjectCaseSensitive(J *object, const char *string);
+
+/* Update array items. */
+N_CJSON_PUBLIC(void) JInsertItemInArray(J *array, int which, J *newitem); /* Shifts pre-existing items to the right. */
+N_CJSON_PUBLIC(Jbool) JReplaceItemViaPointer(J * const parent, J * const item, J * replacement);
+N_CJSON_PUBLIC(void) JReplaceItemInArray(J *array, int which, J *newitem);
+N_CJSON_PUBLIC(void) JReplaceItemInObject(J *object,const char *string,J *newitem);
+N_CJSON_PUBLIC(void) JReplaceItemInObjectCaseSensitive(J *object,const char *string,J *newitem);
+
+/* Duplicate a J item */
+N_CJSON_PUBLIC(J *) JDuplicate(const J *item, Jbool recurse);
+/* Duplicate will create a new, identical J item to the one you pass, in new memory that will
+need to be released. With recurse!=0, it will duplicate any children connected to the item.
+The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two J items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+N_CJSON_PUBLIC(Jbool) JCompare(const J * const a, const J * const b, const Jbool case_sensitive);
+
+
+N_CJSON_PUBLIC(void) JMinify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+N_CJSON_PUBLIC(J*) JAddTrueToObject(J * const object, const char * const name);
+N_CJSON_PUBLIC(J*) JAddFalseToObject(J * const object, const char * const name);
+N_CJSON_PUBLIC(J*) JAddBoolToObject(J * const object, const char * const name, const Jbool boolean);
+N_CJSON_PUBLIC(J*) JAddNumberToObject(J * const object, const char * const name, const JNUMBER number);
+N_CJSON_PUBLIC(J*) JAddIntToObject(J * const object, const char * const name, const JINTEGER integer);
+N_CJSON_PUBLIC(J*) JAddStringToObject(J * const object, const char * const name, const char * const string);
+N_CJSON_PUBLIC(J*) JAddRawToObject(J * const object, const char * const name, const char * const raw);
+N_CJSON_PUBLIC(J*) JAddObjectToObject(J * const object, const char * const name);
+N_CJSON_PUBLIC(J*) JAddArrayToObject(J * const object, const char * const name);
+#define JConvertToJSONString JPrintUnformatted
+#define JConvertFromJSONString JParse
+
+/* When assigning an integer value, it needs to be propagated to valuenumber too. */
+#define JSetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuenumber = (number) : (number))
+/* helper for the JSetNumberValue macro */
+N_CJSON_PUBLIC(JNUMBER) JSetNumberHelper(J *object, JNUMBER number);
+#define JSetNumberValue(object, number) ((object != NULL) ? JSetNumberHelper(object, (JNUMBER)number) : (number))
+
+/* Macro for iterating over an array or object */
+#define JArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+// Iterate over the fields of an object
+#define JObjectForEach(element, array) JArrayForEach(element, array)
+
+/* malloc/free objects using the malloc/free functions that have been set with JInitHooks */
+N_CJSON_PUBLIC(void *) JMalloc(size_t size);
+N_CJSON_PUBLIC(void) JFree(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/note-c/n_cjson_helpers.c b/src/note-c/n_cjson_helpers.c
new file mode 100644
index 0000000..9f0279c
--- /dev/null
+++ b/src/note-c/n_cjson_helpers.c
@@ -0,0 +1,694 @@
+/*!
+ * @file n_cjson_helpers.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "n_lib.h"
+
+/*!
+ @brief Determine if a field is present in a JSON object.
+
+ @param json The JSON object.
+ @param field The field to find.
+
+ @returns True if the field is present, or false if the field is not present or
+          the JSON object is NULL.
+ */
+bool JIsPresent(J *json, const char *field)
+{
+    if (json == NULL) {
+        return false;
+    }
+    return (JGetObjectItem(json, field) != NULL);
+}
+
+/*!
+ @brief Get the value of a string field from a JSON object.
+
+ @param json The JSON object.
+ @param field The string field to query.
+
+ @returns A pointer to the string if the field exists and is a string, otherwise
+          the empty string ("").
+
+ @note The returned string is a pointer to the string contained in the JSON
+       object. It is not a copy of the string, so once the JSON object is freed,
+       the pointer is no longer valid.
+ */
+char *JGetString(J *json, const char *field)
+{
+    if (json == NULL) {
+        return (char *) c_nullstring;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return (char *) c_nullstring;
+    }
+    if (!JIsString(item)) {
+        return (char *) c_nullstring;
+    }
+    if (item->valuestring == NULL) {
+        return (char *) c_nullstring;
+    }
+    return item->valuestring;
+}
+
+/*!
+ @brief Get the value of an array field from a JSON object.
+
+ @param json The JSON object.
+ @param field The array field to query.
+
+ @returns A pointer to the array, which is itself a JSON object (`J *`), if the
+          field exists and is an array, otherwise NULL.
+
+ @note The returned JSON object is a pointer to the array contained in the
+       parent JSON object. It is not a copy, so once the parent JSON object is
+       freed, the pointer is no longer valid.
+ */
+J *JGetArray(J *json, const char *field)
+{
+    if (json == NULL) {
+        return NULL;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return NULL;
+    }
+    if (!JIsArray(item)) {
+        return NULL;
+    }
+    return item;
+}
+
+/*!
+ @brief Get the value of an object field from a JSON object.
+
+ @param json The JSON object.
+ @param field The object field to query.
+
+ @returns A pointer to the object, which is itself a JSON object (`J *`), if the
+          field exists and is an object, otherwise NULL.
+
+ @note The returned JSON object is a pointer to the object contained in the
+       parent JSON object. It is not a copy, so once the parent JSON object is
+       freed, the pointer is no longer valid.
+ */
+J *JGetObject(J *json, const char *field)
+{
+    if (json == NULL) {
+        return NULL;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return NULL;
+    }
+    if (!JIsObject(item)) {
+        return NULL;
+    }
+    return item;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Return the boolean representation of an item.
+    @param   item The JSON item.
+    @returns The boolean value.
+*/
+/**************************************************************************/
+bool JBoolValue(J *item)
+{
+    if (item == NULL) {
+        return false;
+    }
+    return ((item->type & 0xff) == JTrue);
+}
+
+//**************************************************************************/
+/*!
+    @brief  Return the string representation of an item.
+    @param   item The JSON item.
+    @returns The string value, or empty string, if NULL.
+*/
+/**************************************************************************/
+char *JStringValue(J *item)
+{
+    if (item == NULL) {
+        return (char *)"";
+    }
+    return item->valuestring;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Return the number representation of an item.
+    @param   item The JSON item.
+    @returns The number, or 0.0, if NULL.
+*/
+/**************************************************************************/
+JNUMBER JNumberValue(J *item)
+{
+    if (item == NULL) {
+        return 0.0;
+    }
+    return item->valuenumber;
+}
+
+/*!
+ @brief Get the floating point value of a number field from a JSON object.
+
+ @param json The JSON object.
+ @param field The number field to query.
+
+ @returns The value of the number field if the field exists and is a number,
+          otherwise 0.0.
+
+ @note The returned value is the floating point representation of the number.
+
+ @see `JGetInt`
+ @see `JGetBool`
+ */
+JNUMBER JGetNumber(J *json, const char *field)
+{
+    if (json == NULL) {
+        return 0.0;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return 0.0;
+    }
+    if (!JIsNumber(item)) {
+        return 0.0;
+    }
+    return JNumberValue(item);
+}
+
+//**************************************************************************/
+/*!
+    @brief  Return the integer representation of an item.
+    @param   item The JSON item.
+    @returns The number, or 0, if NULL.
+*/
+/**************************************************************************/
+JINTEGER JIntValue(J *item)
+{
+    if (item == NULL) {
+        return 0;
+    }
+    return item->valueint;
+}
+
+/*!
+ @brief Get the integer value of a number field from a JSON object.
+
+ @param json The JSON object.
+ @param field The number field to query.
+
+ @returns The value of the number field if the field exists and is a number,
+          otherwise 0.
+
+ @note The returned value is the integer representation of the number.
+
+ @see `JGetBool`
+ @see `JGetNumber`
+ */
+JINTEGER JGetInt(J *json, const char *field)
+{
+    if (json == NULL) {
+        return 0;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return 0;
+    }
+    if (!JIsNumber(item)) {
+        return 0;
+    }
+    return JIntValue(item);
+}
+
+/*!
+ @brief Get the value of a boolean field from a JSON object.
+
+ @param json The JSON object.
+ @param field The boolean field to query.
+
+ @returns The value of the boolean field if it exists and is a boolean,
+          otherwise false.
+
+ @see `JGetInt`
+ @see `JGetNumber`
+ */
+bool JGetBool(J *json, const char *field)
+{
+    if (json == NULL) {
+        return false;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return false;
+    }
+    if (!JIsBool(item)) {
+        return false;
+    }
+    return JIsTrue(item);
+}
+
+//**************************************************************************/
+/*!
+    @brief  Determine if a JSON object is valid and if a field is not present,
+            or null.
+    @param   json The JSON response object.
+    @param   field The field to return.
+    @returns bool. False if the field is not present, or NULL.
+*/
+/**************************************************************************/
+bool JIsNullString(J *json, const char *field)
+{
+    if (json == NULL) {
+        return false;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return true;
+    }
+    if (!JIsString(item)) {
+        return false;
+    }
+    if (item->valuestring == NULL) {
+        return true;
+    }
+    if (item->valuestring[0] == '\0') {
+        return true;
+    }
+    return false;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Determine if a field exists, is a string and matches a
+            provided value.
+    @param   json The JSON response object.
+    @param   field The field to check.
+    @param   teststr The string to test against the returned value.
+    @returns bol. Whether the fields match exactly.
+*/
+/**************************************************************************/
+bool JIsExactString(J *json, const char *field, const char *teststr)
+{
+    if (json == NULL) {
+        return false;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return false;
+    }
+    if (!JIsString(item)) {
+        return false;
+    }
+    if (item->valuestring == NULL) {
+        return false;
+    }
+    if (strlen(teststr) == 0) {
+        return false;
+    }
+    return (strcmp(item->valuestring, teststr) == 0);
+}
+
+//**************************************************************************/
+/*!
+    @brief  Determine if a field exists, is a string and contains a provided
+            value.
+    @param   json The JSON response object.
+    @param   field The field to check.
+    @param   substr The string to test against the returned value.
+    @returns bol. Whether the provided string is found within the field.
+*/
+/**************************************************************************/
+bool JContainsString(J *json, const char *field, const char *substr)
+{
+    if (json == NULL) {
+        return false;
+    }
+    J *item = JGetObjectItem(json, field);
+    if (item == NULL) {
+        return false;
+    }
+    if (!JIsString(item)) {
+        return false;
+    }
+    if (item->valuestring == NULL) {
+        return false;
+    }
+    if (strlen(substr) == 0) {
+        return false;
+    }
+    return (strstr(item->valuestring, substr) != NULL);
+}
+
+
+/*!
+ @brief Add binary data as a Base64-encoded string field to a JSON object.
+
+ @param json The JSON object.
+ @param fieldName The name to use for the field.
+ @param binaryData A buffer of binary data to encode.
+ @param binaryDataLen The length of the binary data in bytes.
+
+ @returns True if the string was successfully encoded and added to the object,
+          otherwise false.
+ */
+bool JAddBinaryToObject(J *json, const char *fieldName, const void *binaryData, uint32_t binaryDataLen)
+{
+    if (json == NULL) {
+        return false;
+    }
+    unsigned stringDataLen = JB64EncodeLen(binaryDataLen);
+    char *stringData = (char *) _Malloc(stringDataLen);
+    if (stringData == NULL) {
+        return false;
+    }
+    JB64Encode(stringData, binaryData, binaryDataLen);
+    J *stringItem = JCreateStringValue(stringData);
+    if (stringItem == NULL) {
+        _Free(stringData);
+        return false;
+    }
+    JAddItemToObject(json, fieldName, stringItem);
+    return true;
+}
+
+
+/*!
+ @brief Decode a Base64-encoded string field in a JSON object and return the
+        decoded bytes.
+
+ @param json The JSON object.
+ @param fieldName The name of the field.
+ @param retBinaryData A pointer to a pointer, used to hold the pointer to the
+        decoded bytes.
+ @param retBinaryDataLen A pointer to an unsigned integer, used to hold the
+        length of the decoded bytes.
+
+ @returns True if the string was successfully decoded and returned, otherwise
+          false.
+
+ @note The returned binary buffer must be freed by the user with `JFree` when it
+       is no longer needed.
+
+ @note On error, the returned binary buffer and data length shall be set to
+       `NULL` and zero (0), respectively.
+ */
+bool JGetBinaryFromObject(J *json, const char *fieldName, uint8_t **retBinaryData, uint32_t *retBinaryDataLen)
+{
+    // Initialize the return values to NULL and zero.
+    *retBinaryData = NULL;
+    *retBinaryDataLen = 0;
+
+    if (json == NULL) {
+        return false;
+    }
+
+    // In some cases, the caller may already have extracted the string from a different field, in which
+    // case "json" will be set to the payload pointer.
+    char *payload;
+    if (fieldName == NULL) {
+        payload = (char *) json;
+    } else {
+        payload = JGetString(json, fieldName);
+    }
+    if (payload[0] == '\0') {
+        return false;
+    }
+
+    // Allocate a buffer for the payload, with an extra 'convenience byte' for null termination.  (see below)
+    char *p = (char *) _Malloc(JB64DecodeLen(payload)+1);
+    if (p == NULL) {
+        return false;
+    }
+    uint32_t actualLen = JB64Decode(p, payload);
+
+    // As a convenience to the caller, null-terminate the returned buffer in case it's a string.
+    // (If we didn't do this, the caller would be forced to alloc another buffer of length+1 and
+    // copy it to add the null terminator, while it's easy for us to do it here.)
+    p[actualLen] = '\0';
+
+    // Return the binary to the caller
+    *retBinaryData = (uint8_t *)p;
+    *retBinaryDataLen = actualLen;
+    return true;
+
+}
+
+//**************************************************************************/
+/*!
+    @brief  Get the object name.
+    @param   item The JSON object.
+    @returns The name, or the empty string, if NULL.
+*/
+/**************************************************************************/
+const char *JGetItemName(const J * item)
+{
+    if (item == NULL || item->string == NULL) {
+        return "";
+    }
+    return item->string;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Convert an integer to text.
+    @param   n The integer to convert.
+    @param   s The buffer to hold the text.
+    @note The buffer must be large enough because no bounds checking is done.
+*/
+/**************************************************************************/
+void JItoA(JINTEGER n, char *s)
+{
+    char c;
+    // Conversion to unsigned is required to handle the case where n is
+    // JINTEGER_MIN. In that case, applying the unary minus operator to the
+    // signed version of n overflows and the behavior is undefined. By changing
+    // n to be unsigned, the unary minus operator behaves differently, and there
+    // is no overflow. See https://stackoverflow.com/q/8026694.
+    JUINTEGER unsignedN = n;
+    long int i, j;
+    if (n < 0) {
+        unsignedN = -unsignedN;
+    }
+    i = 0;
+    do {
+        s[i++] = unsignedN % 10 + '0';
+    } while ((unsignedN /= 10) > 0);
+    if (n < 0) {
+        s[i++] = '-';
+    }
+    s[i] = '\0';
+    for (i = 0, j = strlen(s)-1; i<j; i++, j--) {
+        c = s[i];
+        s[i] = s[j];
+        s[j] = c;
+    }
+}
+
+//**************************************************************************/
+/*!
+    @brief  Convert text to an integer
+    @param   string A null-terminated text buffer
+    @returns An integer, or 0 if invalid
+*/
+/**************************************************************************/
+JINTEGER JAtoI(const char *string)
+{
+    JINTEGER result = 0;
+    unsigned int digit;
+    int sign;
+    while (*string == ' ') {
+        string += 1;
+    }
+    if (*string == '-') {
+        sign = 1;
+        string += 1;
+    } else {
+        sign = 0;
+        if (*string == '+') {
+            string += 1;
+        }
+    }
+    for ( ; ; string += 1) {
+        digit = *string - '0';
+        if (digit > 9) {
+            break;
+        }
+        result = (10*result) + digit;
+    }
+    if (sign) {
+        result = -result;
+    }
+    return result;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Convert a buffer/len to a null-terminated c-string
+    @param   buffer A buffer containing the bytes to convert.
+    @param   len The length of buffer in bytes.
+    @returns If buffer is NULL or length 0, the empty string. If allocation
+             fails, NULL. On success, the converted c-string. The returned
+             string must be freed with NoteFree.
+*/
+/**************************************************************************/
+char *JAllocString(uint8_t *buffer, uint32_t len)
+{
+    char *buf = _Malloc(len+1);
+    if (buf == NULL) {
+        return NULL;
+    }
+    if (len > 0) {
+        memcpy(buf, buffer, len);
+    }
+    buf[len] = '\0';
+    return buf;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Return the type of an item, as a string
+    @param   item The JSON item.
+    @returns The type
+*/
+/**************************************************************************/
+const char *JType(J *item)
+{
+    if (item == NULL) {
+        return "";
+    }
+    switch (item->type & 0xff) {
+    case JTrue:
+    case JFalse:
+        return "bool";
+    case JNULL:
+        return "null";
+    case JNumber:
+        return "number";
+    case JRaw:
+    case JString:
+        return "string";
+    case JObject:
+        return "object";
+    case JArray:
+        return "array";
+    }
+    return "invalid";
+}
+
+//**************************************************************************/
+/*!
+    @brief  Get the type of a field, as an int usable in a switch statement.
+    @param   json The JSON object containing the field.
+    @param   field The field's name.
+    @returns The type of the field on success. JTYPE_NOT_PRESENT on error or if
+             the field doesn't exist.
+*/
+/**************************************************************************/
+int JGetType(J *json, const char *field)
+{
+    if (json == NULL || field == NULL) {
+        return JTYPE_NOT_PRESENT;
+    }
+    return JGetItemType(JGetObjectItem(json, field));
+}
+
+// Get the
+int JGetItemType(J *item)
+{
+    const char *v;
+    if (item == NULL) {
+        return JTYPE_NOT_PRESENT;
+    }
+    switch (item->type & 0xff) {
+    case JTrue:
+        return JTYPE_BOOL_TRUE;
+    case JFalse:
+        return JTYPE_BOOL_FALSE;
+    case JNULL:
+        return JTYPE_NULL;
+    case JNumber:
+        if (item->valueint == 0 && item->valuenumber == 0) {
+            return JTYPE_NUMBER_ZERO;
+        }
+        return JTYPE_NUMBER;
+    case JRaw:
+    case JString: {
+        v = item->valuestring;
+        if (v == NULL || v[0] == 0) {
+            return JTYPE_STRING_BLANK;
+        }
+        int vlen = strlen(v);
+        char *endstr;
+        JNUMBER value = JAtoN(v, &endstr);
+        if (endstr[0] == 0) {
+            if (value == 0) {
+                return JTYPE_STRING_ZERO;
+            }
+            return JTYPE_STRING_NUMBER;
+        }
+        if (vlen == 4 && (
+                    (v[0] == 't' || v[0] == 'T')
+                    && (v[1] == 'r' || v[1] == 'R')
+                    && (v[2] == 'u' || v[2] == 'U')
+                    && (v[3] == 'e' || v[3] == 'E'))) {
+            return JTYPE_STRING_BOOL_TRUE;
+        }
+        if (vlen == 5 && (
+                    (v[0] == 'f' || v[0] == 'F')
+                    && (v[1] == 'a' || v[1] == 'A')
+                    && (v[2] == 'l' || v[2] == 'L')
+                    && (v[3] == 's' || v[3] == 'S')
+                    && (v[4] == 'e' || v[4] == 'E'))) {
+            return JTYPE_STRING_BOOL_FALSE;
+        }
+        return JTYPE_STRING;
+    }
+    case JObject:
+        return JTYPE_OBJECT;
+    case JArray:
+        return JTYPE_ARRAY;
+    }
+    return JTYPE_NOT_PRESENT;
+}
+
+// Coalesce to the base types
+int JBaseItemType(int type)
+{
+    switch (type) {
+    case JTYPE_BOOL_TRUE:
+        return JTYPE_BOOL;
+    case JTYPE_BOOL_FALSE:
+        return JTYPE_BOOL;
+    case JTYPE_NUMBER_ZERO:
+        return JTYPE_NUMBER;
+    case JTYPE_STRING_BLANK:
+        return JTYPE_STRING;
+    case JTYPE_STRING_ZERO:
+        return JTYPE_STRING;
+    case JTYPE_STRING_NUMBER:
+        return JTYPE_STRING;
+    case JTYPE_STRING_BOOL_TRUE:
+        return JTYPE_STRING;
+    case JTYPE_STRING_BOOL_FALSE:
+        return JTYPE_STRING;
+    }
+    return type;
+}
diff --git a/src/note-c/n_cobs.c b/src/note-c/n_cobs.c
new file mode 100644
index 0000000..426a5a1
--- /dev/null
+++ b/src/note-c/n_cobs.c
@@ -0,0 +1,161 @@
+// Copyright 2023 Blues Inc.  All rights reserved.
+// Use of this source code is governed by licenses granted by the
+// copyright holder including that found in the LICENSE file.
+
+#include <stdint.h>
+
+#define COBS_EOP_OVERHEAD 1
+
+//**************************************************************************/
+/*!
+  @brief Decode a string encoded with COBS encoding
+
+  @details Because the decoded length is guaranteed to be less than or equal to
+  length, the decode may be done in-place. Default behavior (with eop == 0) is
+  to restore all '\0' into output data, but if a different value is specified,
+  the input is XOR'ed such that THAT byte is the one that is assumed can't be
+  in the input.
+
+  @param  ptr Pointer to the data to decode
+  @param  length Length of the data to decode
+  @param  eop Byte to use as the end-of-packet marker
+  @param  dst Pointer to the buffer for the decoded data
+
+  @return the length of the decoded data
+ */
+/**************************************************************************/
+uint32_t cobsDecode(uint8_t *ptr, uint32_t length, uint8_t eop, uint8_t *dst)
+{
+    const uint8_t *start = dst, *end = ptr + length;
+    uint8_t code = 0xFF, copy = 0;
+    for (; ptr < end; copy--) {
+        if (copy != 0) {
+            *dst++ = (*ptr++) ^ eop;
+        } else {
+            if (code != 0xFF) {
+                *dst++ = 0;
+            }
+            copy = code = (*ptr++) ^ eop;
+            if (code == 0) {
+                break;
+            }
+        }
+    }
+    return dst - start;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Encode a string with Consistent Overhead Byte Stuffing (COBS) encoding
+
+  @details behavior (with eop == 0) is to eliminate all '\0' from input data,
+  but if a different value is specified, the output is XOR'ed such that THAT
+  byte is the one that won't be contained in output.
+  https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing
+
+  @param  ptr Pointer to the data to encode
+  @param  length Length of the data to encode
+  @param  eop Byte to use as the end-of-packet marker
+  @param  dst Pointer to the buffer for the encoded data
+
+  @return the length of the encoded data
+
+  @note You may use `cobsEncodedLength()` to calculate the required size for
+        the buffer pointed to by the `dst` parameter.
+
+  @see cobsEncodedLength()
+ */
+/**************************************************************************/
+uint32_t cobsEncode(uint8_t *ptr, uint32_t length, uint8_t eop, uint8_t *dst)
+{
+    uint8_t ch;
+    uint8_t *start = dst;
+    uint8_t code = 1;
+    uint8_t *code_ptr = dst++;          // Where to insert the leading count
+    while (length--) {
+        ch = *ptr++;
+        if (ch != 0) {                  // Input byte not zero
+            *dst++ = ch ^ eop;
+            code++;
+        }
+        if (ch == 0 || code == 0xFF) {  // Input is zero or complete block
+            *code_ptr = code ^ eop;
+            code = 1;
+            code_ptr = dst++;
+        }
+    }
+    *code_ptr = code ^ eop;             // Final code
+    return (dst - start);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Compute the encoding length of unencoded data
+
+  @param  ptr Pointer to the data to encode
+  @param  length Length of the data to encode
+
+  @return the length required for encoded data
+
+  @note  The computed length does not include the EOP (end-of-packet) marker
+ */
+/**************************************************************************/
+uint32_t cobsEncodedLength(const uint8_t *ptr, uint32_t length)
+{
+    uint8_t ch;
+    uint32_t dst = 1;
+    uint8_t code = 1;
+    while (length--) {
+        ch = *ptr++;
+        if (ch != 0) {                  // Input byte not zero
+            dst++;
+            code++;
+        }
+        if (ch == 0 || code == 0xFF) {  // Input is zero or complete block
+            code = 1;
+            dst++;
+        }
+    }
+    return dst;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Compute the max encoding length for a given length of unencoded data
+
+  @param  length Length of the data to encode
+
+  @return The max length required to encode the data
+
+  @note  Since the contents of the buffer are unknown, then we must assume
+          that the entire buffer has no end-of-packet markers. This would
+          require the injection of overhead bytes (as opposed to the
+          replacement of end-of-packet markers with overhead bytes) at
+          intervals of 255, thus producing the worst case scenario.
+  @note  An additional byte is added for the EOP (end-of-packet) marker.
+ */
+/**************************************************************************/
+uint32_t cobsEncodedMaxLength(uint32_t length)
+{
+    const uint32_t overheadBytes = ((length / 254) + ((length % 254) > 0));
+    return (length + overheadBytes + COBS_EOP_OVERHEAD);
+}
+
+//**************************************************************************/
+/*!
+  @brief Compute the maximum length of unencoded data that can fit into a
+  buffer of specified length.
+
+  @param  bufLen Length of the buffer in bytes
+
+  @return the length of unencoded data
+
+  @note  The computation may leave additional space at the end.
+  @note  An additional byte is added for the EOP (end-of-packet) marker.
+ */
+/**************************************************************************/
+uint32_t cobsGuaranteedFit(uint32_t bufLen)
+{
+    uint32_t cobsOverhead = 1 + (bufLen / 254) + COBS_EOP_OVERHEAD;
+    return (cobsOverhead > bufLen ? 0 : (bufLen - cobsOverhead));
+}
diff --git a/src/note-c/n_const.c b/src/note-c/n_const.c
new file mode 100644
index 0000000..41ce569
--- /dev/null
+++ b/src/note-c/n_const.c
@@ -0,0 +1,30 @@
+/*!
+ * @file n_const.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include "n_lib.h"
+
+const char *c_null = "null";
+const char *c_false = "false";
+const char *c_true = "true";
+const char *c_nullstring = "";
+const char *c_newline = "\r\n";
+const char *c_mem = "mem";
+const char *c_iotimeout = "timeout {io}";
+const char *c_err = "err";
+const char *c_req = "req";
+const char *c_cmd = "cmd";
+const char *c_bad = "bad";
+const char *c_iobad = "bad {io}";
+const char *c_ioerr = "{io}";
+const char *c_unsupported = "{not-supported}";
+const char *c_badbinerr = "{bad-bin}";
diff --git a/src/note-c/n_ftoa.c b/src/note-c/n_ftoa.c
new file mode 100644
index 0000000..c1df61b
--- /dev/null
+++ b/src/note-c/n_ftoa.c
@@ -0,0 +1,510 @@
+/*
+ * Modified by Dave Hart for integration into NTP 4.2.7 <hart@ntp.org>
+ *
+ * Copyright (c) 1995 Patrick Powell.
+ *
+ * This code is based on code written by Patrick Powell <papowell@astart.com>.
+ * It may be used for any purpose as long as this notice remains intact on all
+ * source code distributions.
+ *
+ * Copyright (c) 2008 Holger Weiss.
+ *
+ * This version of the code is maintained by Holger Weiss <holger@jhweiss.de>.
+ * My changes to the code may freely be used, modified and/or redistributed for
+ * any purpose.  It would be nice if additions and fixes to this file (including
+ * trivial code cleanups) would be sent back in order to let me include them in
+ * the version available at <http://www.jhweiss.de/software/snprintf.html>.
+ * However, this is not a requirement for using or redistributing (possibly
+ * modified) versions of this file, nor is leaving this notice intact mandatory.
+ */
+
+
+#include "n_lib.h"
+#include <stdint.h>
+#include <math.h>
+
+#define	PRINT_F_QUOTE		0x0001
+#define	PRINT_F_TYPE_E		0x0002
+#define	PRINT_F_TYPE_G		0x0004
+#define	PRINT_F_NUM			0x0008
+#define	PRINT_F_PLUS		0x0010
+#define	PRINT_F_MINUS		0x0020
+#define	PRINT_F_ZERO		0x0040
+#define	PRINT_F_SPACE		0x0080
+#define	PRINT_F_UP			0x0100
+
+static void fmtstr(char *, size_t *, size_t, const char *, int, int, int);
+static void fmtflt(char *, size_t *, size_t, JNUMBER, int, int, int, int *);
+static void printsep(char *, size_t *, size_t);
+static int getnumsep(int);
+static int getexponent(JNUMBER);
+static int convert(uintmax_t, char *, size_t, int, int);
+static uintmax_t cast(JNUMBER);
+static uintmax_t myround(JNUMBER);
+static JNUMBER mypow10(int);
+#define OUTCHAR(str, len, size, ch) \
+do { \
+	if (len + 1 < size) \
+		str[len] = ch; \
+	(len)++; \
+} while (0)
+
+// Convert a JNUMBER into a null-terminated text string.  Note that buf must
+// be pointing at a buffer of JNTOA_MAX length, which is defined so that it
+// includes enough space for the null terminator, so there's no need to
+// have a buffer of JNTOA_MAX+1.
+char * JNtoA(JNUMBER f, char * buf, int precision)
+{
+    int overflow = 0;
+    size_t len = 0;
+    int flags = PRINT_F_TYPE_G;
+    if (precision < 0) {
+        precision = JNTOA_PRECISION;
+    }
+    fmtflt(buf, &len, JNTOA_MAX, f, -1, precision, flags, &overflow);
+    if (overflow) {
+        len = 0;
+        buf[len++] = '0';
+    }
+    buf[len] = '\0';
+    return buf;
+}
+
+static void
+fmtflt(char *str, size_t *len, size_t size, JNUMBER fvalue, int width,
+       int precision, int flags, int *overflow)
+{
+    JNUMBER ufvalue;
+    uintmax_t intpart;
+    uintmax_t fracpart;
+    uintmax_t mask;
+    const char *infnan = NULL;
+    char iconvert[JNTOA_MAX];
+    char fconvert[JNTOA_MAX];
+    char econvert[6];   /* "e-1024" (without nul-termination). */
+    char esign = 0;
+    char sign = 0;
+    int leadfraczeros = 0;
+    int exponent = 0;
+    int emitpoint = 0;
+    int omitzeros = 0;
+    int omitcount = 0;
+    int padlen = 0;
+    int epos = 0;
+    int fpos = 0;
+    int ipos = 0;
+    int separators = (flags & PRINT_F_QUOTE);
+    int estyle = (flags & PRINT_F_TYPE_E);
+
+    /*
+     * AIX' man page says the default is 0, but C99 and at least Solaris'
+     * and NetBSD's man pages say the default is 6, and sprintf(3) on AIX
+     * defaults to 6.
+     */
+    if (precision == -1) {
+        precision = 6;
+    }
+
+    if (fvalue < 0.0) {
+        sign = '-';
+    } else if (flags & PRINT_F_PLUS) {	/* Do a sign. */
+        sign = '+';
+    } else if (flags & PRINT_F_SPACE) {
+        sign = ' ';
+    }
+
+    if (isnan(fvalue)) {
+        infnan = (flags & PRINT_F_UP) ? "NAN" : "nan";
+    } else if (isinf(fvalue)) {
+        infnan = (flags & PRINT_F_UP) ? "INF" : "inf";
+    }
+
+    if (infnan != NULL) {
+        if (sign != 0) {
+            iconvert[ipos++] = sign;
+        }
+        while (*infnan != '\0') {
+            iconvert[ipos++] = *infnan++;
+        }
+        fmtstr(str, len, size, iconvert, width, ipos, flags);
+        return;
+    }
+
+    /* "%e" (or "%E") or "%g" (or "%G") conversion. */
+    if (flags & PRINT_F_TYPE_E || flags & PRINT_F_TYPE_G) {
+        if (flags & PRINT_F_TYPE_G) {
+            /*
+             * For "%g" (and "%G") conversions, the precision
+             * specifies the number of significant digits, which
+             * includes the digits in the integer part.  The
+             * conversion will or will not be using "e-style" (like
+             * "%e" or "%E" conversions) depending on the precision
+             * and on the exponent.  However, the exponent can be
+             * affected by rounding the converted value, so we'll
+             * leave this decision for later.  Until then, we'll
+             * assume that we're going to do an "e-style" conversion
+             * (in order to get the exponent calculated).  For
+             * "e-style", the precision must be decremented by one.
+             */
+            precision--;
+            /*
+             * For "%g" (and "%G") conversions, trailing zeros are
+             * removed from the fractional portion of the result
+             * unless the "#" flag was specified.
+             */
+            if (!(flags & PRINT_F_NUM)) {
+                omitzeros = 1;
+            }
+        }
+        exponent = getexponent(fvalue);
+        estyle = 1;
+    }
+
+again:
+    /*
+     * Sorry, we only support 9, 19, or 38 digits (that is, the number of
+     * digits of the 32-bit, the 64-bit, or the 128-bit UINTMAX_MAX value
+     * minus one) past the decimal point due to our conversion method.
+     */
+    switch (sizeof(uintmax_t)) {
+    case 16:
+        if (precision > 38) {
+            precision = 38;
+        }
+        break;
+    case 8:
+        if (precision > 19) {
+            precision = 19;
+        }
+        break;
+    default:
+        if (precision > 9) {
+            precision = 9;
+        }
+        break;
+    }
+
+    ufvalue = (fvalue >= 0.0) ? fvalue : -fvalue;
+    if (estyle) {	/* We want exactly one integer digit. */
+        ufvalue /= mypow10(exponent);
+    }
+
+    if ((intpart = cast(ufvalue)) == UINTMAX_MAX) {
+        *overflow = 1;
+        return;
+    }
+
+    /*
+     * Factor of ten with the number of digits needed for the fractional
+     * part.  For example, if the precision is 3, the mask will be 1000.
+     */
+    mask = (uintmax_t)mypow10(precision);
+    /*
+     * We "cheat" by converting the fractional part to integer by
+     * multiplying by a factor of ten.
+     */
+    if ((fracpart = myround(mask * (ufvalue - intpart))) >= mask) {
+        /*
+         * For example, ufvalue = 2.99962, intpart = 2, and mask = 1000
+         * (because precision = 3).  Now, myround(1000 * 0.99962) will
+         * return 1000.  So, the integer part must be incremented by one
+         * and the fractional part must be set to zero.
+         */
+        intpart++;
+        fracpart = 0;
+        if (estyle && intpart == 10) {
+            /*
+             * The value was rounded up to ten, but we only want one
+             * integer digit if using "e-style".  So, the integer
+             * part must be set to one and the exponent must be
+             * incremented by one.
+             */
+            intpart = 1;
+            exponent++;
+        }
+    }
+
+    /*
+     * Now that we know the real exponent, we can check whether or not to
+     * use "e-style" for "%g" (and "%G") conversions.  If we don't need
+     * "e-style", the precision must be adjusted and the integer and
+     * fractional parts must be recalculated from the original value.
+     *
+     * C99 says: "Let P equal the precision if nonzero, 6 if the precision
+     * is omitted, or 1 if the precision is zero.  Then, if a conversion
+     * with style `E' would have an exponent of X:
+     *
+     * - if P > X >= -4, the conversion is with style `f' (or `F') and
+     *   precision P - (X + 1).
+     *
+     * - otherwise, the conversion is with style `e' (or `E') and precision
+     *   P - 1." (7.19.6.1, 8)
+     *
+     * Note that we had decremented the precision by one.
+     */
+    if (flags & PRINT_F_TYPE_G && estyle &&
+            precision + 1 > exponent && exponent >= -4) {
+        precision -= exponent;
+        estyle = 0;
+        goto again;
+    }
+
+    if (estyle) {
+        if (exponent < 0) {
+            exponent = -exponent;
+            esign = '-';
+        } else {
+            esign = '+';
+        }
+
+        /*
+         * Convert the exponent.  The sizeof(econvert) is 6.  So, the
+         * econvert buffer can hold e.g. "e+1024" and "e-1024".
+         */
+        size_t digits = 2;
+        if (exponent > 99 || exponent < -99) {
+            digits++;
+        }
+        if (exponent > 999 || exponent < -999) {
+            digits++;
+        }
+        epos = convert(exponent, econvert, digits, 10, 0);
+        /*
+         * C99 says: "The exponent always contains at least two digits,
+         * and only as many more digits as necessary to represent the
+         * exponent." (7.19.6.1, 8)
+         */
+        if (epos == 1) {
+            econvert[epos++] = '0';
+        }
+        econvert[epos++] = esign;
+        econvert[epos++] = (flags & PRINT_F_UP) ? 'E' : 'e';
+    }
+
+    /* Convert the integer part and the fractional part. */
+    ipos = convert(intpart, iconvert, sizeof(iconvert), 10, 0);
+    if (fracpart != 0) {	/* convert() would return 1 if fracpart == 0. */
+        fpos = convert(fracpart, fconvert, sizeof(fconvert), 10, 0);
+    }
+
+    leadfraczeros = precision - fpos;
+
+    if (omitzeros) {
+        if (fpos > 0) {    /* Omit trailing fractional part zeros. */
+            while (omitcount < fpos && fconvert[omitcount] == '0') {
+                omitcount++;
+            }
+        } else {  /* The fractional part is zero, omit it completely. */
+            omitcount = precision;
+            leadfraczeros = 0;
+        }
+        precision -= omitcount;
+    }
+
+    /*
+     * Print a decimal point if either the fractional part is non-zero
+     * and/or the "#" flag was specified.
+     */
+    if (precision > 0 || flags & PRINT_F_NUM) {
+        emitpoint = 1;
+    }
+    if (separators) {	/* Get the number of group separators we'll print. */
+        separators = getnumsep(ipos);
+    }
+
+    padlen = width                  /* Minimum field width. */
+             - ipos                      /* Number of integer digits. */
+             - epos                      /* Number of exponent characters. */
+             - precision                 /* Number of fractional digits. */
+             - separators                /* Number of group separators. */
+             - (emitpoint ? 1 : 0)       /* Will we print a decimal point? */
+             - ((sign != 0) ? 1 : 0);    /* Will we print a sign character? */
+
+    if (padlen < 0) {
+        padlen = 0;
+    }
+
+    /*
+     * C99 says: "If the `0' and `-' flags both appear, the `0' flag is
+     * ignored." (7.19.6.1, 6)
+     */
+    if (flags & PRINT_F_MINUS) {	/* Left justifty. */
+        padlen = -padlen;
+    } else if (flags & PRINT_F_ZERO && padlen > 0) {
+        if (sign != 0) {	/* Sign. */
+            OUTCHAR(str, *len, size, sign);
+            sign = 0;
+        }
+        while (padlen > 0) {	/* Leading zeros. */
+            OUTCHAR(str, *len, size, '0');
+            padlen--;
+        }
+    }
+    while (padlen > 0) {	/* Leading spaces. */
+        OUTCHAR(str, *len, size, ' ');
+        padlen--;
+    }
+    if (sign != 0) {	/* Sign. */
+        OUTCHAR(str, *len, size, sign);
+    }
+    while (ipos > 0) {	/* Integer part. */
+        ipos--;
+        OUTCHAR(str, *len, size, iconvert[ipos]);
+        if (separators > 0 && ipos > 0 && ipos % 3 == 0) {
+            printsep(str, len, size);
+        }
+    }
+    if (emitpoint) {	/* Decimal point. */
+        OUTCHAR(str, *len, size, '.');
+    }
+    while (leadfraczeros > 0) {	/* Leading fractional part zeros. */
+        OUTCHAR(str, *len, size, '0');
+        leadfraczeros--;
+    }
+    while (fpos > omitcount) {	/* The remaining fractional part. */
+        fpos--;
+        OUTCHAR(str, *len, size, fconvert[fpos]);
+    }
+    while (epos > 0) {	/* Exponent. */
+        epos--;
+        OUTCHAR(str, *len, size, econvert[epos]);
+    }
+    while (padlen < 0) {	/* Trailing spaces. */
+        OUTCHAR(str, *len, size, ' ');
+        padlen++;
+    }
+}
+
+static void fmtstr(char *str, size_t *len, size_t size, const char *value, int width,
+                   int precision, int flags)
+{
+    int padlen, strln;	/* Amount to pad. */
+    int noprecision = (precision == -1);
+
+    if (value == NULL) {	/* We're forgiving. */
+        value = "(null)";
+    }
+
+    /* If a precision was specified, don't read the string past it. */
+    for (strln = 0; value[strln] != '\0' &&
+            (noprecision || strln < precision); strln++) {
+        continue;
+    }
+
+    if ((padlen = width - strln) < 0) {
+        padlen = 0;
+    }
+    if (flags & PRINT_F_MINUS) {	/* Left justify. */
+        padlen = -padlen;
+    }
+
+    while (padlen > 0) {	/* Leading spaces. */
+        OUTCHAR(str, *len, size, ' ');
+        padlen--;
+    }
+    while (*value != '\0' && (noprecision || precision-- > 0)) {
+        OUTCHAR(str, *len, size, *value);
+        value++;
+    }
+    while (padlen < 0) {	/* Trailing spaces. */
+        OUTCHAR(str, *len, size, ' ');
+        padlen++;
+    }
+}
+
+static void printsep(char *str, size_t *len, size_t size)
+{
+    OUTCHAR(str, *len, size, ',');
+}
+
+static int getnumsep(int digits)
+{
+    int separators = (digits - ((digits % 3 == 0) ? 1 : 0)) / 3;
+    return separators;
+}
+
+static int getexponent(JNUMBER value)
+{
+    JNUMBER tmp = (value >= 0.0) ? value : -value;
+    int exponent = 0;
+
+    /*
+     * We check for 1023 >= exponent >= -1022 in order to work around possible
+     * endless loops which could happen (at least) in the second loop (at
+     * least) if we're called with an infinite value.  However, we checked
+     * for infinity before calling this function using our ISINF() macro, so
+     * this might be somewhat paranoid.
+     */
+    while (tmp < 1.0 && tmp > 0.0 && --exponent >= -1022) {
+        tmp *= 10;
+    }
+    while (tmp >= 10.0 && ++exponent <= 1023) {
+        tmp /= 10;
+    }
+
+    return exponent;
+}
+
+static int convert(uintmax_t value, char *buf, size_t size, int base, int caps)
+{
+    const char *digits = caps ? "0123456789ABCDEF" : "0123456789abcdef";
+    size_t pos = 0;
+
+    /* We return an unterminated buffer with the digits in reverse order. */
+    do {
+        buf[pos++] = digits[value % base];
+        value /= base;
+    } while (value != 0 && pos < size);
+
+    return (int)pos;
+}
+
+static uintmax_t cast(JNUMBER value)
+{
+    uintmax_t result;
+
+    /*
+     * We check for ">=" and not for ">" because if UINTMAX_MAX cannot be
+     * represented exactly as an JNUMBER value (but is less than LDBL_MAX),
+     * it may be increased to the nearest higher representable value for the
+     * comparison (cf. C99: 6.3.1.4, 2).  It might then equal the JNUMBER
+     * value although converting the latter to uintmax_t would overflow.
+     */
+    if (value >= UINTMAX_MAX) {
+        return UINTMAX_MAX;
+    }
+
+    result = (uintmax_t)value;
+    /*
+     * At least on NetBSD/sparc64 3.0.2 and 4.99.30, casting long double to
+     * an integer type converts e.g. 1.9 to 2 instead of 1 (which violates
+     * the standard).  Sigh.
+     */
+    return (result <= value) ? result : result - 1;
+}
+
+static uintmax_t myround(JNUMBER value)
+{
+    uintmax_t intpart = cast(value);
+
+    if (intpart == UINTMAX_MAX) {
+        return UINTMAX_MAX;
+    }
+
+    return ((value -= intpart) < 0.5) ? intpart : intpart + 1;
+}
+
+static JNUMBER mypow10(int exponent)
+{
+    JNUMBER result = 1;
+
+    while (exponent > 0) {
+        result *= 10;
+        exponent--;
+    }
+    while (exponent < 0) {
+        result /= 10;
+        exponent++;
+    }
+    return result;
+}
diff --git a/src/note-c/n_helpers.c b/src/note-c/n_helpers.c
new file mode 100644
index 0000000..131989b
--- /dev/null
+++ b/src/note-c/n_helpers.c
@@ -0,0 +1,2575 @@
+/*!
+ * @file n_helpers.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include "n_lib.h"
+
+#ifdef NOTE_C_TEST
+#include "test_static.h"
+#else
+#define NOTE_C_STATIC static
+#endif
+
+// When interfacing with the Notecard, it is generally encouraged that the JSON
+// object manipulation and calls to the note-arduino library are done directly
+// at point of need. However, there are cases in which it's convenient to have a
+// wrapper. The most common reason is when it's best to have a suppression timer
+// on the actual call to the Notecard so as not to assault the I2C bus or UART
+// on a continuing basis - the most common examples of this being "card.time"
+// and any other Notecard state that needs to be polled for an app, such as the
+// device location, its voltage level, and so on.  This file contains this kind
+// of wrapper, just implemented here as a convenience to all developers.
+
+// Time-related suppression timer and cache
+static uint32_t timeBaseSetAtMs = 0;
+static JTIME timeBaseSec = 0;
+static bool timeBaseSetManually = false;
+static uint32_t suppressionTimerSecs = 10;
+static uint32_t refreshTimerSecs = 86400;
+static uint32_t timeTimer = 0;
+static uint32_t timeRefreshTimer = 0;
+static bool zoneStillUnavailable = true;
+static bool zoneForceRefresh = false;
+static char curZone[10] = {0};
+static char curArea[64] = {0};
+static char curCountry[8] = "";
+static int curZoneOffsetMins = 0;
+
+// Location-related suppression timer and cache
+static uint32_t locationTimer = 0;
+static char locationLastErr[64] = {0};
+static bool locationValid = false;
+
+// Connection-related suppression timer and cache
+static uint32_t connectivityTimer = 0;
+static bool cardConnected = false;
+
+// Status suppression timer
+static uint32_t statusTimer = 0;
+
+// DEPRECATED. Turbo communications mode, for special use cases and well-tested
+// hardware.
+bool cardTurboIO = false;
+
+// Service config-related suppression timer and cache
+static uint32_t serviceConfigTimer = 0;
+static char scDevice[128] = {0};
+static char scSN[128] = {0};
+static char scProduct[128] = {0};
+static char scService[128] = {0};
+
+// For date conversions
+#define daysByMonth(y) ((y)&03||(y)==0?normalYearDaysByMonth:leapYearDaysByMonth)
+static short leapYearDaysByMonth[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
+static short normalYearDaysByMonth[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
+static const char *daynames[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+
+// Forwards
+NOTE_C_STATIC void setTime(JTIME seconds);
+NOTE_C_STATIC bool timerExpiredSecs(uint32_t *timer, uint32_t periodSecs);
+NOTE_C_STATIC int yToDays(int year);
+
+static const char NOTE_C_BINARY_EOP = '\n';
+
+//**************************************************************************/
+/*!
+  @brief  Decode binary data received from the Notecard.
+
+  @param  encData The encoded binary data to decode.
+  @param  encDataLen The length of the encoded binary data.
+  @param  decBuf The target buffer for the decoded data. For in-place decoding,
+                 `decBuf` can use the same address as `encData` (see note).
+  @param  decBufSize The size of `decBuf`.
+
+  @returns  The length of the decoded data, or zero on error.
+
+  @note Use `NoteBinaryCodecMaxDecodedLength()` to calculate the required
+        size for the buffer pointed to by the `decBuf` parameter, which MUST
+        accommodate both the encoded data and newline terminator.
+  @note This API supports in-place decoding. If you wish to utilize in-place
+        decoding, then set `decBuf` to `encData` and `decBufSize` to `encLen`.
+ */
+/**************************************************************************/
+uint32_t NoteBinaryCodecDecode(const uint8_t *encData, uint32_t encDataLen,
+                               uint8_t *decBuf, uint32_t decBufSize)
+{
+    uint32_t result;
+
+    // Validate parameter(s)
+    if (encData == NULL || decBuf == NULL) {
+        NOTE_C_LOG_ERROR(ERRSTR("NULL parameter", c_err));
+        result = 0;
+    } else if (decBufSize < cobsGuaranteedFit(encDataLen)) {
+        NOTE_C_LOG_ERROR(ERRSTR("output buffer too small", c_err));
+        result = 0;
+    } else {
+        result = cobsDecode((uint8_t *)encData, encDataLen, NOTE_C_BINARY_EOP, decBuf);
+    }
+
+    return result;
+}
+
+//**************************************************************************/
+/*!
+
+  @brief  Encode binary data to transmit to the Notecard.
+
+  @param  decData The decoded binary data to encode.
+  @param  decDataLen The length of the decoded binary data.
+  @param  encBuf The target buffer for the encoded data. For in-place encoding,
+                 `encBuf` can use the same buffer as `decData`, but cannot
+                 share the same address (see note).
+  @param  encBufSize The size of `encBuf`.
+
+  @returns  The length of the encoded data, or zero on error.
+
+  @note Use `NoteBinaryCodecMaxEncodedLength()` to calculate the required
+        size for the buffer pointed to by the `encBuf` parameter, which MUST
+        accommodate both the encoded data and newline terminator.
+  @note This API supports in-place encoding. If you wish to utilize in-place
+        encoding, shift the decoded data to the end of the buffer, update
+        `decBuf` accordingly, and set the value of `encBuf` to the beginning
+        of the buffer.
+ */
+/**************************************************************************/
+uint32_t NoteBinaryCodecEncode(const uint8_t *decData, uint32_t decDataLen,
+                               uint8_t *encBuf, uint32_t encBufSize)
+{
+    uint32_t result;
+
+    // Validate parameter(s)
+    if (decData == NULL || encBuf == NULL) {
+        NOTE_C_LOG_ERROR(ERRSTR("NULL parameter", c_err));
+        result = 0;
+    } else if ((encBufSize < cobsEncodedMaxLength(decDataLen))
+               && (encBufSize < cobsEncodedLength(decData, decDataLen))) {
+        // NOTE: `cobsEncodedMaxLength()` provides a constant time [O(1)] means
+        //       of checking the buffer size. Only when it fails will the linear
+        //       time [O(n)] check, `cobsEncodedLength()`, be invoked.
+        NOTE_C_LOG_ERROR(ERRSTR("output buffer too small", c_err));
+        result = 0;
+    } else {
+        result = cobsEncode((uint8_t *)decData, decDataLen, NOTE_C_BINARY_EOP, encBuf);
+    }
+
+    return result;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Compute the maximum decoded data length guaranteed
+          to fit into a fixed-size buffer, after being encoded.
+
+          This API is designed for a space constrained environment, where a
+          working buffer has been allocated to facilitate binary transactions.
+
+          There are two primary use cases:
+
+          1. When data is retrieved from the Notecard, it must be requested in
+             terms of the unencoded offset and length. However, the data is
+             encoded prior to transmission, and, as a result, the buffer must be
+             capable of receiving the encoded (larger) data. This API returns a
+             length that is safe to request from the Notecard, because the
+             resulting encoded data is guaranteed to fit in the provided buffer.
+          2. When data is transmitted to the Notecard, this API can be used to
+             verify whether or not unencoded data of a given length will fit in
+             the provided buffer after encoding.
+
+  @param  bufferSize The size of the fixed-size buffer.
+
+  @returns  The max length of unencoded data certain to fit in the fixed-size
+            buffer, after being encoded.
+ */
+/**************************************************************************/
+uint32_t NoteBinaryCodecMaxDecodedLength(uint32_t bufferSize)
+{
+    return cobsGuaranteedFit(bufferSize);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Compute the maximum buffer size needed to encode
+          any unencoded buffer of the given length.
+
+  @param  unencodedLength The length of an unencoded buffer.
+
+  @returns  The max required buffer size to hold the encoded data.
+ */
+/**************************************************************************/
+uint32_t NoteBinaryCodecMaxEncodedLength(uint32_t unencodedLength)
+{
+    return cobsEncodedMaxLength(unencodedLength);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the length of the data in the Notecard's binary store. If there's
+          no data on the Notecard, then `*len` will return 0.
+
+  @param  len [out] The length of the decoded contents of the Notecard's binary
+          store.
+
+  @returns An error string on error and NULL on success.
+ */
+/**************************************************************************/
+const char * NoteBinaryStoreDecodedLength(uint32_t *len)
+{
+    // Validate parameter(s)
+    if (!len) {
+        const char *err = ERRSTR("len cannot be NULL", c_bad);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Issue a "card.binary" request.
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.binary"));
+    if (!rsp) {
+        const char *err = ERRSTR("unable to issue binary request", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Ensure the transaction doesn't return an error
+    // and confirm the binary feature is available
+    if (NoteResponseError(rsp)) {
+        const char *jErr = JGetString(rsp, "err");
+        // Swallow `{bad-bin}` errors, because we intend to overwrite the data.
+        if (!NoteErrorContains(jErr, c_badbinerr)) {
+            NOTE_C_LOG_ERROR(jErr);
+            JDelete(rsp);
+            const char *err = ERRSTR("unexpected error received during handshake", c_bad);
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+    }
+
+    // Examine "length" from the response to evaluate the length of the decoded
+    // data residing on the Notecard.
+    *len = JGetInt(rsp, "length");
+    JDelete(rsp);
+
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the required buffer length to receive the entire binary object
+          stored in the Notecard's binary store.
+
+  @param  len [out] The length required to hold the entire contents of the
+          Notecard's binary store. If there's no data on the Notecard, then
+          `len` will return 0.
+
+  @returns An error string on error and NULL on success.
+ */
+/**************************************************************************/
+const char * NoteBinaryStoreEncodedLength(uint32_t *len)
+{
+    // Validate parameter(s)
+    if (!len) {
+        const char *err = ERRSTR("size cannot be NULL", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Issue a "card.binary" request.
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.binary"));
+    if (!rsp) {
+        const char *err = ERRSTR("unable to issue binary request", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Ensure the transaction doesn't return an error
+    // and confirm the binary feature is available
+    if (NoteResponseError(rsp)) {
+        const char *jErr = JGetString(rsp, "err");
+        // Swallow `{bad-bin}` errors, because we intend to overwrite the data.
+        if (!NoteErrorContains(jErr, c_badbinerr)) {
+            NOTE_C_LOG_ERROR(jErr);
+            JDelete(rsp);
+            const char *err = ERRSTR("unexpected error received during handshake", c_bad);
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+    }
+
+    // Examine "cobs" from the response to evaluate the space required to hold
+    // the encoded data to be received from the Notecard.
+    long int cobs = JGetInt(rsp, "cobs");
+    JDelete(rsp);
+    *len = cobs;
+
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Receive a large binary object from the Notecard's binary store.
+
+  @param  buffer A buffer to hold the binary range.
+  @param  bufLen The total length of the provided buffer.
+  @param  decodedOffset The offset to the decoded binary data residing
+                        in the Notecard's binary store.
+  @param  decodedLen The length of the decoded data to fetch from the Notecard.
+
+  @returns  NULL on success, else an error string pointer.
+
+  @note  The buffer must be large enough to hold the encoded value of the
+         data store contents from the requested offset for the specified length.
+         To determine the necessary buffer size for a given data length, use
+         `NoteBinaryCodecMaxEncodedLength()`, or if you wish to consume the
+         entire buffer use `(NoteBinaryStoreEncodedLength() + 1)` instead.
+ */
+/**************************************************************************/
+const char * NoteBinaryStoreReceive(uint8_t *buffer, uint32_t bufLen,
+                                    uint32_t decodedOffset, uint32_t decodedLen)
+{
+    // Validate parameter(s)
+    if (!buffer) {
+        const char *err = ERRSTR("NULL buffer", c_bad);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+    if (bufLen < cobsEncodedMaxLength(decodedLen)) {
+        const char *err = ERRSTR("insufficient buffer size", c_bad);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+    if (decodedLen == 0) {
+        const char *err = ERRSTR("decodedLen cannot be zero (0)", c_bad);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Claim Notecard Mutex
+    _LockNote();
+
+    // Issue `card.binary.get` and capture `"status"` from response
+    char status[NOTE_MD5_HASH_STRING_SIZE] = {0};
+    J *req = NoteNewRequest("card.binary.get");
+    if (req) {
+        JAddIntToObject(req, "offset", decodedOffset);
+        JAddIntToObject(req, "length", decodedLen);
+
+        // We already have the Notecard lock, so call
+        // noteTransactionShouldLock with `lockNotecard` set to false so we
+        // don't try to lock again.
+        J *rsp = noteTransactionShouldLock(req, false);
+        JDelete(req);
+        // Ensure the transaction doesn't return an error.
+        if (!rsp || NoteResponseError(rsp)) {
+            if (rsp) {
+                NOTE_C_LOG_ERROR(JGetString(rsp,"err"));
+                JDelete(rsp);
+            }
+
+            const char *err = ERRSTR("failed to initialize binary transaction", c_err);
+            NOTE_C_LOG_ERROR(err);
+            _UnlockNote();
+            return err;
+        }
+
+        // Examine "status" from the response to evaluate the MD5 checksum.
+        strlcpy(status, JGetString(rsp,"status"), NOTE_MD5_HASH_STRING_SIZE);
+        JDelete(rsp);
+    } else {
+        const char *err = ERRSTR("unable to allocate request", c_mem);
+        NOTE_C_LOG_ERROR(err);
+        _UnlockNote();
+        return err;
+    }
+
+    // Read raw bytes from the active interface into a predefined buffer
+    uint32_t available = 0;
+    NOTE_C_LOG_DEBUG("receiving binary data...");
+    const char *err = _ChunkedReceive(buffer, &bufLen, false, (CARD_INTRA_TRANSACTION_TIMEOUT_SEC * 1000), &available);
+    NOTE_C_LOG_DEBUG("binary receive complete.");
+
+    // Release Notecard Mutex
+    _UnlockNote();
+
+    // Ensure transaction was successful
+    if (err) {
+        // Queue a reset when a problem is detected, otherwise `note-c` will
+        // attempt to allocate memory to receive the response.
+        NoteResetRequired();
+        return ERRSTR(err, c_err);
+    }
+
+    // Check buffer overflow condition
+    if (available) {
+        const char *err = ERRSTR("unexpected data available", c_err);
+        NOTE_C_LOG_ERROR(err);
+        // Queue a reset when a problem is detected, otherwise `note-c` will
+        // attempt to allocate memory to receive the response.
+        NoteResetRequired();
+        return err;
+    }
+
+    // _ChunkedReceive returns the raw bytes that came off the wire, which
+    // includes a terminating newline that ends the packet. This newline isn't
+    // part of the binary payload, so we decrement the length by 1 to remove it.
+    --bufLen;
+
+    // Decode it in place, which is safe because decoding shrinks
+    const uint32_t decLen = NoteBinaryCodecDecode(buffer, bufLen, buffer, bufLen);
+
+    // Ensure the decoded length matches the caller's expectations.
+    if (decodedLen != decLen) {
+        const char *err = ERRSTR("length mismatch after decoding", c_err);
+        NOTE_C_LOG_ERROR(err);
+        // Queue a reset when a problem is detected, otherwise `note-c` will
+        // attempt to allocate memory to receive the response.
+        NoteResetRequired();
+        return err;
+    }
+
+    // Put a hard marker at the end of the decoded portion of the buffer. This
+    // enables easier human reasoning when interrogating the buffer, if the
+    // buffer holds a string.
+    buffer[decLen] = '\0';
+
+    // Verify MD5
+    char hashString[NOTE_MD5_HASH_STRING_SIZE] = {0};
+    NoteMD5HashString(buffer, decLen, hashString, NOTE_MD5_HASH_STRING_SIZE);
+    if (strncmp(hashString, status, NOTE_MD5_HASH_STRING_SIZE)) {
+        const char *err = ERRSTR("computed MD5 does not match received MD5", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Return `NULL` if success, else error string pointer
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Reset the Notecard's binary store.
+
+  @returns  NULL on success, else an error string pointer.
+
+  @note  This operation is necessary to clear the Notecard's binary buffer after
+         a binary object is received from the Notecard, or if the Notecard's
+         binary store has been left in an unknown state due to an error arising
+         from a binary transfer to the Notecard.
+ */
+/**************************************************************************/
+const char * NoteBinaryStoreReset(void)
+{
+    J *req = NoteNewRequest("card.binary");
+    if (req) {
+        JAddBoolToObject(req, "delete", true);
+
+        // Ensure the transaction doesn't return an error.
+        J *rsp = NoteRequestResponse(req);
+        if (NoteResponseError(rsp)) {
+            NOTE_C_LOG_ERROR(JGetString(rsp,"err"));
+            JDelete(rsp);
+            const char *err = ERRSTR("failed to reset binary buffer", c_err);
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+
+        JDelete(rsp);
+    } else {
+        const char *err = ERRSTR("unable to allocate request", c_mem);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Transmit a large binary object to the Notecard's binary store.
+
+  @param  unencodedData  A buffer with data to encode in place.
+  @param  unencodedLen   The length of the data in the buffer.
+  @param  bufLen         The total length of the buffer (see notes).
+  @param  notecardOffset The offset where the data buffer should be appended
+                         to the decoded binary data residing in the Notecard's
+                         binary store. This does not provide random access, but
+                         rather ensures alignment across sequential writes.
+
+  @returns  NULL on success, else an error string pointer.
+
+  @note  Buffers are encoded in place, the buffer _MUST_ be larger than the data
+         to be encoded. The original contents of the buffer will be modified.
+         Use `NoteBinaryCodecMaxEncodedLength()` to calculate the required size
+         for the buffer pointed to by the `unencodedData` parameter, which MUST
+         accommodate both the encoded data and newline terminator.
+ */
+/**************************************************************************/
+const char * NoteBinaryStoreTransmit(uint8_t *unencodedData, uint32_t unencodedLen,
+                                     uint32_t bufLen, uint32_t notecardOffset)
+{
+    // Validate parameter(s)
+    if (!unencodedData) {
+        const char *err = ERRSTR("unencodedData cannot be NULL", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    } else if ((bufLen < cobsEncodedMaxLength(unencodedLen))
+               && (bufLen < (cobsEncodedLength(unencodedData, unencodedLen) + 1))) {
+        // NOTE: `cobsEncodedMaxLength()` provides a constant time [O(1)] means
+        //       of checking the buffer size. Only when it fails will the linear
+        //       time [O(n)] check, `cobsEncodedLength()`, be invoked.
+        const char *err = ERRSTR("insufficient buffer size", c_bad);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Issue a "card.binary" request.
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.binary"));
+    if (!rsp) {
+        const char *err = ERRSTR("unable to issue binary request", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Ensure the transaction doesn't return an error
+    // and confirm the binary feature is available
+    if (NoteResponseError(rsp)) {
+        const char *jErr = JGetString(rsp, "err");
+        // Swallow `{bad-bin}` errors, because we intend to overwrite the data.
+        if (!NoteErrorContains(jErr, c_badbinerr)) {
+            NOTE_C_LOG_ERROR(jErr);
+            JDelete(rsp);
+            const char *err = ERRSTR("unexpected error received during handshake", c_bad);
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+    }
+
+    // Examine "length" and "max" from the response to evaluate the unencoded
+    // space available to "card.binary.put" on the Notecard.
+    const long len = JGetInt(rsp,"length");
+    const long max = JGetInt(rsp,"max");
+    JDelete(rsp);
+    if (!max) {
+        const char *err = ERRSTR("unexpected response: max is zero or not present", c_err);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Validate the index provided by the caller, against the `length` value
+    // returned from the Notecard to ensure the caller and Notecard agree on
+    // how much data is residing on the Notecard.
+    if ((long)notecardOffset != len) {
+        const char *err = ERRSTR("notecard data length is misaligned with offset", c_mem);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // When offset is zero, the Notecard's entire binary buffer is available
+    const uint32_t remaining = (notecardOffset ? (max - len) : max);
+    if (unencodedLen > remaining) {
+        const char *err = ERRSTR("buffer size exceeds available memory", c_mem);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Calculate MD5
+    char hashString[NOTE_MD5_HASH_STRING_SIZE] = {0};
+    NoteMD5HashString(unencodedData, unencodedLen, hashString, NOTE_MD5_HASH_STRING_SIZE);
+
+    // Shift the data to the end of the buffer. Next, we'll encode the data,
+    // outputting the encoded data to the front of the buffer.
+    const uint32_t dataShift = (bufLen - unencodedLen);
+    memmove(unencodedData + dataShift, unencodedData, unencodedLen);
+
+    // Create an alias to help reason about the buffer after in-place encoding.
+    uint8_t * const encodedData = unencodedData;
+
+    // Update unencoded data pointer
+    unencodedData += dataShift;
+
+    // Capture encoded length
+    // NOTE: `(bufLen - 1)` accounts for one byte of space we need to save for a
+    //       newline to mark the end of the packet.
+    const uint32_t encLen = NoteBinaryCodecEncode(unencodedData, unencodedLen, encodedData, (bufLen - 1));
+
+    // Append the \n, which marks the end of a packet.
+    encodedData[encLen] = '\n';
+
+    const size_t NOTE_C_BINARY_RETRIES = 3;
+    for (size_t i = 0 ; i < NOTE_C_BINARY_RETRIES ; ++i) {
+        // Claim Notecard Mutex
+        _LockNote();
+
+        // Issue a "card.binary.put"
+        J *req = NoteNewRequest("card.binary.put");
+        if (req) {
+            JAddIntToObject(req, "cobs", encLen);
+            if (notecardOffset) {
+                JAddIntToObject(req, "offset", notecardOffset);
+            }
+            JAddStringToObject(req, "status", hashString);
+
+            // We already have the Notecard lock, so call
+            // noteTransactionShouldLock with `lockNotecard` set to false so we
+            // don't try to lock again.
+            rsp = noteTransactionShouldLock(req, false);
+            JDelete(req);
+            // Ensure the transaction doesn't return an error.
+            if (!rsp || NoteResponseError(rsp)) {
+                if (rsp) {
+                    NOTE_C_LOG_ERROR(JGetString(rsp,"err"));
+                    JDelete(rsp);
+                }
+
+                const char *err = ERRSTR("failed to initialize binary transaction", c_err);
+                NOTE_C_LOG_ERROR(err);
+                _UnlockNote();
+                // On errors, we restore the caller's input buffer by decoding
+                // it. The caller is then able to retry transmission with their
+                // original pointer to this buffer.
+                NoteBinaryCodecDecode(encodedData, encLen, encodedData, bufLen);
+                return err;
+            }
+
+            JDelete(rsp);
+        } else {
+            const char *err = ERRSTR("unable to allocate request", c_mem);
+            NOTE_C_LOG_ERROR(err);
+            _UnlockNote();
+            NoteBinaryCodecDecode(encodedData, encLen, encodedData, bufLen);
+            return err;
+        }
+
+        // Immediately send the encoded binary.
+        NOTE_C_LOG_DEBUG("transmitting binary data...");
+        const char *err = _ChunkedTransmit(encodedData, (encLen + 1), false);
+        NOTE_C_LOG_DEBUG("binary transmission complete.");
+
+        // Release Notecard Mutex
+        _UnlockNote();
+
+        // Ensure transaction was successful
+        if (err) {
+            NoteBinaryCodecDecode(encodedData, encLen, encodedData, bufLen);
+            return ERRSTR(err, c_err);
+        }
+
+        // Issue a `"card.binary"` request.
+        rsp = NoteRequestResponse(NoteNewRequest("card.binary"));
+        if (!rsp) {
+            const char *err = ERRSTR("unable to validate request", c_err);
+            NOTE_C_LOG_ERROR(err);
+            NoteBinaryCodecDecode(encodedData, encLen, encodedData, bufLen);
+            return err;
+        }
+
+        // Ensure the transaction doesn't return an error
+        // to confirm the binary was received
+        if (NoteResponseError(rsp)) {
+            const char *jErr = JGetString(rsp, "err");
+            if (NoteErrorContains(jErr, c_badbinerr)) {
+                NOTE_C_LOG_WARN(jErr);
+                JDelete(rsp);
+                if ( i < (NOTE_C_BINARY_RETRIES - 1) ) {
+                    NOTE_C_LOG_WARN("retrying binary transmission...");
+                    continue;
+                }
+                const char *err = ERRSTR("binary data invalid", c_bad);
+                NOTE_C_LOG_ERROR(err);
+                NoteBinaryCodecDecode(encodedData, encLen, encodedData, bufLen);
+                return err;
+            } else {
+                NOTE_C_LOG_ERROR(jErr);
+                JDelete(rsp);
+                const char *err = ERRSTR("unexpected error received during confirmation", c_bad);
+                NOTE_C_LOG_ERROR(err);
+                NoteBinaryCodecDecode(encodedData, encLen, encodedData, bufLen);
+                return err;
+            }
+        }
+        JDelete(rsp);
+        break;
+    }
+
+    // Return `NULL` on success
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine if the card time is "real" calendar/clock time, or if
+  it is simply the millisecond clock since boot.
+  @returns  A boolean indicating whether the current time is valid.
+*/
+/**************************************************************************/
+bool NoteTimeValid(void)
+{
+    timeTimer = 0;
+    return NoteTimeValidST();
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine if if the suppression-timer card time is valid.
+  @returns  A boolean indicating whether the current time is valid.
+*/
+/**************************************************************************/
+bool NoteTimeValidST(void)
+{
+    NoteTimeST();
+    return (timeBaseSec != 0);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the current epoch time, unsuppressed.
+  @returns  The current time.
+*/
+/**************************************************************************/
+JTIME NoteTime(void)
+{
+    timeTimer = 0;
+    return NoteTimeST();
+}
+
+/*!
+  @brief Set the number of minutes between refreshes of the time from the
+         Notecard, to help minimize clock drift on this host. Set this to 0 for
+         no auto-refresh; it defaults to daily.
+
+  @param mins Minutes between time refreshes.
+ */
+void NoteTimeRefreshMins(uint32_t mins)
+{
+    refreshTimerSecs = mins * 60;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the time.
+  @param   seconds The UNIX Epoch time.
+*/
+/**************************************************************************/
+NOTE_C_STATIC void setTime(JTIME seconds)
+{
+    timeBaseSec = seconds;
+    timeBaseSetAtMs = _GetMs();
+}
+
+/*!
+  @brief  Set the time from a source that is NOT the Notecard
+  @param  secondsUTC The UNIX Epoch time, or 0 for automatic Notecard time
+  @param  offset The local time zone offset, in minutes, to adjust UTC
+  @param  zone The optional local time zone name (3 character c-string). Note
+                that this isn't used in any time calculations. To compute
+                accurate local time, only the offset is used. See
+                https://www.iana.org/time-zones for a time zone database.
+  @param   country The optional country
+  @param   area The optional region
+ */
+void NoteTimeSet(JTIME secondsUTC, int offset, char *zone, char *country, char *area)
+{
+    if (secondsUTC == 0) {
+        timeBaseSec = 0;
+        timeBaseSetAtMs = 0;
+        timeBaseSetManually = false;
+        zoneStillUnavailable = true;
+        zoneForceRefresh = false;
+    } else {
+        timeBaseSec = secondsUTC;
+        timeBaseSetAtMs = _GetMs();
+        timeBaseSetManually = true;
+        zoneStillUnavailable = false;
+        curZoneOffsetMins = offset;
+        strlcpy(curZone, zone == NULL ? "UTC" : zone, sizeof(curZone));
+        strlcpy(curArea, area == NULL ? "" : area, sizeof(curArea));
+        strlcpy(curCountry, country == NULL ? "" : country, sizeof(curCountry));
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Print a full, newline-terminated line.
+  @param   line The c-string line to print.
+*/
+/**************************************************************************/
+void NotePrintln(const char *line)
+{
+    NotePrint(line);
+    NotePrint(c_newline);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Log text "raw" to either the active debug console or to the
+  Notecard's USB console.
+  @param   text  A debug string for output.
+*/
+/**************************************************************************/
+bool NotePrint(const char *text)
+{
+    bool success = false;
+
+    if (noteIsDebugOutputActive()) {
+        NoteDebug(text);
+        return true;
+    }
+
+    J *req = NoteNewRequest("card.log");
+    JAddStringToObject(req, "text", text);
+    success = NoteRequest(req);
+
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the current epoch time as known by the module. If it isn't known
+  by the module, just return the time since boot as indicated by the
+  millisecond clock.
+  @returns  The current time, or the time since boot.
+*/
+/**************************************************************************/
+JTIME NoteTimeST(void)
+{
+
+    // Handle timer tick wrap by resetting the base
+    uint32_t nowMs = _GetMs();
+    if (timeBaseSec != 0 && nowMs < timeBaseSetAtMs) {
+        int64_t actualTimeMs = 0x100000000LL + (int64_t) nowMs;
+        int64_t elapsedTimeMs = actualTimeMs - (int64_t) timeBaseSetAtMs;
+        uint32_t elapsedTimeSecs = (uint32_t) (elapsedTimeMs / 1000);
+        timeBaseSec += elapsedTimeSecs;
+        timeBaseSetAtMs = nowMs;
+    }
+
+    // If it's time to refresh the time, do so
+    if (refreshTimerSecs != 0 && timerExpiredSecs(&timeRefreshTimer, refreshTimerSecs)) {
+        timeTimer = 0;
+    }
+
+    // If we haven't yet fetched the time, or if we still need the timezone, do
+    // so with a suppression timer so that we don't hammer the module before
+    // it's had a chance to connect to the network to fetch time.
+    if (!timeBaseSetManually && (timeTimer == 0 || timeBaseSec == 0 || zoneStillUnavailable || zoneForceRefresh)) {
+        if (timerExpiredSecs(&timeTimer, suppressionTimerSecs)) {
+
+            // Request time and zone info from the card
+            J *rsp = NoteRequestResponse(NoteNewRequest("card.time"));
+            if (rsp != NULL) {
+                if (!NoteResponseError(rsp)) {
+                    JTIME seconds = JGetInt(rsp, "time");
+                    if (seconds != 0) {
+
+                        // Set the time
+                        setTime(seconds);
+
+                        // Get the zone
+                        char *z = JGetString(rsp, "zone");
+                        if (z[0] != '\0') {
+                            char zone[64];
+                            strlcpy(zone, z, sizeof(zone));
+                            // Only use the 3-letter abbrev
+                            char *sep = strchr(zone, ',');
+                            if (sep == NULL) {
+                                zone[0] = '\0';
+                            } else {
+                                *sep = '\0';
+                            }
+                            zoneStillUnavailable = (memcmp(zone, "UTC", 3) == 0);
+                            zoneForceRefresh = false;
+                            strlcpy(curZone, zone, sizeof(curZone));
+                            curZoneOffsetMins = JGetInt(rsp, "minutes");
+                            strlcpy(curCountry, JGetString(rsp, "country"), sizeof(curCountry));
+                            strlcpy(curArea, JGetString(rsp, "area"), sizeof(curArea));
+                        }
+
+                    }
+                }
+                NoteDeleteResponse(rsp);
+            }
+        }
+    }
+
+    // Adjust the base time by the number of seconds that have elapsed since
+    // the base.
+    JTIME adjustedTime = timeBaseSec + (int32_t) (((int64_t) nowMs - (int64_t) timeBaseSetAtMs) / 1000);
+
+    // Done
+    return adjustedTime;
+
+}
+
+/*!
+  @brief Set suppression timer secs, returning the previous value.
+
+  @param secs New suppression timer seconds.
+
+  @returns Previous suppression timer seconds
+ */
+uint32_t NoteSetSTSecs(uint32_t secs)
+{
+    uint32_t prev = suppressionTimerSecs;
+    suppressionTimerSecs = secs;
+    return prev;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Return local region info, if known. Returns true if valid.
+  @param   retCountry (out) The country.
+  @param   retArea (out) The area value.
+  @param   retZone (out) The timezone value.
+  @param   retZoneOffset (out) The timezone offset.
+  @returns boolean indicating if the region information is valid.
+*/
+/**************************************************************************/
+bool NoteRegion(char **retCountry, char **retArea, char **retZone, int *retZoneOffset)
+{
+    NoteTimeST();
+    if (zoneStillUnavailable) {
+        if (retCountry != NULL) {
+            *retCountry = (char *) "";
+        }
+        if (retArea != NULL) {
+            *retArea = (char *) "";
+        }
+        if (retZone != NULL) {
+            *retZone = (char *) "UTC";
+        }
+        if (retZoneOffset != NULL) {
+            *retZoneOffset = 0;
+        }
+        return false;
+    }
+    if (retCountry != NULL) {
+        *retCountry = curCountry;
+    }
+    if (retArea != NULL) {
+        *retArea = curArea;
+    }
+    if (retZone != NULL) {
+        *retZone = curZone;
+    }
+    if (retZoneOffset != NULL) {
+        *retZoneOffset = curZoneOffsetMins;
+    }
+    return true;
+}
+
+/*!
+  @brief Return local time info, if known. Returns true if valid.
+
+  @param retYear [out] Pointer to return year value.
+  @param retMonth [out] Pointer to return month value.
+  @param retDay [out] Pointer to return day value.
+  @param retHour [out] Pointer to return hour value.
+  @param retMinute [out] Pointer to return minute value.
+  @param retSecond [out] Pointer to return seconds value.
+  @param retWeekday [out] Pointer to return weekday string.
+  @param retZone [in,out] If NULL, local time will be returned in UTC, else
+         returns pointer to zone string
+
+  @returns True if either the zone or DST have changed since last call, false
+           otherwise.
+
+  @note Only call this if time is valid.
+ */
+bool NoteLocalTimeST(uint16_t *retYear, uint8_t *retMonth, uint8_t *retDay,
+                     uint8_t *retHour, uint8_t *retMinute, uint8_t *retSecond, char **retWeekday,
+                     char **retZone)
+{
+
+    // Preset
+    if (retYear != NULL) {
+        *retYear = 0;
+    }
+    if (retMonth != NULL) {
+        *retMonth = 0;
+    }
+    if (retDay != NULL) {
+        *retDay = 0;
+    }
+    if (retHour != NULL) {
+        *retHour = 0;
+    }
+    if (retMinute != NULL) {
+        *retMinute = 0;
+    }
+    if (retSecond != NULL) {
+        *retSecond = 0;
+    }
+    if (retWeekday != NULL) {
+        *retWeekday = (char *) "";
+    }
+    if (retZone != NULL) {
+        *retZone = (char *) "";
+    }
+
+    // Exit if time isn't yet valid
+    if (!NoteTimeValidST()) {
+        return false;
+    }
+
+    // Get the current time and region, and compute local time
+    char  *currentZone;
+    int currentOffsetMins;
+    JTIME currentEpochTime = NoteTimeST();
+    bool regionAvailable = NoteRegion(NULL, NULL, &currentZone, &currentOffsetMins);
+
+    // Offset the epoch time by time zone offset
+    currentEpochTime += currentOffsetMins * 60;
+
+    // Convert from unix epoch time to local date/time
+    int i, year, mon;
+    int32_t days;
+    uint32_t secs;
+    secs = (uint32_t) currentEpochTime + ((70*365L+17)*86400LU);
+    days = secs / 86400;
+    if (retWeekday != NULL) {
+        *retWeekday = (char *) daynames[(days + 1) % 7];
+    }
+    for (year = days / 365; days < (i = yToDays(year) + 365L * year); ) {
+        --year;
+    }
+    days -= i;
+    if (retYear != NULL) {
+        *retYear = (uint16_t) year+1900;
+    }
+    short *pm = daysByMonth(year);
+    for (mon = 12; days < pm[--mon]; ) ;
+    if (retMonth != NULL) {
+        *retMonth = (uint8_t) mon+1;
+    }
+    if (retDay != NULL) {
+        *retDay = days - pm[mon] + 1;
+    }
+    secs = secs % 86400;
+    uint8_t currentHour = (uint8_t) (secs / 3600);
+    if (retHour != NULL) {
+        *retHour = currentHour;
+    }
+    secs %= 3600;
+    if (retMinute != NULL) {
+        *retMinute = (uint8_t) (secs/60);
+    }
+    if (retSecond != NULL) {
+        *retSecond = (uint8_t) (secs % 60);
+    }
+    if (retZone != NULL) {
+        *retZone = currentZone;
+    }
+
+    // Determine whether or not we should refresh to check whether DST offset has changed, which
+    // is between midnight and 3am local time (if available).
+    static uint8_t lastHour;
+    static bool lastInfoIsKnown = false;
+    if (regionAvailable && lastInfoIsKnown) {
+        if ((lastHour != 1 && currentHour == 1) || (lastHour != 2 && currentHour == 2) || (lastHour != 3 && currentHour == 3)) {
+            zoneForceRefresh = true;
+        }
+    }
+    lastInfoIsKnown = true;
+    lastHour = currentHour;
+
+    // Done
+    return regionAvailable;
+
+}
+
+// Figure out how many days at start of the year
+NOTE_C_STATIC int yToDays(int year)
+{
+    int days = 0;
+    if (0 < year) {
+        days = (year - 1) / 4;
+    } else if (year <= -4) {
+        days = year / 4;
+    }
+    return days + daysByMonth(year)[0];
+}
+
+//**************************************************************************/
+/*!
+  @brief  See if the card location is valid.  If it is OFF, it is
+  treated as valid.
+  @param   errbuf (out) A buffer with any error information to return.
+  @param   errbuflen The length of the error buffer.
+  @returns boolean indicating if the location information is valid.
+*/
+/**************************************************************************/
+bool NoteLocationValid(char *errbuf, uint32_t errbuflen)
+{
+    locationTimer = 0;
+    locationValid = false;
+    locationLastErr[0] = '\0';
+    return NoteLocationValidST(errbuf, errbuflen);
+}
+
+//**************************************************************************/
+/*!
+  @brief  See if the card location is valid, time-suppressed.  If it is OFF,
+  it is treated as valid.
+  @param   errbuf (out) A buffer with any error information to return.
+  @param   errbuflen The length of the error buffer.
+  @returns boolean indicating if the location information is valid.
+*/
+/**************************************************************************/
+bool NoteLocationValidST(char *errbuf, uint32_t errbuflen)
+{
+
+    // Preset
+    if (errbuf != NULL) {
+        strlcpy(errbuf, locationLastErr, errbuflen);
+    }
+
+    // If it was ever valid, return true
+    if (locationValid) {
+        locationLastErr[0] = '\0';
+        if (errbuf != NULL) {
+            *errbuf = '\0';
+        }
+        return true;
+    }
+
+    // If we haven't yet fetched the location, do so with a suppression
+    // timer so that we don't hammer the module before it's had a chance to
+    // connect to the gps to fetch location.
+    if (!timerExpiredSecs(&locationTimer, suppressionTimerSecs)) {
+        return false;
+    }
+
+    // Request location from the card
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.location"));
+    if (rsp == NULL) {
+        return false;
+    }
+
+    // If valid, or the location mode is OFF, we're done
+    if (!NoteResponseError(rsp) || strcmp(JGetString(rsp, "mode"), "off") == 0) {
+        NoteDeleteResponse(rsp);
+        locationValid = true;
+        locationLastErr[0] = '\0';
+        if (errbuf != NULL) {
+            *errbuf = '\0';
+        }
+        return true;
+    }
+
+    // Remember the error for next iteration
+    strlcpy(locationLastErr, JGetString(rsp, "err"), sizeof(locationLastErr));
+    if (errbuf != NULL) {
+        strlcpy(errbuf, locationLastErr, errbuflen);
+    }
+    NoteDeleteResponse(rsp);
+    return false;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set a service environment variable default string.
+  @param   variable The variable key.
+  @param   buf The variable value.
+  @returns boolean indicating if variable was set.
+*/
+/**************************************************************************/
+bool NoteSetEnvDefault(const char *variable, char *buf)
+{
+    bool success = false;
+    J *req = NoteNewRequest("env.default");
+    if (req != NULL) {
+        JAddStringToObject(req, "name", variable);
+        JAddStringToObject(req, "text", buf);
+        success = NoteRequest(req);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set a service environment variable default integer.
+  @param   variable The variable key.
+  @param   defaultVal The variable value.
+  @returns boolean indicating if variable was set.
+*/
+/**************************************************************************/
+bool NoteSetEnvDefaultInt(const char *variable, JINTEGER defaultVal)
+{
+    char buf[32];
+    JItoA(defaultVal, buf);
+    return NoteSetEnvDefault(variable, buf);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set a service environment variable default number.
+  @param   variable The variable key.
+  @param   defaultVal The variable value.
+  @returns boolean indicating if variable was set.
+*/
+/**************************************************************************/
+bool NoteSetEnvDefaultNumber(const char *variable, JNUMBER defaultVal)
+{
+    char buf[JNTOA_MAX];
+    JNtoA(defaultVal, buf, -1);
+    return NoteSetEnvDefault(variable, buf);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get a service environment variable number.
+  @param   variable The variable key.
+  @param   defaultVal The default variable value.
+  @returns environment variable value.
+*/
+/**************************************************************************/
+JNUMBER NoteGetEnvNumber(const char *variable, JNUMBER defaultVal)
+{
+    char buf[JNTOA_MAX], buf2[JNTOA_MAX];
+    JNtoA(defaultVal, buf2, -1);
+    NoteGetEnv(variable, buf2, buf, sizeof(buf));
+    return JAtoN((const char*)buf, NULL);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get a service environment variable integer.
+  @param   variable The variable key.
+  @param   defaultVal The default variable value.
+  @returns environment variable value.
+*/
+/**************************************************************************/
+JINTEGER NoteGetEnvInt(const char *variable, JINTEGER defaultVal)
+{
+    char buf[32], buf2[32];
+    JItoA(defaultVal, buf2);
+    NoteGetEnv(variable, buf2, buf, sizeof(buf));
+    return atoi(buf);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get a service environment variable.
+  @param   variable The variable key.
+  @param   defaultVal The default variable value, if the environment variable
+           hasn't been set.
+  @param   buf (out) The buffer in which to place the variable value. If the
+           environment variable hasn't been set, defaultVal will be copied into
+           buf.
+  @param   buflen The length of the output buffer.
+  @returns true if there is no error (JSON response with no explicit error)
+*/
+/**************************************************************************/
+bool NoteGetEnv(const char *variable, const char *defaultVal, char *buf, uint32_t buflen)
+{
+    bool success = false;
+    if (defaultVal == NULL) {
+        buf[0] = '\0';
+    } else {
+        strlcpy(buf, defaultVal, buflen);
+    }
+    J *req = NoteNewRequest("env.get");
+    if (req != NULL) {
+        JAddStringToObject(req, "name", variable);
+        J *rsp = NoteRequestResponse(req);
+        if (rsp != NULL) {
+            if (!NoteResponseError(rsp)) {
+                success = true;
+                char *val = JGetString(rsp, "text");
+                if (val[0] != '\0') {
+                    strlcpy(buf, val, buflen);
+                }
+            }
+            NoteDeleteResponse(rsp);
+        }
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine if the Notecard is connected to the network.
+  @returns boolean. `true` if connected.
+*/
+/**************************************************************************/
+bool NoteIsConnected(void)
+{
+    connectivityTimer = 0;
+    return NoteIsConnectedST();
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine if the Notecard is connected to the network.
+  @returns boolean. `true` if connected.
+*/
+/**************************************************************************/
+bool NoteIsConnectedST(void)
+{
+    if (timerExpiredSecs(&connectivityTimer, suppressionTimerSecs)) {
+        J *rsp = NoteRequestResponse(NoteNewRequest("hub.status"));
+        if (rsp != NULL) {
+            if (!NoteResponseError(rsp)) {
+                cardConnected = JGetBool(rsp, "connected");
+            }
+            NoteDeleteResponse(rsp);
+        }
+    }
+    return cardConnected;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get Full Network Status via `hub.status`.
+  @param  statusBuf (out) a buffer to populate with the status response.
+  @param  statusBufLen The length of the status buffer
+  @returns boolean. `true` if the status was retrieved.
+*/
+/**************************************************************************/
+bool NoteGetNetStatus(char *statusBuf, int statusBufLen)
+{
+    bool success = false;
+    statusBuf[0] = '\0';
+    J *rsp = NoteRequestResponse(NoteNewRequest("hub.status"));
+    if (rsp != NULL) {
+        success = !NoteResponseError(rsp);
+        if (success) {
+            strlcpy(statusBuf, JGetString(rsp, "status"), statusBufLen);
+        }
+        NoteDeleteResponse(rsp);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Make a `card.version` request
+  @param  versionBuf (out) a buffer to populate with the version response.
+  @param  versionBufLen The length of the version buffer
+  @returns boolean. `true` if the version information was retrieved.
+*/
+/**************************************************************************/
+bool NoteGetVersion(char *versionBuf, int versionBufLen)
+{
+    bool success = false;
+    versionBuf[0] = '\0';
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.version"));
+    if (rsp != NULL) {
+        success = !NoteResponseError(rsp);
+        if (success) {
+            strlcpy(versionBuf, JGetString(rsp, "version"), versionBufLen);
+        }
+        NoteDeleteResponse(rsp);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Make a `card.location` request
+  @param  retLat (out) The retrieved latitude value.
+  @param  retLon (out) The retrieved longitude value.
+  @param  time (out) The retrieved time.
+  @param  statusBuf (out) a buffer to populate with the location response.
+  @param  statusBufLen The length of the location buffer
+  @returns boolean. `true` if the location information was retrieved.
+*/
+/**************************************************************************/
+bool NoteGetLocation(JNUMBER *retLat, JNUMBER *retLon, JTIME *time, char *statusBuf, int statusBufLen)
+{
+    bool locValid = false;
+    if (statusBuf != NULL) {
+        *statusBuf = '\0';
+    }
+    if (retLat != NULL) {
+        *retLat = 0.0;
+    }
+    if (retLon != NULL) {
+        *retLon = 0.0;
+    }
+    if (time != NULL) {
+        *time = 0;
+    }
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.location"));
+    if (rsp != NULL) {
+        if (statusBuf != NULL) {
+            strlcpy(statusBuf, JGetString(rsp, "status"), statusBufLen);
+        }
+        if (JIsPresent(rsp, "lat") && JIsPresent(rsp, "lon")) {
+            if (retLat != NULL) {
+                *retLat = JGetNumber(rsp, "lat");
+            }
+            if (retLon != NULL) {
+                *retLon = JGetNumber(rsp, "lon");
+            }
+            locValid = true;
+        }
+        JTIME seconds = JGetInt(rsp, "time");
+        if (seconds != 0 && time != NULL) {
+            *time = seconds;
+        }
+        NoteDeleteResponse(rsp);
+    }
+    return locValid;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the card location to a static value.
+  @param  lat The latitude value to set on the Notecard.
+  @param  lon The longitude value to set on the Notecard.
+  @returns boolean. `true` if the location information was set.
+*/
+/**************************************************************************/
+bool NoteSetLocation(JNUMBER lat, JNUMBER lon)
+{
+    bool success = false;
+    J *req = NoteNewRequest("card.location.mode");
+    if (req != NULL) {
+        JAddStringToObject(req, "mode", "fixed");
+        JAddNumberToObject(req, "lat", lat);
+        JAddNumberToObject(req, "lon", lon);
+        success = NoteRequest(req);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Clear last known Location.
+  @returns boolean. `true` if the location information was cleared.
+*/
+/**************************************************************************/
+bool NoteClearLocation(void)
+{
+    bool success = false;
+    J *req = NoteNewRequest("card.location.mode");
+    if (req != NULL) {
+        JAddBoolToObject(req, "delete", true);
+        success = NoteRequest(req);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the current location Mode.
+  @param  modeBuf (out) a buffer to populate with the location mode response.
+  @param  modeBufLen The length of the mode buffer
+  @returns boolean. `true` if the mode information was retrieved.
+*/
+/**************************************************************************/
+bool NoteGetLocationMode(char *modeBuf, int modeBufLen)
+{
+    bool success = false;
+    modeBuf[0] = '\0';
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.location.mode"));
+    if (rsp != NULL) {
+        success = !NoteResponseError(rsp);
+        if (success) {
+            strlcpy(modeBuf, JGetString(rsp, "mode"), modeBufLen);
+        }
+        NoteDeleteResponse(rsp);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Make a `card.location.mode` request.
+  @param  mode the Notecard location mode to set.
+  @param  seconds The value of the `seconds` field for the request.
+  @returns boolean. `true` if the mode was set.
+*/
+/**************************************************************************/
+bool NoteSetLocationMode(const char *mode, uint32_t seconds)
+{
+    bool success = false;
+    J *req = NoteNewRequest("card.location.mode");
+    if (req != NULL) {
+        if (mode[0] == '\0') {
+            mode = "-";
+        }
+        JAddStringToObject(req, "mode", mode);
+        JAddNumberToObject(req, "seconds", seconds);
+        success = NoteRequest(req);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the current service configuration information, unsuppressed.
+  @param  productBuf (out) a buffer to populate with the ProductUID from the
+  response.
+  @param  productBufLen The length of the ProductUID buffer.
+  @param  serviceBuf (out) a buffer to populate with the host url from the
+  response.
+  @param  serviceBufLen The length of the host buffer.
+  @param  deviceBuf (out) a buffer to populate with the DeviceUID from the
+  response.
+  @param  deviceBufLen The length of the DeviceUID buffer.
+  @param  snBuf (out) a buffer to populate with the Product Serial Number
+  from the response.
+  @param  snBufLen The length of the Serial Number buffer.
+  @returns boolean. `true` if the service configuration was obtained.
+*/
+/**************************************************************************/
+bool NoteGetServiceConfig(char *productBuf, int productBufLen, char *serviceBuf, int serviceBufLen, char *deviceBuf, int deviceBufLen, char *snBuf, int snBufLen)
+{
+    serviceConfigTimer = 0;
+    return NoteGetServiceConfigST(productBuf, productBufLen, serviceBuf, serviceBufLen, deviceBuf, deviceBufLen, snBuf, snBufLen);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the current service configuration information, with
+  a supression timer.
+  @param  productBuf (out) a buffer to populate with the ProductUID from the
+  response.
+  @param  productBufLen The length of the ProductUID buffer.
+  @param  serviceBuf (out) a buffer to populate with the host url from the
+  response.
+  @param  serviceBufLen The length of the host buffer.
+  @param  deviceBuf (out) a buffer to populate with the DeviceUID from the
+  response.
+  @param  deviceBufLen The length of the DeviceUID buffer.
+  @param  snBuf (out) a buffer to populate with the Product Serial Number
+  from the response.
+  @param  snBufLen The length of the Serial Number buffer.
+  @returns boolean. `true` if the service configuration was obtained.
+*/
+/**************************************************************************/
+bool NoteGetServiceConfigST(char *productBuf, int productBufLen, char *serviceBuf, int serviceBufLen, char *deviceBuf, int deviceBufLen, char *snBuf, int snBufLen)
+{
+    bool success = false;
+
+    // Use cache except for a rare refresh
+    if (scProduct[0] == '\0' || scDevice[0] == '\0' || timerExpiredSecs(&serviceConfigTimer, 4*60*60)) {
+        J *rsp = NoteRequestResponse(NoteNewRequest("hub.get"));
+        if (rsp != NULL) {
+            success = !NoteResponseError(rsp);
+            if (success) {
+                strlcpy(scProduct, JGetString(rsp, "product"), sizeof(scProduct));
+                strlcpy(scService, JGetString(rsp, "host"), sizeof(scService));
+                strlcpy(scDevice, JGetString(rsp, "device"), sizeof(scDevice));
+                strlcpy(scSN, JGetString(rsp, "sn"), sizeof(scSN));
+            }
+            NoteDeleteResponse(rsp);
+        }
+    } else {
+        success = true;
+    }
+
+    // Done
+    if (productBuf != NULL) {
+        strlcpy(productBuf, scProduct, productBufLen);
+    }
+    if (serviceBuf != NULL) {
+        strlcpy(serviceBuf, scService, serviceBufLen);
+    }
+    if (deviceBuf != NULL) {
+        strlcpy(deviceBuf, scDevice, deviceBufLen);
+    }
+    if (snBuf != NULL) {
+        strlcpy(snBuf, scSN, snBufLen);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get Status of the Notecard, unsuppressed.
+  @param  statusBuf (out) a buffer to populate with the Notecard status
+  from the response.
+  @param  statusBufLen The length of the status buffer.
+  @param  bootTime (out) The Notecard boot time.
+  @param  retUSB (out) Whether the Notecard is powered over USB.
+  @param  retSignals (out) Whether the Notecard has a network signal.
+  @returns boolean. `true` if the card status was obtained.
+*/
+/**************************************************************************/
+bool NoteGetStatus(char *statusBuf, int statusBufLen, JTIME *bootTime, bool *retUSB, bool *retSignals)
+{
+    statusTimer = 0;
+    return NoteGetStatusST(statusBuf, statusBufLen, bootTime, retUSB, retSignals);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get Status of the Notecard, with a suppression timer.
+  @param  statusBuf (out) a buffer to populate with the Notecard status
+  from the response.
+  @param  statusBufLen The length of the status buffer.
+  @param  bootTime (out) The Notecard boot time.
+  @param  retUSB (out) Whether the Notecard is powered over USB.
+  @param  retSignals (out) Whether the Notecard has a network signal.
+  @returns boolean. `true` if the card status was obtained.
+*/
+/**************************************************************************/
+bool NoteGetStatusST(char *statusBuf, int statusBufLen, JTIME *bootTime, bool *retUSB, bool *retSignals)
+{
+    bool success = false;
+    static char lastStatus[128] = {0};
+    static JTIME lastBootTime = 0;
+    static bool lastUSB = false;
+    static bool lastSignals = false;
+
+    // Refresh if it's time to do so
+    if (timerExpiredSecs(&statusTimer, suppressionTimerSecs)) {
+        J *rsp = NoteRequestResponse(NoteNewRequest("card.status"));
+        if (rsp != NULL) {
+            success = !NoteResponseError(rsp);
+            if (success) {
+                strlcpy(lastStatus, JGetString(rsp, "status"), sizeof(lastStatus));
+                lastBootTime = JGetInt(rsp, "time");
+                lastUSB = JGetBool(rsp, "usb");
+                if (JGetBool(rsp, "connected")) {
+                    lastSignals = (JGetInt(rsp, "signals") > 0);
+                } else {
+                    lastSignals = false;
+                }
+            }
+            NoteDeleteResponse(rsp);
+        }
+    } else {
+        success = true;
+    }
+
+    // Done
+    if (statusBuf != NULL) {
+        strlcpy(statusBuf, lastStatus, statusBufLen);
+    }
+    if (bootTime != NULL) {
+        *bootTime = lastBootTime;
+    }
+    if (retUSB != NULL) {
+        *retUSB = lastUSB;
+    }
+    if (retSignals != NULL) {
+        *retSignals = lastSignals;
+    }
+
+    return success;
+}
+
+/*!
+  @brief Save the current state and use `card.attn` to set a host
+         sleep interval.
+
+  @param desc An optional binary payload to keep in memory while the host
+         sleeps.
+  @param seconds The duration to sleep.
+  @param modes Optional list of additional `card.attn` modes.
+
+  @returns `true` if the cmd is sent without error. The Notecard does not reply
+            to commands so a `true` return value does not guarantee
+            that the sleep request was received and processed by the Notecard.
+*/
+bool NotePayloadSaveAndSleep(NotePayloadDesc *desc, uint32_t seconds, const char *modes)
+{
+    char *stateB64 = NULL;
+
+    // If specified, encode
+    if (desc->data != NULL && desc->length != 0) {
+
+        // Get length that it will be when converted to base64
+        unsigned b64Len = JB64EncodeLen(desc->length);
+
+        // Convert the state to base64
+        stateB64 = _Malloc(b64Len);
+        if (stateB64 == NULL) {
+            return false;
+        }
+
+        // Encode the state buffer into a string
+        JB64Encode(stateB64, (const char *) desc->data, desc->length);
+
+    }
+
+    // Sleep
+    bool success = NoteSleep(stateB64, seconds, modes);
+
+    // Free the temp buffer
+    if (stateB64 != NULL) {
+        _Free(stateB64);
+    }
+
+    // Done
+    return success;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Save the current state and use `card.attn` to set a host
+  sleep interval.
+  @param  stateb64 A base64 payload to keep in memory while the host sleeps.
+  @param  seconds The duration to sleep.
+  @param  modes Optional list of additional `card.attn` modes.
+  @returns boolean. `true` if the cmd is sent without error. The Notecard
+           does not reply to `cmd` so a `true` return value does not guarantee
+           that the sleep request was received and processed by the Notecard.
+*/
+/**************************************************************************/
+bool NoteSleep(char *stateb64, uint32_t seconds, const char *modes)
+{
+    bool success = false;
+
+    // Trace
+    NOTE_C_LOG_INFO("ABOUT TO SLEEP\n");
+
+    // Use a Command rather than a Request so that the Notecard doesn't try to
+    // send a response back to us (host), which would cause a communications
+    // error on the Notecard end.
+    NOTE_C_LOG_INFO("requesting sleep\n");
+    J *req = NoteNewCommand("card.attn");
+    if (req != NULL) {
+        // Add the base64 item in a wonderful way that doesn't strdup the
+        // huge string
+        if (stateb64 != NULL) {
+            J *stringReferenceItem = JCreateStringReference(stateb64);
+            if (stringReferenceItem != NULL) {
+                JAddItemToObject(req, "payload", stringReferenceItem);
+            }
+        }
+        char modestr[64];
+        strlcpy(modestr, "sleep", sizeof(modestr));
+        if (modes != NULL) {
+            strlcat(modestr, ",", sizeof(modestr));
+            strlcat(modestr, modes, sizeof(modestr));
+        }
+        JAddStringToObject(req, "mode", modestr);
+        JAddNumberToObject(req, "seconds", seconds);
+
+        // Note that since we use cmd and not req a true return value from
+        // NoteRequest means only that the cmd was sent without error.
+        success = NoteRequest(req);
+    }
+
+    // Trace
+    NOTE_C_LOG_ERROR("DIDN'T SLEEP\n");
+
+    // Done
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Wake the module by restoring state into a state buffer of a
+  specified length, and fail if it isn't available or isn't that length.
+  @param  stateLen A length of the state payload buffer to return to the host.
+  @param  state (out) The in-memory payload to return to the host.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteWake(int stateLen, void *state)
+{
+    NotePayloadDesc desc;
+    bool success = NotePayloadRetrieveAfterSleep(&desc);
+    if (!success) {
+        return false;
+    }
+    if (desc.length != (uint32_t)stateLen) {
+        NotePayloadFree(&desc);
+        return false;
+    }
+    memcpy(state, desc.data, stateLen);
+    NotePayloadFree(&desc);
+    return true;
+}
+
+/*!
+  @brief  Wake the module by restoring state into a state buffer, returning
+          its length, and fail if it isn't available.
+
+  @param  desc [out] Payload descriptor to hold the retrieved.
+          payload.
+
+  @returns True if the request was successful, false otherwise.
+ */
+bool NotePayloadRetrieveAfterSleep(NotePayloadDesc *desc)
+{
+
+    // Initialize payload descriptor
+    if (desc != NULL) {
+        memset(desc, 0, sizeof(NotePayloadDesc));
+    }
+
+    // Send the Notecard a request to retrieve the saved state
+    J *req = NoteNewRequest("card.attn");
+    if (req == NULL) {
+        return false;
+    }
+    JAddBoolToObject(req, "start", true);
+    J *rsp = NoteRequestResponse(req);
+    if (rsp == NULL) {
+        return false;
+    }
+    if (NoteResponseError(rsp)) {
+        NoteDeleteResponse(rsp);
+        return false;
+    }
+
+    // Note the current time, if the field is present
+    JTIME seconds = JGetInt(rsp, "time");
+    if (seconds != 0) {
+        setTime(seconds);
+    }
+
+    // If we didn't expect any state to be restored, we're done
+    if (desc == NULL) {
+        NoteDeleteResponse(rsp);
+        return true;
+    }
+
+    // Exit if no payload, knowing that we expected one
+    char *payload = JGetString(rsp, "payload");
+    if (payload[0] == '\0') {
+        NoteDeleteResponse(rsp);
+        return false;
+    }
+
+    // Allocate a buffer for the payload. (We can't decode in place because we
+    // can't risk overwriting memory if the actual payload is even slightly
+    // different.)
+    uint32_t allocLen = JB64DecodeLen(payload);
+    uint8_t *p = (uint8_t *) _Malloc(allocLen);
+    if (p == NULL) {
+        NoteDeleteResponse(rsp);
+        return false;
+    }
+    uint32_t actualLen = (uint32_t) JB64Decode((char *)p, payload);
+
+    // Fill out the payload descriptor
+    desc->data = p;
+    desc->alloc = allocLen;
+    desc->length = actualLen;
+
+    // State restored
+    NOTE_C_LOG_INFO("AWAKENED SUCCESSFULLY\n");
+    NoteDeleteResponse(rsp);
+    return true;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Restore the module to factory settings.
+  @param  deleteConfigSettings Whether to delete current configuration
+  settings on the Notecard during the reset.
+  @returns boolean. `true` if reset was successful.
+*/
+/**************************************************************************/
+bool NoteFactoryReset(bool deleteConfigSettings)
+{
+    bool success = false;
+
+    // Perform the restore-to-factor-settings transaction
+    J *req = NoteNewRequest("card.restore");
+    if (req != NULL) {
+        JAddBoolToObject(req, "delete", deleteConfigSettings);
+        success = NoteRequest(req);
+    }
+
+    // Exit if it didn't work
+    if (!success) {
+        return false;
+    }
+
+    // Wait for serial to stabilize after it reboots
+    _DelayMs(5000);
+    NOTE_C_LOG_INFO("CARD RESTORED\n");
+
+    // Reset the Notecard
+    while (!NoteReset()) {
+        _DelayMs(5000);
+    }
+
+    // Success
+    return true;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the Notecard Product UID.
+  @param  productID The ProductUID to set on the Notecard.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteSetProductID(const char *productID)
+{
+    bool success = false;
+    J *req = NoteNewRequest("hub.set");
+    if (req != NULL) {
+        if (productID[0] == '\0') {
+            JAddStringToObject(req, "product", "-");
+        } else {
+            JAddStringToObject(req, "product", productID);
+        }
+        success = NoteRequest(req);
+    }
+    // Flush cache so that service config is re-fetched
+    serviceConfigTimer = 0;
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the Notecard Serial Number.
+  @param  sn The Serial Number to set on the Notecard.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteSetSerialNumber(const char *sn)
+{
+    bool success = false;
+    J *req = NoteNewRequest("hub.set");
+    if (req != NULL) {
+        if (sn[0] == '\0') {
+            JAddStringToObject(req, "sn", "-");
+        } else {
+            JAddStringToObject(req, "sn", sn);
+        }
+        success = NoteRequest(req);
+    }
+    // Flush cache so that service config is re-fetched
+    serviceConfigTimer = 0;
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the Notecard upload mode and interval.
+  @param   uploadMode The upload mode (for instance, `continuous`,
+  or `periodic`).
+  @param   uploadMinutes The max number of minutes to wait between Notehub
+  uploads.
+  @param   align Flag to specify that uploads should be grouped within the
+  specified period, rather than counting the number of minutes
+  from first modified.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteSetUploadMode(const char *uploadMode, int uploadMinutes, bool align)
+{
+    bool success = false;
+    J *req = NoteNewRequest("hub.set");
+    if (req != NULL) {
+        JAddStringToObject(req, "mode", uploadMode);
+        if (uploadMinutes != 0) {
+            JAddNumberToObject(req, "outbound", uploadMinutes);
+            // Setting this flag aligns uploads to be grouped within the period,
+            // rather than counting the number of minutes from "first modified".
+            JAddBoolToObject(req, "align", align);
+        }
+        success = NoteRequest(req);
+    }
+    return success;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the Notecard upload mode, download mode and interval.
+  @param   uploadMode The upload mode (for instance, `continuous`,
+  or `periodic`).
+  @param   uploadMinutes The max number of minutes to wait between Notehub
+  uploads.
+  @param   downloadMinutes The max number of minutes to wait between Notehub
+  downloads.
+  @param   align Flag to specify that uploads should be grouped within the
+  specified period, rather than counting the number of minutes
+  from first modified.
+  @param   sync Setting this flag when mode is `continuous` causes an
+  immediate sync when a file is modified on the service side.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteSetSyncMode(const char *uploadMode, int uploadMinutes, int downloadMinutes, bool align, bool sync)
+{
+    bool success = false;
+    J *req = NoteNewRequest("hub.set");
+    if (req != NULL) {
+        JAddStringToObject(req, "mode", uploadMode);
+        if (uploadMinutes != 0) {
+            JAddNumberToObject(req, "outbound", uploadMinutes);
+            // Setting this flag aligns uploads to be grouped within the period,
+            // rather than counting the number of minutes from "first modified".
+            JAddBoolToObject(req, "align", align);
+        }
+        if (downloadMinutes != 0) {
+            JAddNumberToObject(req, "inbound", downloadMinutes);
+        }
+        // Setting this flag when mode is "continuous" causes an immediate sync
+        // when a file is modified on the service side via HTTP
+        JAddBoolToObject(req, "sync", sync);
+        success = NoteRequest(req);
+    }
+    return success;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set a template for a Notefile.
+  @param   target The Notefile on which to set a template.
+  @param   body The template body.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteTemplate(const char *target, J *body)
+{
+    J *req = NoteNewRequest("note.template");
+    if (req == NULL) {
+        JDelete(body);
+        return false;
+    }
+    JAddStringToObject(req, "file", target);
+    JAddItemToObject(req, "body", body);
+    return NoteRequest(req);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Add a Note to a Notefile with `note.add`. Body is freed, regardless
+          of success.
+  @param   target The Notefile on which to set a template.
+  @param   body The template body.
+  @param   urgent Whether to perform an immediate sync after the Note
+  is added.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteAdd(const char *target, J *body, bool urgent)
+{
+
+    // Initiate the request
+    J *req = NoteNewRequest("note.add");
+    if (req == NULL) {
+        JDelete(body);
+        return false;
+    }
+
+    // Add the target notefile and body to the request.  Note that
+    // JAddItemToObject passes ownership of the object to req
+    JAddStringToObject(req, "file", target);
+    JAddItemToObject(req, "body", body);
+
+    // Initiate sync NOW if it's urgent
+    if (urgent) {
+        JAddBoolToObject(req, "start", true);
+    }
+
+    // Perform the transaction
+    return NoteRequest(req);
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Send a body to a route using an HTTP request.
+  Body is freed, regardless of success.
+  @param   method HTTP method to use, `get`, `post` or `put`.
+  @param   routeAlias The Notehub Route alias.
+  @param   notefile The Notefile name.
+  @param   body The request JSON body.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteSendToRoute(const char *method, const char *routeAlias, char *notefile, J *body)
+{
+
+    // Create the new event
+    J *req = NoteNewRequest("note.event");
+    if (req == NULL) {
+        JDelete(body);
+        return false;
+    }
+
+    // Add the body item and the Notefile name
+    JAddItemToObject(req, "body", body);
+    JAddStringToObject(req, "file", notefile);
+
+    // Perform the transaction to convert it to an event
+    J *rsp = NoteRequestResponse(req);
+    if (rsp == NULL) {
+        return false;
+    }
+
+    // Exit if error
+    if (NoteResponseError(rsp)) {
+        NoteDeleteResponse(rsp);
+        return false;
+    }
+
+    // Extract the event, which we'll use as the body for the next transaction
+    body = JDetachItemFromObject(rsp, "body");
+    NoteDeleteResponse(rsp);
+
+    // Create the web transaction
+    char request[32];
+    strlcpy(request, "web.", sizeof(request));
+    strlcat(request, method, sizeof(request));
+    req = NoteNewRequest(request);
+    if (req == NULL) {
+        JDelete(body);
+        return false;
+    }
+
+    // Add the body, and the alias of the route on the notehub, hard-wired here
+    JAddItemToObject(req, "body", body);
+    JAddStringToObject(req, "route", routeAlias);
+
+    // Perform the transaction
+    return NoteRequest(req);
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the voltage of the Notecard.
+  @param   voltage (out) The Notecard voltage.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteGetVoltage(JNUMBER *voltage)
+{
+    bool success = false;
+    *voltage = 0.0;
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.voltage"));
+    if (rsp != NULL) {
+        if (!NoteResponseError(rsp)) {
+            *voltage = JGetNumber(rsp, "value");
+            success = true;
+        }
+        NoteDeleteResponse(rsp);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the temperature of the Notecard.
+  @param   temp (out) The Notecard temperature.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteGetTemperature(JNUMBER *temp)
+{
+    bool success = false;
+    *temp = 0.0;
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.temp"));
+    if (rsp != NULL) {
+        if (!NoteResponseError(rsp)) {
+            *temp = JGetNumber(rsp, "value");
+            success = true;
+        }
+        NoteDeleteResponse(rsp);
+    }
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the Notecard contact info.
+  @param   nameBuf (out) The contact name buffer.
+  @param   nameBufLen The length of the contact name buffer.
+  @param   orgBuf (out) The contact organization buffer.
+  @param   orgBufLen The length of the contact organization buffer.
+  @param   roleBuf (out) The contact role buffer.
+  @param   roleBufLen The length of the contact role buffer.
+  @param   emailBuf (out) The contact email buffer.
+  @param   emailBufLen The length of the contact email buffer.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteGetContact(char *nameBuf, int nameBufLen, char *orgBuf, int orgBufLen, char *roleBuf, int roleBufLen, char *emailBuf, int emailBufLen)
+{
+    bool success = false;
+
+    if (nameBuf != NULL) {
+        *nameBuf = '\0';
+    }
+    if (orgBuf != NULL) {
+        *orgBuf = '\0';
+    }
+    if (roleBuf != NULL) {
+        *roleBuf = '\0';
+    }
+    if (emailBuf != NULL) {
+        *emailBuf = '\0';
+    }
+
+    J *rsp = NoteRequestResponse(NoteNewRequest("card.contact"));
+    if (rsp != NULL) {
+        success = !NoteResponseError(rsp);
+        if (success) {
+            if (nameBuf != NULL) {
+                strlcpy(nameBuf, JGetString(rsp, "name"), nameBufLen);
+            }
+            if (orgBuf != NULL) {
+                strlcpy(orgBuf, JGetString(rsp, "org"), orgBufLen);
+            }
+            if (roleBuf != NULL) {
+                strlcpy(roleBuf, JGetString(rsp, "role"), roleBufLen);
+            }
+            if (emailBuf != NULL) {
+                strlcpy(emailBuf, JGetString(rsp, "email"), emailBufLen);
+            }
+        }
+        NoteDeleteResponse(rsp);
+    }
+
+    return success;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the Notecard contact info.
+  @param   nameBuf (in) The contact name buffer.
+  @param   orgBuf (in) The contact organization buffer.
+  @param   roleBuf (in) The contact role buffer.
+  @param   emailBuf (in) The contact email buffer.
+  @returns boolean. `true` if request was successful.
+*/
+/**************************************************************************/
+bool NoteSetContact(char *nameBuf, char *orgBuf, char *roleBuf, char *emailBuf)
+{
+    J *req = NoteNewRequest("card.contact");
+    if (req == NULL) {
+        return false;
+    }
+    if (nameBuf != NULL) {
+        JAddStringToObject(req, "name", nameBuf);
+    }
+    if (orgBuf != NULL) {
+        JAddStringToObject(req, "org", orgBuf);
+    }
+    if (roleBuf != NULL) {
+        JAddStringToObject(req, "role", roleBuf);
+    }
+    if (emailBuf != NULL) {
+        JAddStringToObject(req, "email", emailBuf);
+    }
+    return NoteRequest(req);
+}
+
+// A simple suppression timer based on a millisecond system clock. This clock is
+// reset to 0 after boot and every wake. This returns true if the specified
+// interval has elapsed, in seconds, and it updates the timer if it expires so
+// that we will go another period.
+NOTE_C_STATIC bool timerExpiredSecs(uint32_t *timer, uint32_t periodSecs)
+{
+    bool expired = false;
+
+    // If the timer went backward, we've expired regardless of the interval
+    uint32_t prev = *timer;
+    uint32_t now = _GetMs();
+    if (now < prev) {
+        prev = 0;
+    }
+
+    // If never initialized, it's expired
+    if (prev == 0 || now >= prev+(periodSecs*1000)) {
+        expired = true;
+        *timer = now;
+    }
+
+    return expired;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Periodically show Notecard sync status, returning `true` if
+  something was displayed
+  @param   pollFrequencyMs The time to wait, in milliseconds, between
+  polling for sync status.
+  @param   maxLevel The Synclog level to monitor.
+  @returns boolean. `true` if a sync status message was displayed.
+*/
+/**************************************************************************/
+bool NoteDebugSyncStatus(int pollFrequencyMs, int maxLevel)
+{
+
+    // Suppress polls so as to not overwhelm the notecard
+    static uint32_t lastCommStatusPollMs = 0;
+    if (lastCommStatusPollMs != 0 && (_GetMs() - lastCommStatusPollMs) < (uint32_t) pollFrequencyMs) {
+        return false;
+    }
+
+    // Get the next queued status note
+    J *req = NoteNewRequest("note.get");
+    if (req == NULL) {
+        return false;
+    }
+    JAddStringToObject(req, "file", "_synclog.qi");
+    JAddBoolToObject(req, "delete", true);
+    NoteSuspendTransactionDebug();
+    J *rsp = NoteRequestResponse(req);
+    NoteResumeTransactionDebug();
+    if (rsp != NULL) {
+
+        // If an error is returned, this means that no response is pending. Note
+        // that it's expected that this might return either a "note does not
+        // exist" error if there are no pending inbound notes, or a "file does
+        // not exist" error if the inbound queue hasn't yet been created on the
+        // service.
+        if (NoteResponseError(rsp)) {
+            // Only stop polling quickly if we don't receive anything
+            lastCommStatusPollMs = _GetMs();
+            NoteDeleteResponse(rsp);
+            return false;
+        }
+
+        // Get the note's body
+        J *body = JGetObject(rsp, "body");
+        if (body != NULL) {
+            if (maxLevel < 0 || JGetInt(body, "level") <= maxLevel) {
+                _Debug("[SYNC] ");
+                _Debug(JGetString(body, "subsystem"));
+                _Debug(" ");
+                _Debugln(JGetString(body, "text"));
+            }
+        }
+
+        // Done with this response
+        NoteDeleteResponse(rsp);
+        return true;
+    }
+
+    return false;
+
+}
+
+// A general purpose, super nonperformant, but accurate way of figuring out how
+// much memory is available, while exercising the allocator to ensure that it
+// competently deals with adjacent block coalescing on free.
+typedef struct objHeader_s {
+    struct objHeader_s *prev;
+    int length;
+} objHeader;
+
+//**************************************************************************/
+/*!
+  @brief  Obtain the amount of free memory available on the Notecard.
+  @returns The number of bytes of memory available on the Notecard.
+*/
+/**************************************************************************/
+uint32_t NoteMemAvailable(void)
+{
+
+    // Allocate progressively smaller and smaller chunks
+    objHeader *lastObj = NULL;
+    static long int maxsize = 35000;
+    for (long int i=maxsize; i>=(long int)sizeof(objHeader); i=i-sizeof(objHeader)) {
+        for (long int j=0;; j++) {
+            objHeader *thisObj;
+            thisObj = (objHeader *) _Malloc(i);
+            if (thisObj == NULL) {
+                break;
+            }
+            thisObj->prev = lastObj;
+            thisObj->length = i;
+            lastObj = thisObj;
+        }
+    }
+
+    // Free the objects backwards
+    long int lastLength = 0;
+    long int lastLengthCount = 0;
+    uint32_t total = 0;
+    while (lastObj != NULL) {
+        if (lastObj->length != lastLength) {
+            lastLength = lastObj->length;
+            lastLengthCount = 1;
+        } else {
+            lastLengthCount++;
+        }
+        objHeader *thisObj = lastObj;
+        lastObj = lastObj->prev;
+        total += thisObj->length;
+        _Free(thisObj);
+    }
+
+    return total;
+
+}
+
+//**************************************************************************/
+/*!
+  @brief  Create a desc from a buffer, or initialize a new to-be-allocated desc
+		  if the buf is null
+  @param   desc Pointer to the payload descriptor
+  @param   buf Pointer to the buffer to initialize the desc with (or NULL)
+  @param   buflen Length of the buffer to initialize the desc with (or 0)
+*/
+/**************************************************************************/
+void NotePayloadSet(NotePayloadDesc *desc, uint8_t *buf, uint32_t buflen)
+{
+    desc->data = buf;
+    desc->alloc = buflen;
+    desc->length = buflen;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Free the payload pointed to by the descriptor
+  @param   desc Pointer to the payload descriptor
+*/
+/**************************************************************************/
+void NotePayloadFree(NotePayloadDesc *desc)
+{
+    if (desc->data != NULL) {
+        _Free(desc->data);
+    }
+    desc->data = NULL;
+    desc->alloc = 0;
+    desc->length = 0;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Add a segment to the specified binary with 4-character type code
+  @param   desc Pointer to the payload descriptor
+  @param   segtype Pointer to the 4-character payload identifier
+  @param   data Pointer to the data segment to be appended
+  @param   len Length of data segment
+  @returns boolean. `true` if named segment is appended successfully
+*/
+/**************************************************************************/
+bool NotePayloadAddSegment(NotePayloadDesc *desc, const char segtype[NP_SEGTYPE_LEN], void *data, uint32_t len)
+{
+    uint32_t alloc = 512;
+    uint32_t hlen = len + NP_SEGHDR_LEN;
+    if (hlen > alloc) {
+        alloc += hlen;
+    }
+    if (desc->data == NULL) {
+        uint8_t *base = _Malloc(alloc);
+        if (base == NULL) {
+            return false;
+        }
+        uint8_t *p = base;
+        memcpy(p, segtype, NP_SEGTYPE_LEN);
+        p += NP_SEGTYPE_LEN;
+        memcpy(p, &len, NP_SEGLEN_LEN);
+        p += NP_SEGLEN_LEN;
+        memcpy(p, data, len);
+        desc->data = base;
+        desc->alloc = alloc;
+        desc->length = hlen;
+    } else if ((desc->alloc - desc->length) < hlen) {
+        uint8_t *base = _Malloc(desc->alloc + alloc);
+        if (base == NULL) {
+            return false;
+        }
+        uint8_t *p = base;
+        memcpy(p, desc->data, desc->length);
+        p += desc->length;
+        memcpy(p, segtype, NP_SEGTYPE_LEN);
+        p += NP_SEGTYPE_LEN;
+        memcpy(p, &len, NP_SEGLEN_LEN);
+        p += NP_SEGLEN_LEN;
+        memcpy(p, data, len);
+        _Free(desc->data);
+        desc->data = base;
+        desc->alloc = desc->alloc + alloc;
+        desc->length += hlen;
+    } else {
+        uint8_t *p = desc->data + desc->length;
+        memcpy(p, segtype, NP_SEGTYPE_LEN);
+        p += NP_SEGTYPE_LEN;
+        memcpy(p, &len, NP_SEGLEN_LEN);
+        p += NP_SEGLEN_LEN;
+        memcpy(p, data, len);
+        desc->length += hlen;
+    }
+    return true;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Find and copy a named segment from a segmented payload
+  @param   desc Pointer to the payload descriptor
+  @param   segtype Pointer to the 4-character payload identifier
+  @param   pdata Buffer to copy found segment to if return is true
+  @param   len The expected length of the returned segment
+  @returns boolean. `true` if named segment is restored successfully
+*/
+/**************************************************************************/
+bool NotePayloadGetSegment(NotePayloadDesc *desc, const char segtype[NP_SEGTYPE_LEN], void *pdata, uint32_t len)
+{
+    uint8_t *data;
+    uint32_t datalen;
+    bool success = NotePayloadFindSegment(desc, segtype, &data, &datalen);
+    if (success && datalen == len) {
+        memcpy(pdata, data, len);
+        return true;
+    }
+    return false;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Find a named segment within a segmented payload
+  @param   desc Pointer to the payload descriptor
+  @param   segtype Pointer to the 4-character payload identifier
+  @param   pdata Pointer to the found segment if return is true
+  @param   plen Pointer to the returned segment length if return is true
+  @returns boolean. `true` if named segment is found
+*/
+/**************************************************************************/
+bool NotePayloadFindSegment(NotePayloadDesc *desc, const char segtype[NP_SEGTYPE_LEN], void *pdata, uint32_t *plen)
+{
+
+    // Preset returns
+    * (uint8_t **) pdata = NULL;
+    *plen = 0;
+
+    // Locate the segment
+    uint8_t *p = desc->data;
+    uint32_t left = desc->length;
+    if (p == NULL) {
+        return false;
+    }
+    while (left >= NP_SEGHDR_LEN) {
+        uint32_t len;
+        memcpy(&len, p + NP_SEGTYPE_LEN, sizeof(len));
+        if (memcmp(p, segtype, NP_SEGTYPE_LEN) == 0) {
+            *plen = len;
+            * (uint8_t **) pdata = p + NP_SEGHDR_LEN;
+            return true;
+        }
+        len += NP_SEGHDR_LEN;
+        p += len;
+        if (len > left) {
+            left = 0;
+        } else {
+            left -= len;
+        }
+    }
+    return false;
+}
+
+void NoteTurboIO(bool enable)
+{
+    (void)enable;
+
+    NOTE_C_LOG_WARN("NoteTurboIO is deprecated and has no effect.");
+}
diff --git a/src/note-c/n_hooks.c b/src/note-c/n_hooks.c
new file mode 100644
index 0000000..3e00d0e
--- /dev/null
+++ b/src/note-c/n_hooks.c
@@ -0,0 +1,911 @@
+/*!
+ * @file n_hooks.c
+ *
+ * Hooks allow libraries dependent on note-c to provide platform- or
+ * MCU-specific functions for common functions like I2C locking/unlocking,
+ * memory allocation and freeing, delays, and communicating with the Notecard
+ * over I2C and Serial. Using these hooks, note-c is able to manage Notecard
+ * transaction logic, and defer to platform functionality, when needed.
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include "n_lib.h"
+
+//**************************************************************************/
+/*!
+  @brief  Show malloc operations for debugging in very low mem environments.
+*/
+/**************************************************************************/
+#define NOTE_SHOW_MALLOC  false
+#if NOTE_SHOW_MALLOC
+#include <string.h>
+void *malloc_show(size_t len);
+#endif
+
+// Which I/O port to use
+#define interfaceNone       0
+#define interfaceSerial     1
+#define interfaceI2C        2
+
+// Externalized Hooks
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's debug interface, if any.
+*/
+/**************************************************************************/
+debugOutputFn hookDebugOutput = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's I2C lock function.
+*/
+/**************************************************************************/
+mutexFn hookLockI2C = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's I2C unlock function.
+*/
+/**************************************************************************/
+mutexFn hookUnlockI2C = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's Notecard lock function.
+*/
+/**************************************************************************/
+mutexFn hookLockNote = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's Notecard lock function.
+*/
+/**************************************************************************/
+mutexFn hookUnlockNote = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's transaction initiation function.
+*/
+/**************************************************************************/
+txnStartFn hookTransactionStart = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's transaction completion function.
+*/
+/**************************************************************************/
+txnStopFn hookTransactionStop = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's memory allocation function.
+*/
+/**************************************************************************/
+mallocFn hookMalloc = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's memory free function.
+*/
+/**************************************************************************/
+freeFn hookFree = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's delay function.
+*/
+/**************************************************************************/
+delayMsFn hookDelayMs = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's millis timing function.
+*/
+/**************************************************************************/
+getMsFn hookGetMs = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's current active interface. Value is
+  one of:
+  - interfaceNone = 0 (default)
+  - interfaceSerial = 1
+  - interfaceI2C = 2
+*/
+/**************************************************************************/
+uint32_t hookActiveInterface = interfaceNone;
+
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's Serial reset function.
+*/
+/**************************************************************************/
+serialResetFn hookSerialReset = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's Serial transmit function.
+*/
+/**************************************************************************/
+serialTransmitFn hookSerialTransmit = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's Serial data available function.
+*/
+/**************************************************************************/
+serialAvailableFn hookSerialAvailable = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's Serial receive function.
+*/
+/**************************************************************************/
+serialReceiveFn hookSerialReceive = NULL;
+
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's I2C address.
+*/
+/**************************************************************************/
+uint32_t i2cAddress = 0;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's I2C maximum segment size, in bytes.
+*/
+/**************************************************************************/
+uint32_t i2cMax = 0;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's I2C reset function.
+*/
+/**************************************************************************/
+i2cResetFn hookI2CReset = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's transmit function.
+*/
+/**************************************************************************/
+i2cTransmitFn hookI2CTransmit = NULL;
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's I2C receive function.
+*/
+/**************************************************************************/
+i2cReceiveFn hookI2CReceive = NULL;
+
+// Internal hooks
+typedef bool (*nNoteResetFn) (void);
+typedef const char * (*nTransactionFn) (const char *, size_t, char **, uint32_t);
+typedef const char * (*nReceiveFn) (uint8_t *, uint32_t *, bool, uint32_t, uint32_t *);
+typedef const char * (*nTransmitFn) (uint8_t *, uint32_t, bool);
+static nNoteResetFn notecardReset = NULL;
+static nTransactionFn notecardTransaction = NULL;
+static nReceiveFn notecardChunkedReceive = NULL;
+static nTransmitFn notecardChunkedTransmit = NULL;
+
+/*!
+ @brief  Set the default memory and timing hooks if they aren't already set
+ @param   mallocfn  The default memory allocation `malloc`
+ function to use.
+ @param   freefn  The default memory free
+ function to use.
+ @param   delayfn  The default delay function to use.
+ @param   millisfn  The default 'millis' function to use.
+ */
+void NoteSetFnDefault(mallocFn mallocfn, freeFn freefn, delayMsFn delayfn, getMsFn millisfn)
+{
+    if (hookMalloc == NULL) {
+        hookMalloc = mallocfn;
+    }
+    if (hookFree == NULL) {
+        hookFree = freefn;
+    }
+    if (hookDelayMs == NULL) {
+        hookDelayMs = delayfn;
+    }
+    if (hookGetMs == NULL) {
+        hookGetMs = millisfn;
+    }
+}
+
+/*!
+ @brief Set the platform-specific memory and timing hooks.
+
+ @param mallocHook The platform-specific memory allocation function (i.e.
+        `malloc`).
+ @param freeHook The platform-specific memory free function (i.e. `free`).
+ @param delayMsHook The platform-specific millisecond delay function.
+ @param getMsHook The platform-specific millisecond counter function.
+*/
+void NoteSetFn(mallocFn mallocHook, freeFn freeHook, delayMsFn delayMsHook,
+               getMsFn getMsHook)
+{
+    hookMalloc = mallocHook;
+    hookFree = freeHook;
+    hookDelayMs = delayMsHook;
+    hookGetMs = getMsHook;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the platform-specific debug output function.
+  @param   fn  A function pointer to call for debug output.
+*/
+/**************************************************************************/
+void NoteSetFnDebugOutput(debugOutputFn fn)
+{
+    hookDebugOutput = fn;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine if a debug output function has been set.
+  @returns  A boolean indicating whether a debug ouput function was
+  provided.
+*/
+/**************************************************************************/
+bool noteIsDebugOutputActive(void)
+{
+    return hookDebugOutput != NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the platform-specific transaction initiation/completion fn's
+  @param   startFn  The platform-specific transaction initiation function to use.
+  @param   stopFn  The platform-specific transaction completion function to use.
+  to use.
+*/
+/**************************************************************************/
+void NoteSetFnTransaction(txnStartFn startFn, txnStopFn stopFn)
+{
+    hookTransactionStart = startFn;
+    hookTransactionStop = stopFn;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the platform-specific mutex functions for I2C and the
+  Notecard.
+  @param   lockI2Cfn  The platform-specific I2C lock function to use.
+  @param   unlockI2Cfn  The platform-specific I2C unlock function to use.
+  @param   lockNotefn  The platform-specific Notecard lock function to use.
+  @param   unlockNotefn  The platform-specific Notecard unlock function
+  to use.
+*/
+/**************************************************************************/
+void NoteSetFnMutex(mutexFn lockI2Cfn, mutexFn unlockI2Cfn, mutexFn lockNotefn, mutexFn unlockNotefn)
+{
+    hookLockI2C = lockI2Cfn;
+    hookUnlockI2C = unlockI2Cfn;
+    hookLockNote = lockNotefn;
+    hookUnlockNote = unlockNotefn;
+}
+
+/*!
+ @brief Set the platform-specific mutex functions for I2C.
+
+ @param lockI2Cfn The platform-specific I2C lock function.
+ @param unlockI2Cfn The platform-specific I2C unlock function.
+ */
+void NoteSetFnI2CMutex(mutexFn lockI2Cfn, mutexFn unlockI2Cfn)
+{
+    hookLockI2C = lockI2Cfn;
+    hookUnlockI2C = unlockI2Cfn;
+}
+
+/*!
+ @brief  Set the platform-specific mutex functions for the Notecard.
+
+ @param lockFn The platform-specific Notecard lock function.
+ @param unlockFn The platform-specific Notecard unlock function.
+ */
+void NoteSetFnNoteMutex(mutexFn lockFn, mutexFn unlockFn)
+{
+    hookLockNote = lockFn;
+    hookUnlockNote = unlockFn;
+}
+
+/*!
+ @brief Set the platform-specific hooks for communicating with the Notecard over
+        serial.
+
+ @param resetFn The platform-specific serial reset function.
+ @param transmitFn The platform-specific serial transmit function.
+ @param availFn The platform-specific serial available function.
+ @param receiveFn The platform-specific serial receive function.
+*/
+void NoteSetFnSerial(serialResetFn resetFn, serialTransmitFn transmitFn,
+                     serialAvailableFn availFn, serialReceiveFn receiveFn)
+{
+    hookActiveInterface = interfaceSerial;
+
+    hookSerialReset = resetFn;
+    hookSerialTransmit = transmitFn;
+    hookSerialAvailable = availFn;
+    hookSerialReceive = receiveFn;
+
+    notecardReset = serialNoteReset;
+    notecardTransaction = serialNoteTransaction;
+    notecardChunkedReceive = serialChunkedReceive;
+    notecardChunkedTransmit = serialChunkedTransmit;
+}
+
+/*!
+ @brief Set the platform-specific hooks for communicating with the Notecard over
+        I2C, as well as the I2C address of the Notecard and maximum transmission
+        size.
+
+  @param notecardAddr The I2C address of the Notecard. Pass 0 to use the default
+         address.
+  @param maxTransmitSize The max number of bytes to send to the Notecard in a
+         single I2C segment. Pass 0 to use the default maximum transmission
+         size.
+  @param resetFn The platform-specific I2C reset function.
+  @param transmitFn The platform-specific I2C transmit function.
+  @param receiveFn The platform-specific I2C receive function.
+ */
+void NoteSetFnI2C(uint32_t notecardAddr, uint32_t maxTransmitSize,
+                  i2cResetFn resetFn, i2cTransmitFn transmitFn,
+                  i2cReceiveFn receiveFn)
+{
+    i2cAddress = notecardAddr;
+    i2cMax = maxTransmitSize;
+
+    hookActiveInterface = interfaceI2C;
+
+    hookI2CReset = resetFn;
+    hookI2CTransmit = transmitFn;
+    hookI2CReceive = receiveFn;
+
+    notecardReset = i2cNoteReset;
+    notecardTransaction = i2cNoteTransaction;
+    notecardChunkedReceive = i2cChunkedReceive;
+    notecardChunkedTransmit = i2cChunkedTransmit;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the platform-specific communications method to be disabled
+*/
+/**************************************************************************/
+void NoteSetFnDisabled(void)
+{
+
+    hookActiveInterface = interfaceNone;
+
+    notecardReset = NULL;
+    notecardTransaction = NULL;
+    notecardChunkedReceive = NULL;
+    notecardChunkedTransmit = NULL;
+
+}
+
+// Runtime hook wrappers
+
+//**************************************************************************/
+/*!
+  @brief  Write a number to the debug stream and output a newline.
+  @param   line  A debug string for output.
+  @param n The number to write.
+*/
+/**************************************************************************/
+void NoteDebugIntln(const char *line, int n)
+{
+    if (line != NULL) {
+        _Debug(line);
+    }
+    char str[16];
+    JItoA(n, str);
+    _Debug(str);
+    _Debug(c_newline);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Write text to the debug stream and output a newline.
+  @param   line  A debug string for output.
+*/
+/**************************************************************************/
+void NoteDebugln(const char *line)
+{
+    _Debug(line);
+    _Debug(c_newline);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Write to the debug stream.
+  @param   line  A debug string for output.
+*/
+/**************************************************************************/
+void NoteDebug(const char *line)
+{
+#ifndef NOTE_NODEBUG
+    if (hookDebugOutput != NULL) {
+        hookDebugOutput(line);
+    }
+#endif
+}
+
+//**************************************************************************/
+/*!
+  @brief       Write the message to the debug stream, if the level is less than
+               or equal to NOTE_C_LOG_LEVEL. Otherwise, the message is dropped.
+  @param level The log level of the message. See the NOTE_C_LOG_LEVEL_* macros
+               in note.h for possible values.
+  @param msg   The debug message.
+*/
+/**************************************************************************/
+void NoteDebugWithLevel(uint8_t level, const char *msg)
+{
+#ifndef NOTE_NODEBUG
+
+    if (level > NOTE_C_LOG_LEVEL) {
+        return;
+    }
+
+    _Debug(msg);
+
+#endif // !NOTE_NODEBUG
+}
+
+//**************************************************************************/
+/*!
+  @brief       Same as NoteDebugWithLevel, but add a newline at the end.
+  @param level The log level of the message. See the NOTE_C_LOG_LEVEL_* macros
+               in note.h for possible values.
+  @param msg   The debug message.
+*/
+/**************************************************************************/
+void NoteDebugWithLevelLn(uint8_t level, const char *msg)
+{
+    _DebugWithLevel(level, msg);
+    _DebugWithLevel(level, c_newline);
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the current milliseconds value from the platform-specific
+  hook.
+  @returns  The current milliseconds value.
+*/
+/**************************************************************************/
+uint32_t NoteGetMs(void)
+{
+    if (hookGetMs == NULL) {
+        return 0;
+    }
+    return hookGetMs();
+}
+
+//**************************************************************************/
+/*!
+  @brief  Delay milliseconds using the platform-specific hook.
+  @param   ms the milliseconds delay value.
+*/
+/**************************************************************************/
+void NoteDelayMs(uint32_t ms)
+{
+    if (hookDelayMs != NULL) {
+        hookDelayMs(ms);
+    }
+}
+
+#if NOTE_SHOW_MALLOC || !defined(NOTE_C_LOW_MEM)
+//**************************************************************************/
+/*!
+  @brief  Convert number to a hex string
+  @param  n the number
+  @param  p the buffer to return it into
+*/
+/**************************************************************************/
+void n_htoa32(uint32_t n, char *p)
+{
+    int i;
+    for (i=0; i<8; i++) {
+        uint32_t nibble = (n >> 28) & 0xff;
+        n = n << 4;
+        if (nibble >= 10) {
+            *p++ = 'A' + (nibble-10);
+        } else {
+            *p++ = '0' + nibble;
+        }
+    }
+    *p = '\0';
+}
+#endif
+
+#if NOTE_SHOW_MALLOC
+//**************************************************************************/
+/*!
+  @brief  If set for low-memory platforms, show a malloc call.
+  @param   len the number of bytes of memory allocated by the last call.
+*/
+/**************************************************************************/
+void *malloc_show(size_t len)
+{
+    char str[16];
+    JItoA(len, str);
+    hookDebugOutput("malloc ");
+    hookDebugOutput(str);
+    void *p = hookMalloc(len);
+    if (p == NULL) {
+        hookDebugOutput("FAIL");
+    } else {
+        n_htoa32((uint32_t)p, str);
+        hookDebugOutput(str);
+    }
+    return p;
+}
+#endif
+
+//**************************************************************************/
+/*!
+  @brief  Allocate a memory chunk using the platform-specific hook.
+  @param   size the number of bytes to allocate.
+*/
+/**************************************************************************/
+void *NoteMalloc(size_t size)
+{
+    if (hookMalloc == NULL) {
+        return NULL;
+    }
+#if NOTE_SHOW_MALLOC
+    return malloc_show(size);
+#else
+    return hookMalloc(size);
+#endif
+}
+
+//**************************************************************************/
+/*!
+  @brief  Free memory using the platform-specific hook.
+  @param   p A pointer to the memory address to free.
+*/
+/**************************************************************************/
+void NoteFree(void *p)
+{
+    if (hookFree != NULL) {
+#if NOTE_SHOW_MALLOC
+        char str[16];
+        n_htoa32((uint32_t)p, str);
+        hookDebugOutput("free");
+        hookDebugOutput(str);
+#endif
+        hookFree(p);
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Lock the I2C bus using the platform-specific hook.
+*/
+/**************************************************************************/
+void NoteLockI2C(void)
+{
+    if (hookLockI2C != NULL) {
+        hookLockI2C();
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Unlock the I2C bus using the platform-specific hook.
+*/
+/**************************************************************************/
+void NoteUnlockI2C(void)
+{
+    if (hookUnlockI2C != NULL) {
+        hookUnlockI2C();
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Lock the Notecard using the platform-specific hook.
+*/
+/**************************************************************************/
+void noteLockNote(void)
+{
+    if (hookLockNote != NULL) {
+        hookLockNote();
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Unlock the Notecard using the platform-specific hook.
+*/
+/**************************************************************************/
+void noteUnlockNote(void)
+{
+    if (hookUnlockNote != NULL) {
+        hookUnlockNote();
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Indicate that we're initiating a transaction using the platform-specific hook.
+*/
+/**************************************************************************/
+bool noteTransactionStart(uint32_t timeoutMs)
+{
+    if (hookTransactionStart != NULL) {
+        return hookTransactionStart(timeoutMs);
+    }
+    return true;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Indicate that we've completed a transaction using the platform-specific hook.
+*/
+/**************************************************************************/
+void noteTransactionStop(void)
+{
+    if (hookTransactionStop != NULL) {
+        hookTransactionStop();
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the active interface's name
+  @returns A string
+*/
+/**************************************************************************/
+const char *noteActiveInterface(void)
+{
+    switch (hookActiveInterface) {
+    case interfaceSerial:
+        return "serial";
+    case interfaceI2C:
+        return "i2c";
+    }
+    return "unknown";
+}
+
+//**************************************************************************/
+/*!
+  @brief  Reset the Serial bus using the platform-specific hook.
+  @returns A boolean indicating whether the Serial bus was reset successfully.
+*/
+/**************************************************************************/
+bool noteSerialReset(void)
+{
+    if (hookActiveInterface == interfaceSerial && hookSerialReset != NULL) {
+        return hookSerialReset();
+    }
+    return true;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Transmit bytes over Serial using the platform-specific hook.
+  @param   text The bytes to transmit.
+  @param   len The length of bytes.
+  @param   flush `true` to flush the bytes upon transmit.
+*/
+/**************************************************************************/
+void noteSerialTransmit(uint8_t *text, size_t len, bool flush)
+{
+    if (hookActiveInterface == interfaceSerial && hookSerialTransmit != NULL) {
+        hookSerialTransmit(text, len, flush);
+    }
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine if Serial bus is available using the platform-specific
+  hook.
+  @returns A boolean indicating whether the Serial bus is available to read.
+*/
+/**************************************************************************/
+bool noteSerialAvailable(void)
+{
+    if (hookActiveInterface == interfaceSerial && hookSerialAvailable != NULL) {
+        return hookSerialAvailable();
+    }
+    return false;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Obtain a character from the Serial bus using the platform-specific
+  hook.
+  @returns A character from the Serial bus.
+*/
+/**************************************************************************/
+char noteSerialReceive(void)
+{
+    if (hookActiveInterface == interfaceSerial && hookSerialReceive != NULL) {
+        return hookSerialReceive();
+    }
+    return 0;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Reset the I2C bus using the platform-specific hook.
+  @returns A boolean indicating whether the I2C bus was reset successfully.
+*/
+/**************************************************************************/
+bool noteI2CReset(uint16_t DevAddress)
+{
+    if (hookActiveInterface == interfaceI2C && hookI2CReset != NULL) {
+        return hookI2CReset(DevAddress);
+    }
+    return true;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Transmit bytes over I2C using the platform-specific hook.
+  @param   DevAddress the I2C address for transmission.
+  @param   pBuffer The bytes to transmit.
+  @param   Size The length of bytes.
+  @returns A c-string from the platform-specific hook, or an error string
+  if the bus is not active.
+*/
+/**************************************************************************/
+const char *noteI2CTransmit(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size)
+{
+    if (hookActiveInterface == interfaceI2C && hookI2CTransmit != NULL) {
+        return hookI2CTransmit(DevAddress, pBuffer, Size);
+    }
+    return "i2c not active";
+}
+
+//**************************************************************************/
+/*!
+  @brief  Receive bytes from I2C using the platform-specific hook.
+  @param   DevAddress the I2C address for transmission.
+  @param   pBuffer (out) A buffer in which to place received bytes.
+  @param   Size The length of bytes.
+  @param   available (out) The number of bytes left to read.
+  @returns A c-string from the platform-specific hook, or an error string
+  if the bus is not active.
+*/
+/**************************************************************************/
+const char *noteI2CReceive(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size, uint32_t *available)
+{
+    if (hookActiveInterface == interfaceI2C && hookI2CReceive != NULL) {
+        return hookI2CReceive(DevAddress, pBuffer, Size, available);
+    }
+    return "i2c not active";
+}
+
+//**************************************************************************/
+/*!
+  @brief  Get the I2C address of the Notecard.
+  @returns The current I2C address.
+*/
+/**************************************************************************/
+uint32_t NoteI2CAddress(void)
+{
+    if (i2cAddress == 0) {
+        return NOTE_I2C_ADDR_DEFAULT;
+    }
+    return i2cAddress;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Set the I2C address for communication with the Notecard.
+  @param   i2caddress the I2C address to use for the Notecard.
+*/
+/**************************************************************************/
+void NoteSetI2CAddress(uint32_t i2caddress)
+{
+    i2cAddress = i2caddress;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Determine the maximum number of bytes for each segment of
+  data sent to the Notecard over I2C.
+  @returns A 32-bit integer of the maximum number of bytes per I2C segment.
+*/
+/**************************************************************************/
+uint32_t NoteI2CMax(void)
+{
+    // Many Arduino libraries (such as ESP32) have a limit less than 32, so if the max isn't specified
+    // we must assume the worst and segment the I2C messages into very tiny chunks.
+    if (i2cMax == 0) {
+        return NOTE_I2C_MAX_DEFAULT;
+    }
+    // Note design specs
+    if (i2cMax > NOTE_I2C_MAX_MAX) {
+        i2cMax = NOTE_I2C_MAX_MAX;
+    }
+    return i2cMax;
+}
+
+
+//**************************************************************************/
+/*!
+  @brief  Perform a hard reset on the Notecard using the platform-specific
+  hook.
+  @returns A boolean indicating whether the Notecard has been reset successfully.
+*/
+/**************************************************************************/
+bool noteHardReset(void)
+{
+    if (notecardReset == NULL) {
+        return true;
+    }
+    return notecardReset();
+}
+
+
+//**************************************************************************/
+/*!
+  @brief  Perform a JSON request to the Notecard using the currently-set
+  platform hook.
+
+  @param   request A string containing the JSON request object, which MUST BE
+            terminated with a newline character.
+  @param   reqLen the string length of the JSON request.
+  @param   response [out] A c-string buffer that will contain the newline ('\n')
+            terminated JSON response from the Notercard. If NULL, no response
+            will be captured.
+  @param   timeoutMs The maximum amount of time, in milliseconds, to wait
+            for data to arrive. Passing zero (0) disables the timeout.
+
+  @returns NULL if successful, or an error string if the transaction failed
+  or the hook has not been set.
+*/
+/**************************************************************************/
+const char *noteJSONTransaction(const char *request, size_t reqLen, char **response, uint32_t timeoutMs)
+{
+    if (notecardTransaction == NULL || hookActiveInterface == interfaceNone) {
+        return "i2c or serial interface must be selected";
+    }
+    return notecardTransaction(request, reqLen, response, timeoutMs);
+}
+
+/**************************************************************************/
+/*!
+  @brief  Receive bytes over from the Notecard using the currently-set
+  platform hook.
+  @param   buffer A buffer to receive bytes into.
+  @param   size (in/out)
+            - (in) The size of the buffer in bytes.
+            - (out) The length of the received data in bytes.
+  @param   delay Respect standard processing delays.
+  @param   timeoutMs The maximum amount of time, in milliseconds, to wait
+            for data to arrive. Passing zero (0) disables the timeout.
+  @param   available (in/out)
+            - (in) The amount of bytes to request. Sending zero (0) will
+                   initiate a priming query when using the I2C interface.
+            - (out) The amount of bytes unable to fit into the provided buffer.
+  @returns  A c-string with an error, or `NULL` if no error ocurred.
+*/
+/**************************************************************************/
+const char *noteChunkedReceive(uint8_t *buffer, uint32_t *size, bool delay,
+                               uint32_t timeoutMs, uint32_t *available)
+{
+    if (notecardChunkedReceive == NULL || hookActiveInterface == interfaceNone) {
+        return "i2c or serial interface must be selected";
+    }
+    return notecardChunkedReceive(buffer, size, delay, timeoutMs, available);
+}
+
+/**************************************************************************/
+/*!
+  @brief  Transmit bytes over to the Notecard using the currently-set
+  platform hook.
+  @param   buffer A buffer of bytes to transmit.
+  @param   size The count of bytes in the buffer to send
+  @param   delay Respect standard processing delays.
+  @returns  A c-string with an error, or `NULL` if no error ocurred.
+*/
+/**************************************************************************/
+const char *noteChunkedTransmit(uint8_t *buffer, uint32_t size, bool delay)
+{
+    if (notecardChunkedTransmit == NULL || hookActiveInterface == interfaceNone) {
+        return "i2c or serial interface must be selected";
+    }
+    return notecardChunkedTransmit(buffer, size, delay);
+}
diff --git a/src/note-c/n_i2c.c b/src/note-c/n_i2c.c
new file mode 100644
index 0000000..deb2269
--- /dev/null
+++ b/src/note-c/n_i2c.c
@@ -0,0 +1,466 @@
+/*!
+ * @file n_i2c.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <stdlib.h>
+
+#include "n_lib.h"
+
+#ifdef NOTE_C_TEST
+#include "test_static.h"
+#else
+#define NOTE_C_STATIC static
+#endif
+
+// Forwards
+NOTE_C_STATIC void delayIO(void);
+NOTE_C_STATIC const char * i2cNoteQueryLength(uint32_t * available, uint32_t timeoutMs);
+
+/**************************************************************************/
+/*!
+  @brief  We've noticed that there's an instability in some cards'
+  implementations of I2C, and as a result we introduce an intentional
+  delay before each and every I2C I/O.The timing was computed
+  empirically based on a number of commercial devices.
+*/
+/**************************************************************************/
+NOTE_C_STATIC void delayIO(void)
+{
+    if (!cardTurboIO) {
+        _DelayMs(6);
+    }
+}
+
+/**************************************************************************/
+/*!
+  @brief  Query the Notecard for the length of cached data.
+
+  @details  It is necessary to send a priming I2C transaction to understand
+             the amount of data the Notecard is prepared to send before an
+             I2C read request can be issued.
+*/
+/**************************************************************************/
+NOTE_C_STATIC const char * i2cNoteQueryLength(uint32_t * available,
+        uint32_t timeoutMs)
+{
+    uint8_t dummy_buffer = 0;
+
+    for (const uint32_t startMs = _GetMs() ; !(*available) ; _DelayMs(50)) {
+        // Send a dummy I2C transaction to prime the Notecard
+        const char *err = _I2CReceive(_I2CAddress(), &dummy_buffer, 0, available);
+        if (err) {
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+
+        // If we've timed out, return an error
+        if (timeoutMs && _GetMs() - startMs >= timeoutMs) {
+            const char *err = ERRSTR("timeout: no response from Notecard {io}", c_iotimeout);
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+    }
+    return NULL;
+}
+
+/**************************************************************************/
+/*!
+  @brief  Given a JSON string, perform an I2C transaction with the Notecard.
+
+  @param   request A string containing the JSON request object, which MUST BE
+            terminated with a newline character.
+  @param   reqLen the string length of the JSON request.
+  @param   response [out] A c-string buffer that will contain the newline ('\n')
+            terminated JSON response from the Notercard. If NULL, no response
+            will be captured.
+  @param   timeoutMs The maximum amount of time, in milliseconds, to wait
+            for data to arrive. Passing zero (0) disables the timeout.
+
+  @returns a c-string with an error, or `NULL` if no error occurred.
+*/
+/**************************************************************************/
+const char *i2cNoteTransaction(const char *request, size_t reqLen, char **response, uint32_t timeoutMs)
+{
+    const char *err = NULL;
+
+    // Lock over the entire transaction
+    _LockI2C();
+
+    err = i2cChunkedTransmit((uint8_t *)request, reqLen, true);
+    if (err) {
+        _UnlockI2C();
+        return err;
+    }
+
+    // If no reply expected, we're done
+    if (response == NULL) {
+        _UnlockI2C();
+        return NULL;
+    }
+
+    delayIO();
+
+    // Allocate a buffer for input, noting that we always put the +1 in the
+    // alloc so we can be assured that it can be null-terminated. This must be
+    // the case because json parsing requires a null-terminated string.
+    uint32_t available = 0;
+    err = i2cNoteQueryLength(&available, timeoutMs);
+    if (err) {
+        NOTE_C_LOG_ERROR(ERRSTR("failed to query Notecard", c_err));
+        _UnlockI2C();
+        return err;
+    }
+    size_t jsonbufAllocLen = (ALLOC_CHUNK * ((available / ALLOC_CHUNK) + ((available % ALLOC_CHUNK) > 0)));
+    uint8_t *jsonbuf = NULL;
+    if (jsonbufAllocLen) {
+        jsonbuf = (uint8_t *)_Malloc(jsonbufAllocLen + 1);
+        if (jsonbuf == NULL) {
+            const char *err = ERRSTR("transaction: jsonbuf malloc failed", c_mem);
+            NOTE_C_LOG_ERROR(err);
+            _UnlockI2C();
+            return err;
+        }
+    }
+
+    // Receive the Notecard response
+    uint32_t jsonbufLen = 0;
+    do {
+        uint32_t jsonbufAvailLen = (jsonbufAllocLen - jsonbufLen);
+
+        // Append into the json buffer
+        const char *err = i2cChunkedReceive((uint8_t *)(jsonbuf + jsonbufLen), &jsonbufAvailLen, true, (CARD_INTRA_TRANSACTION_TIMEOUT_SEC * 1000), &available);
+        if (err) {
+            if (jsonbuf) {
+                _Free(jsonbuf);
+            }
+            NOTE_C_LOG_ERROR(ERRSTR("error occured during receive", c_iobad));
+            _UnlockI2C();
+            return err;
+        }
+        jsonbufLen += jsonbufAvailLen;
+
+        if (available) {
+            // When more bytes are available than we have buffer to accommodate
+            // (i.e. overflow), then we allocate blocks of size `ALLOC_CHUNK` to
+            // reduce heap fragmentation.
+            // NOTE: We always put the +1 in the allocation so we can be assured
+            // that it can be null-terminated, because the json parser requires
+            // a null-terminated string.
+            jsonbufAllocLen += (ALLOC_CHUNK * ((available / ALLOC_CHUNK) + ((available % ALLOC_CHUNK) > 0)));
+            uint8_t *jsonbufNew = (uint8_t *)_Malloc(jsonbufAllocLen + 1);
+            if (jsonbufNew == NULL) {
+                const char *err = ERRSTR("transaction: jsonbuf grow malloc failed", c_mem);
+                NOTE_C_LOG_ERROR(err);
+                if (jsonbuf) {
+                    _Free(jsonbuf);
+                }
+                _UnlockI2C();
+                return err;
+            }
+            if (jsonbuf) {
+                memcpy(jsonbufNew, jsonbuf, jsonbufLen);
+                _Free(jsonbuf);
+            }
+            jsonbuf = jsonbufNew;
+            NOTE_C_LOG_DEBUG("additional receive buffer chunk allocated");
+        }
+    } while (available);
+
+    // Done with the bus
+    _UnlockI2C();
+
+    // Null-terminate it, using the +1 space that we'd allocated in the buffer
+    if (jsonbuf) {
+        jsonbuf[jsonbufLen] = '\0';
+    }
+
+    // Return it
+    *response = (char *)jsonbuf;
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+  @brief  Initialize or re-initialize the I2C subsystem, returning false if
+  anything fails.
+
+  @returns a boolean. `true` if the reset was successful, `false`, if not.
+*/
+/**************************************************************************/
+bool i2cNoteReset(void)
+{
+    bool notecardReady = false;
+
+    // Claim the I2C bus
+    _LockI2C();
+    NOTE_C_LOG_DEBUG("resetting I2C interface...");
+
+    // Reset the I2C subsystem and exit if failure
+    _DelayMs(CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+    notecardReady = _I2CReset(_I2CAddress());
+    if (!notecardReady) {
+        NOTE_C_LOG_ERROR(ERRSTR("error encountered during I2C reset hook execution", c_err));
+        _UnlockI2C();
+        return false;
+    }
+    delayIO();
+
+    // The guaranteed behavior for robust resyncing is to send two newlines
+    // and  wait for two echoed blank lines in return.
+    for (size_t retries = 0; retries < CARD_RESET_SYNC_RETRIES ; ++retries) {
+        // Send a newline to the module to clean out request/response processing
+        // NOTE: This MUST always be `\n` and not `\r\n`, because there are some
+        //       versions of the Notecard firmware will not respond to `\r\n`
+        //       after communicating over I2C.
+        const char *transmitErr = _I2CTransmit(_I2CAddress(), (uint8_t *)"\n", 1);
+        // If we get a failure on transmitting the `\n`, it means that the
+        // Notecard isn't present.
+        if (transmitErr) {
+            NOTE_C_LOG_ERROR(transmitErr);
+            NOTE_C_LOG_ERROR(ERRSTR("error encountered during I2C transmit hook execution", c_err));
+            _DelayMs(CARD_REQUEST_I2C_NACK_WAIT_MS);
+            notecardReady = false;
+            continue;
+        }
+
+        // Wait for the Notecard to respond with a carriage return and newline
+        _DelayMs(CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+
+        // Determine if I2C data is available
+        // set initial state of variable to perform query
+        uint16_t chunkLen = 0;
+
+        // Content flags to determine if reset conditions are met.
+        bool somethingFound = false;
+        bool nonControlCharFound = false;
+
+        // Read I2C data for at least `CARD_RESET_DRAIN_MS` continuously
+        for (uint32_t startMs = _GetMs() ; (_GetMs() - startMs) < CARD_RESET_DRAIN_MS ;) {
+
+            // Read the next chunk of available data
+            uint32_t available = 0;
+            uint8_t buffer[ALLOC_CHUNK] = {0};
+            chunkLen = (chunkLen > sizeof(buffer)) ? sizeof(buffer) : chunkLen;
+            chunkLen = (chunkLen > _I2CMax()) ? _I2CMax() : chunkLen;
+            const char *err = _I2CReceive(_I2CAddress(), buffer, chunkLen, &available);
+            if (err) {
+                // We have received a hardware or protocol level error.
+                // Introduce delay to relieve system stress.
+                NOTE_C_LOG_ERROR(err);
+                NOTE_C_LOG_ERROR(ERRSTR("error encountered during I2C receive hook execution", c_err));
+                _DelayMs(CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+                notecardReady = false;
+                continue;
+            }
+
+            // Set content flags
+            if (chunkLen) {
+                somethingFound = true;
+                // The Notecard responds to a bare `\n` with `\r\n`. If we get
+                // any other characters back, it means the host and Notecard
+                // aren't synced up yet and we need to transmit `\n` again.
+                for (size_t i = 0; i < chunkLen ; ++i) {
+                    char ch = buffer[i];
+                    if (ch != '\n' && ch != '\r') {
+                        nonControlCharFound = true;
+                        // Reset the timer with each non-control character
+                        startMs = _GetMs();
+                    }
+                }
+            }
+
+            // Read the minimum of the available bytes left to read and what
+            // will fit into a 16-bit unsigned value (_I2CReceive takes the
+            // buffer size as a uint16_t).
+            chunkLen = (available > 0xFFFF) ? 0xFFFF : available;
+
+            _DelayMs(CARD_REQUEST_I2C_CHUNK_DELAY_MS);
+        }
+
+        // If characters were received and they were ONLY `\r` or `\n`,
+        // then the Notecard has been successfully reset.
+        if (!somethingFound || nonControlCharFound) {
+            notecardReady = false;
+            if (somethingFound) {
+                NOTE_C_LOG_WARN(ERRSTR("unrecognized data from notecard", c_iobad));
+            } else {
+                NOTE_C_LOG_ERROR(ERRSTR("notecard not responding", c_iobad));
+
+                // Reset the I2C subsystem and exit if failure
+                if (!_I2CReset(_I2CAddress())) {
+                    NOTE_C_LOG_ERROR(ERRSTR("error encountered during I2C reset hook execution", c_err));
+                    break;
+                }
+                delayIO();
+            }
+        } else {
+            notecardReady = true;
+            break;
+        }
+
+        NOTE_C_LOG_DEBUG("retrying I2C interface reset...")
+    }
+
+    // Done with the I2C bus
+    _UnlockI2C();
+
+    // Done
+    return notecardReady;
+}
+
+/**************************************************************************/
+/*!
+  @brief  Receive bytes over I2C from the Notecard.
+
+  @param   buffer A buffer to receive bytes into.
+  @param   size (in/out)
+            - (in) The size of the buffer in bytes.
+            - (out) The length of the received data in bytes.
+  @param   delay Respect standard processing delays.
+  @param   timeoutMs The maximum amount of time, in milliseconds, to wait for
+            serial data to arrive. Passing zero (0) disables the timeout.
+  @param   available (in/out)
+            - (in) The amount of bytes to request. Sending zero (0) will
+                   initiate a priming query when using the I2C interface.
+            - (out) The amount of bytes unable to fit into the provided buffer.
+
+  @returns  A c-string with an error, or `NULL` if no error ocurred.
+*/
+/**************************************************************************/
+const char *i2cChunkedReceive(uint8_t *buffer, uint32_t *size, bool delay, uint32_t timeoutMs, uint32_t *available)
+{
+    // Load buffer with chunked I2C values
+    size_t received = 0;
+    uint16_t requested = 0;
+    bool overflow = false;
+    uint32_t startMs = _GetMs();
+
+    // Request all available bytes, up to the maximum request size
+    requested = (*available > 0xFFFF) ? 0xFFFF : *available;
+    requested = (requested > _I2CMax()) ? _I2CMax() : requested;
+
+    for (bool eop = false ; !overflow ; overflow = ((received + requested) > *size)) {
+
+        // Read a chunk of data from I2C
+        // The first read will request zero bytes to query the amount of data
+        // available to receive from the Notecard.
+        const char *err = _I2CReceive(_I2CAddress(), (buffer + received), requested, available);
+        if (err) {
+            *size = received;
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+
+        // Add requested bytes to received total
+        received += requested;
+
+        // Once we've received any character, we will no longer wait patiently
+        if (requested != 0) {
+            timeoutMs = (CARD_INTRA_TRANSACTION_TIMEOUT_SEC * 1000);
+            startMs = _GetMs();
+        }
+
+        // Request all available bytes, up to the maximum request size
+        requested = (*available > 0xFFFF) ? 0xFFFF : *available;
+        requested = (requested > _I2CMax()) ? _I2CMax() : requested;
+
+        // Look for end-of-packet marker
+        if (received > 0 && !eop) {
+            eop = (buffer[received-1] == '\n');
+        }
+
+        // If the last byte of the chunk is `\n`, then we have received a
+        // complete message. However, everything pending from the Notecard must
+        // be pulled. This loop will only exit when a newline is received AND
+        // there are no more bytes available from the Notecard, OR if the buffer
+        // is full and cannot receive more bytes (i.e. overflow condition).
+        if (*available && eop) {
+            NOTE_C_LOG_WARN(ERRSTR("received newline before all data was received", c_iobad));
+        };
+
+        // If there's something available on the Notecard for us to receive, do it
+        if (*available > 0) {
+            continue;
+        }
+
+        // If there's nothing available AND we've received a newline, we're done
+        if (eop) {
+            break;
+        }
+
+        // Exit on timeout
+        if (timeoutMs && (_GetMs() - startMs >= timeoutMs)) {
+            *size = received;
+            if (received) {
+                NOTE_C_LOG_ERROR(ERRSTR("received only partial reply before timeout", c_iobad));
+            }
+            return ERRSTR("timeout: transaction incomplete {io}", c_iotimeout);
+        }
+
+        // Delay, simply waiting for the Note to process the request
+        if (delay) {
+            _DelayMs(50);
+        }
+    }
+
+    *size = received;
+    return NULL;
+}
+
+/**************************************************************************/
+/*!
+  @brief  Transmit bytes over I2C to the Notecard.
+
+  @param   buffer A buffer of bytes to transmit.
+  @param   size The count of bytes in the buffer to send
+  @param   delay Respect standard processing delays.
+
+  @returns  A c-string with an error, or `NULL` if no error ocurred.
+*/
+/**************************************************************************/
+const char *i2cChunkedTransmit(uint8_t *buffer, uint32_t size, bool delay)
+{
+    // Transmit the request in chunks, but also in segments so as not to
+    // overwhelm the notecard's interrupt buffers
+    const char *estr;
+    uint8_t *chunk = buffer;
+    uint16_t sentInSegment = 0;
+    while (size > 0) {
+        // Constrain chunkLen to fit into 16 bits (_I2CTransmit takes the buffer
+        // size as a uint16_t).
+        uint16_t chunkLen = (size > 0xFFFF) ? 0xFFFF : size;
+        // Constrain chunkLen to be <= _I2CMax().
+        chunkLen = (chunkLen > _I2CMax()) ? _I2CMax() : chunkLen;
+
+        delayIO();
+        estr = _I2CTransmit(_I2CAddress(), chunk, chunkLen);
+        if (estr != NULL) {
+            _I2CReset(_I2CAddress());
+            NOTE_C_LOG_ERROR(estr);
+            return estr;
+        }
+        chunk += chunkLen;
+        size -= chunkLen;
+        sentInSegment += chunkLen;
+        if (sentInSegment > CARD_REQUEST_I2C_SEGMENT_MAX_LEN) {
+            sentInSegment = 0;
+            if (delay) {
+                _DelayMs(CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+            }
+        }
+        if (delay) {
+            _DelayMs(CARD_REQUEST_I2C_CHUNK_DELAY_MS);
+        }
+    }
+
+    return NULL;
+}
diff --git a/src/note-c/n_lib.h b/src/note-c/n_lib.h
new file mode 100644
index 0000000..60d59b7
--- /dev/null
+++ b/src/note-c/n_lib.h
@@ -0,0 +1,240 @@
+/*!
+ * @file n_lib.h
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <string.h>
+
+#include "note.h"
+
+// C-callable functions
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**************************************************************************/
+/*!
+    @brief  How long to wait for the card for any given transaction.
+*/
+/**************************************************************************/
+#define CARD_INTER_TRANSACTION_TIMEOUT_SEC 30
+#define CARD_INTRA_TRANSACTION_TIMEOUT_SEC  1
+
+// The notecard is a real-time device that has a fixed size interrupt buffer.
+// We can push data at it far, far faster than it can process it, therefore we
+// push it in segments with a pause between each segment.
+
+/**************************************************************************/
+/*!
+    @brief  The max length, in bytes, of each request segment when using I2C.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_I2C_SEGMENT_MAX_LEN 250
+/**************************************************************************/
+/*!
+    @brief  The delay, in miliseconds, of each request when using I2C.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_I2C_SEGMENT_DELAY_MS 250
+/**************************************************************************/
+/*!
+    @brief  The delay, in miliseconds, between each request chunk when using I2C.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_I2C_CHUNK_DELAY_MS 20
+/**************************************************************************/
+/*!
+    @brief  The delay, in miliseconds, to wait after receiving a NACK I2C.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_I2C_NACK_WAIT_MS 1000
+/**************************************************************************/
+/*!
+    @brief  The max length, in bytes, of each request segment when using Serial.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN 250
+/**************************************************************************/
+/*!
+    @brief  The delay, in miliseconds, of each request when using Serial.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_SERIAL_SEGMENT_DELAY_MS 250
+/**************************************************************************/
+/*!
+    @brief  The time, in miliseconds, to drain incoming messages.
+*/
+/**************************************************************************/
+#define CARD_RESET_DRAIN_MS 500
+/**************************************************************************/
+/*!
+    @brief  The number of times we will retry a request before giving up.
+*/
+/**************************************************************************/
+#define CARD_REQUEST_RETRIES_ALLOWED 5
+/**************************************************************************/
+/*!
+    @brief  The number of times we will retry getting in sync before giving up.
+*/
+/**************************************************************************/
+#define CARD_RESET_SYNC_RETRIES 10
+/**************************************************************************/
+/*!
+    @brief  Memory allocation chunk size.
+*/
+/**************************************************************************/
+#ifdef NOTE_C_LOW_MEM
+#define ALLOC_CHUNK 64
+#else
+#define ALLOC_CHUNK 128
+#endif
+
+#ifdef NOTE_C_LOW_MEM
+#define NOTE_DISABLE_USER_AGENT
+#endif
+
+// Transactions
+J *noteTransactionShouldLock(J *req, bool lockNotecard);
+const char *i2cNoteTransaction(const char *request, size_t reqLen, char **response, uint32_t timeoutMs);
+bool i2cNoteReset(void);
+const char *serialNoteTransaction(const char *request, size_t reqLen, char **response, uint32_t timeoutMs);
+bool serialNoteReset(void);
+const char *i2cChunkedReceive(uint8_t *buffer, uint32_t *size, bool delay, uint32_t timeoutMs, uint32_t *available);
+const char *i2cChunkedTransmit(uint8_t *buffer, uint32_t size, bool delay);
+const char *serialChunkedReceive(uint8_t *buffer, uint32_t *size, bool delay, uint32_t timeoutMs, uint32_t *available);
+const char *serialChunkedTransmit(uint8_t *buffer, uint32_t size, bool delay);
+
+// Hooks
+void noteLockNote(void);
+void noteUnlockNote(void);
+bool noteTransactionStart(uint32_t timeoutMs);
+void noteTransactionStop(void);
+const char *noteActiveInterface(void);
+bool noteSerialReset(void);
+void noteSerialTransmit(uint8_t *, size_t, bool);
+bool noteSerialAvailable(void);
+char noteSerialReceive(void);
+bool noteI2CReset(uint16_t DevAddress);
+const char *noteI2CTransmit(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size);
+const char *noteI2CReceive(uint16_t DevAddress, uint8_t* pBuffer, uint16_t Size, uint32_t *avail);
+bool noteHardReset(void);
+const char *noteJSONTransaction(const char *request, size_t reqLen, char **response, uint32_t timeoutMs);
+const char *noteChunkedReceive(uint8_t *buffer, uint32_t *size, bool delay, uint32_t timeoutMs, uint32_t *available);
+const char *noteChunkedTransmit(uint8_t *buffer, uint32_t size, bool delay);
+bool noteIsDebugOutputActive(void);
+
+// Utilities
+void n_htoa32(uint32_t n, char *p);
+void n_htoa16(uint16_t n, unsigned char *p);
+uint64_t n_atoh(char *p, int maxLen);
+
+// COBS Helpers
+uint32_t cobsDecode(uint8_t *ptr, uint32_t length, uint8_t eop, uint8_t *dst);
+uint32_t cobsEncode(uint8_t *ptr, uint32_t length, uint8_t eop, uint8_t *dst);
+uint32_t cobsEncodedLength(const uint8_t *ptr, uint32_t length);
+uint32_t cobsEncodedMaxLength(uint32_t length);
+uint32_t cobsGuaranteedFit(uint32_t bufLen);
+
+// Turbo I/O mode
+extern bool cardTurboIO;
+
+// Constants, a global optimization to save static string memory
+extern const char *c_null;
+#define c_null_len 4
+
+extern const char *c_false;
+#define c_false_len 5
+
+extern const char *c_true;
+#define c_true_len 4
+
+extern const char *c_nullstring;
+#define c_nullstring_len 0
+
+extern const char *c_newline;
+#define c_newline_len 2
+
+extern const char *c_mem;
+#define c_mem_len 3
+
+extern const char *c_iotimeout;
+#define c_iotimeout_len 12
+
+extern const char *c_err;
+#define c_err_len 3
+
+extern const char *c_req;
+#define c_req_len 3
+
+extern const char *c_cmd;
+#define c_cmd_len 3
+
+extern const char *c_bad;
+#define c_bad_len 3
+
+extern const char *c_iobad;
+#define c_iobad_len 8
+
+extern const char *c_ioerr;
+#define c_ioerr_len 4
+
+extern const char *c_unsupported;
+#define c_unsupported_len 15
+
+extern const char *c_badbinerr;
+#define c_badbinerr_len 9
+
+// Readability wrappers.  Anything starting with _ is simply calling the wrapper
+// function.
+#define _LockNote noteLockNote
+#define _UnlockNote noteUnlockNote
+#define _TransactionStart noteTransactionStart
+#define _TransactionStop noteTransactionStop
+#define _SerialReset noteSerialReset
+#define _SerialTransmit noteSerialTransmit
+#define _SerialAvailable noteSerialAvailable
+#define _SerialReceive noteSerialReceive
+#define _I2CReset noteI2CReset
+#define _I2CTransmit noteI2CTransmit
+#define _I2CReceive noteI2CReceive
+#define _Reset noteHardReset
+#define _Transaction noteJSONTransaction
+#define _ChunkedReceive noteChunkedReceive
+#define _ChunkedTransmit noteChunkedTransmit
+#define _Malloc NoteMalloc
+#define _Free NoteFree
+#define _GetMs NoteGetMs
+#define _DelayMs NoteDelayMs
+#define _LockI2C NoteLockI2C
+#define _UnlockI2C NoteUnlockI2C
+#define _I2CAddress NoteI2CAddress
+#define _I2CMax NoteI2CMax
+#ifdef NOTE_NODEBUG
+#define _Debug(x)
+#define _Debugln(x)
+#define _DebugIntln(x, y)
+#define _DebugWithLevel(x, y)
+#define _DebugWithLevelLn(x, y)
+#else
+#define _Debug(x) NoteDebug(x)
+#define _Debugln(x) NoteDebugln(x)
+#define _DebugIntln(x, y) NoteDebugIntln(x, y)
+#define _DebugWithLevel(x, y) NoteDebugWithLevel(x, y)
+#define _DebugWithLevelLn(x, y) NoteDebugWithLevelLn(x, y)
+#endif
+
+// End of C-callable functions
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/note-c/n_md5.c b/src/note-c/n_md5.c
new file mode 100644
index 0000000..739fd7a
--- /dev/null
+++ b/src/note-c/n_md5.c
@@ -0,0 +1,321 @@
+/*
+ * https://opensource.apple.com/source/cvs/cvs-19/cvs/lib/md5.c
+ *
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to NoteMD5Init, call NoteMD5Update as
+ * needed on buffers full of bytes, and then call NoteMD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+/* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
+   not require an integer type which is exactly 32 bits.  This work
+   draws on the changes for the same purpose by Tatu Ylonen
+   <ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
+   that code, there is no copyright issue.  I hereby disclaim
+   copyright in any changes I have made; this code remains in the
+   public domain.  */
+
+#include <string.h>
+#include "n_lib.h"
+
+// Forwards
+void n_htoa8(unsigned char n, unsigned char *p);
+static void putu32 (unsigned long data, unsigned char *addr);
+static unsigned long getu32 (const unsigned char *addr);
+
+/* Little-endian byte-swapping routines.  Note that these do not
+   depend on the size of datatypes such as unsigned long, nor do they require
+   us to detect the endianness of the machine we are running on.  It
+   is possible they should be macros for speed, but I would be
+   surprised if they were a performance bottleneck for MD5.  */
+
+static unsigned long getu32 (const unsigned char *addr)
+{
+    return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
+            | addr[1]) << 8 | addr[0];
+}
+
+static void putu32 (unsigned long data, unsigned char *addr)
+{
+    addr[0] = (unsigned char)data;
+    addr[1] = (unsigned char)(data >> 8);
+    addr[2] = (unsigned char)(data >> 16);
+    addr[3] = (unsigned char)(data >> 24);
+}
+
+/* Convert an 8-bit number to 2 hex digits, null-terminating it */
+void n_htoa8(unsigned char n, unsigned char *p)
+{
+    unsigned char nibble = (n >> 4) & 0xf;
+    if (nibble >= 10) {
+        *p++ = 'a' + (nibble-10);
+    } else {
+        *p++ = '0' + nibble;
+    }
+    nibble = n & 0xf;
+    if (nibble >= 10) {
+        *p++ = 'a' + (nibble-10);
+    } else {
+        *p++ = '0' + nibble;
+    }
+    *p = '\0';
+}
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void NoteMD5Init(NoteMD5Context *ctx)
+{
+    memset(ctx, 0, sizeof(NoteMD5Context));
+
+    ctx->buf[0] = 0x67452301;
+    ctx->buf[1] = 0xefcdab89;
+    ctx->buf[2] = 0x98badcfe;
+    ctx->buf[3] = 0x10325476;
+
+    ctx->bits[0] = 0;
+    ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void NoteMD5Update(NoteMD5Context *ctx, unsigned char const *buf, unsigned long len)
+{
+    unsigned long t;
+
+    /* Update bitcount */
+
+    t = ctx->bits[0];
+    if ((ctx->bits[0] = (t + ((unsigned long)len << 3)) & 0xffffffff) < t) {
+        ctx->bits[1]++;    /* Carry from low to high */
+    }
+    ctx->bits[1] += len >> 29;
+
+    t = (t >> 3) & 0x3f;  /* Bytes already in shsInfo->data */
+
+    /* Handle any leading odd-sized chunks */
+
+    if ( t ) {
+        unsigned char *p = ctx->in + t;
+
+        t = 64-t;
+        if (len < t) {
+            memcpy(p, buf, len);
+            return;
+        }
+        memcpy(p, buf, t);
+        NoteMD5Transform(ctx->buf, ctx->in);
+        buf += t;
+        len -= t;
+    }
+
+    /* Process data in 64-byte chunks */
+
+    while (len >= 64) {
+        memcpy(ctx->in, buf, 64);
+        NoteMD5Transform(ctx->buf, ctx->in);
+        buf += 64;
+        len -= 64;
+    }
+
+    /* Handle any remaining bytes of data. */
+
+    memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void NoteMD5Final(unsigned char *digest, NoteMD5Context *ctx)
+{
+    unsigned count;
+    unsigned char *p;
+
+    /* Compute number of bytes mod 64 */
+    count = (ctx->bits[0] >> 3) & 0x3F;
+
+    /* Set the first char of padding to 0x80.  This is safe since there is
+       always at least one byte free */
+    p = ctx->in + count;
+    *p++ = 0x80;
+
+    /* Bytes of padding needed to make 64 bytes */
+    count = 64 - 1 - count;
+
+    /* Pad out to 56 mod 64 */
+    if (count < 8) {
+        /* Two lots of padding:  Pad the first block to 64 bytes */
+        memset(p, 0, count);
+        NoteMD5Transform(ctx->buf, ctx->in);
+
+        /* Now fill the next block with 56 bytes */
+        memset(ctx->in, 0, 56);
+    } else {
+        /* Pad block to 56 bytes */
+        memset(p, 0, count-8);
+    }
+
+    /* Append length in bits and transform */
+    putu32(ctx->bits[0], ctx->in + 56);
+    putu32(ctx->bits[1], ctx->in + 60);
+
+    NoteMD5Transform(ctx->buf, ctx->in);
+    putu32(ctx->buf[0], digest);
+    putu32(ctx->buf[1], digest + 4);
+    putu32(ctx->buf[2], digest + 8);
+    putu32(ctx->buf[3], digest + 12);
+    memset(ctx, 0, sizeof(NoteMD5Context)); /* In case it's sensitive */
+}
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+  ( w += f(x, y, z) + data, w &= 0xffffffff, w = w<<s | w>>(32-s), w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  NoteMD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void NoteMD5Transform(unsigned long buf[4], const unsigned char inraw[64])
+{
+    register unsigned long a, b, c, d;
+    unsigned long in[16];
+    int i;
+
+    for (i = 0; i < 16; ++i) {
+        in[i] = getu32 (inraw + 4 * i);
+    }
+
+    a = buf[0];
+    b = buf[1];
+    c = buf[2];
+    d = buf[3];
+
+    MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
+    MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
+    MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
+    MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
+    MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
+    MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
+    MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
+    MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
+    MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
+    MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
+    MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
+    MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
+    MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
+    MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
+    MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
+    MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
+
+    MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
+    MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
+    MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
+    MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
+    MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
+    MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
+    MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
+    MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
+    MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
+    MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
+    MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
+    MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
+    MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
+    MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
+    MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
+    MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
+
+    MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
+    MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
+    MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
+    MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
+    MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
+    MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
+    MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
+    MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
+    MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
+    MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
+    MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
+    MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
+    MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
+    MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
+    MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
+    MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
+
+    MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
+    MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
+    MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
+    MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
+    MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
+    MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
+    MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
+    MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
+    MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
+    MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
+    MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
+    MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
+    MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
+    MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
+    MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
+    MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
+
+    buf[0] += a;
+    buf[1] += b;
+    buf[2] += c;
+    buf[3] += d;
+
+}
+
+// Hash data and return its binary hash into an NOTE_MD5_HASH_SIZE buffer
+void NoteMD5Hash(unsigned char* data, unsigned long len, unsigned char *retHash)
+{
+    NoteMD5Context context;
+    NoteMD5Init(&context);
+    NoteMD5Update(&context, data, len);
+    NoteMD5Final(retHash, &context);
+}
+
+// Hash data and return it as a string into a buffer that is at least (16*2)+1 in length
+void NoteMD5HashString(unsigned char *data, unsigned long len, char *strbuf, unsigned long buflen)
+{
+    unsigned char hash[NOTE_MD5_HASH_SIZE];
+    NoteMD5Hash(data, len, hash);
+    char hashstr[NOTE_MD5_HASH_SIZE*3] = {0};
+    for (int i=0; i<NOTE_MD5_HASH_SIZE; i++) {
+        n_htoa8(hash[i], (unsigned char *)&hashstr[i*2]);
+    }
+    hashstr[NOTE_MD5_HASH_SIZE*2+1] = 0;
+    strlcpy(strbuf, hashstr, buflen);
+}
+
+// Convert a hash to string
+void NoteMD5HashToString(unsigned char *hash, char *strbuf, unsigned long buflen)
+{
+    char hashstr[NOTE_MD5_HASH_SIZE*3] = {0};
+    for (int i=0; i<NOTE_MD5_HASH_SIZE; i++) {
+        n_htoa8(hash[i], (unsigned char *)&hashstr[i*2]);
+    }
+    strlcpy(strbuf, hashstr, buflen);
+}
diff --git a/src/note-c/n_printf.c b/src/note-c/n_printf.c
new file mode 100644
index 0000000..6c95df4
--- /dev/null
+++ b/src/note-c/n_printf.c
@@ -0,0 +1,66 @@
+/*!
+ * @file n_printf.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include "n_lib.h"
+
+// Externalized Hooks
+//**************************************************************************/
+/*!
+  @brief  Hook for the calling platform's debug interface, if any.
+*/
+/**************************************************************************/
+extern debugOutputFn hookDebugOutput;
+
+//**************************************************************************/
+/*!
+  @brief  Write a formatted string to the debug output.
+  @param   format  A format string for output.
+  @param   ...  One or more values to interpolate into the format string.
+*/
+/**************************************************************************/
+void NoteDebugf(const char *format, ...)
+{
+#ifndef NOTE_NODEBUG
+    if (hookDebugOutput != NULL) {
+        char line[256];
+        va_list args;
+        va_start(args, format);
+        vsnprintf(line, sizeof(line), format, args);
+        va_end(args);
+        hookDebugOutput(line);
+    }
+#endif
+}
+
+//**************************************************************************/
+/*!
+  @brief  Write a formatted string to the debug output.
+  @param   format  A format string for output.
+  @param   ...  One or more values to interpolate into the format string.
+  @note.  Do NOT use this in a memory-constrained environment (vsnprintf is large)
+*/
+/**************************************************************************/
+#ifndef NOTE_LOMEM
+bool NotePrintf(const char *format, ...)
+{
+    char line[256];
+    va_list args;
+    va_start(args, format);
+    vsnprintf(line, sizeof(line), format, args);
+    va_end(args);
+    return NotePrint(line);
+}
+#endif
diff --git a/src/note-c/n_request.c b/src/note-c/n_request.c
new file mode 100644
index 0000000..9226d17
--- /dev/null
+++ b/src/note-c/n_request.c
@@ -0,0 +1,954 @@
+/*!
+ @file n_request.c
+
+ Written by Ray Ozzie and Blues Inc. team.
+
+ Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ governed by licenses granted by the copyright holder including that found in
+ the
+ <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ file.
+ */
+
+#include "n_lib.h"
+
+#ifdef NOTE_C_TEST
+#include "test_static.h"
+#else
+#define NOTE_C_STATIC static
+#endif
+
+// For flow tracing
+static int suppressShowTransactions = 0;
+
+// Flag that gets set whenever an error occurs that should force a reset
+static bool resetRequired = true;
+
+// CRC data
+#ifndef NOTE_C_LOW_MEM
+static uint16_t lastRequestSeqno = 0;
+#define CRC_FIELD_LENGTH        22  // ,"crc":"SSSS:CCCCCCCC"
+#define CRC_FIELD_NAME_OFFSET   1
+#define CRC_FIELD_NAME_TEST     "\"crc\":\""
+NOTE_C_STATIC int32_t crc32(const void* data, size_t length);
+NOTE_C_STATIC char * crcAdd(char *json, uint16_t seqno);
+NOTE_C_STATIC bool crcError(char *json, uint16_t shouldBeSeqno);
+
+static bool notecardSupportsCrc = false;
+#endif
+
+/*!
+ @internal
+
+ @brief Create a JSON object containing an error message.
+
+ Create a dynamically allocated `J` object containing a single string field
+ "err" whose value is the passed in error message.
+
+ @param id The "id" from the original request that resulted in an error
+ @param errmsg The error message.
+
+ @returns A `J` object with the "err" field populated.
+ */
+NOTE_C_STATIC J * errDoc(uint32_t id, const char *errmsg)
+{
+    J *rspdoc = JCreateObject();
+    if (rspdoc != NULL) {
+        JAddStringToObject(rspdoc, c_err, errmsg);
+        JAddStringToObject(rspdoc, "src", "note-c");
+        if (id) {
+            JAddIntToObject(rspdoc, "id", id);
+        }
+        if (suppressShowTransactions == 0) {
+            _DebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, "[ERROR] ");
+            _DebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, "{\"err\":\"");
+            _DebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, errmsg);
+            _DebugWithLevelLn(NOTE_C_LOG_LEVEL_ERROR, "\",\"src\":\"note-c\"}");
+        }
+    }
+
+    return rspdoc;
+}
+
+/*!
+ @brief Suppress showing transaction details.
+ */
+void NoteSuspendTransactionDebug(void)
+{
+    suppressShowTransactions++;
+}
+
+/*!
+ @brief Resume showing transaction details.
+ */
+void NoteResumeTransactionDebug(void)
+{
+    suppressShowTransactions--;
+}
+
+/*!
+ @brief Create a new JSON request.
+
+ Creates a dynamically allocated `J` object with one field `"req"` whose value
+ is the passed in request string.
+
+ @param request The name of the request, for example `hub.set`.
+
+ @returns A `J` object with the "req" field populated.
+ */
+J *NoteNewRequest(const char *request)
+{
+    J *reqdoc = JCreateObject();
+    if (reqdoc != NULL) {
+        JAddStringToObject(reqdoc, c_req, request);
+    }
+    return reqdoc;
+}
+
+/*!
+ @brief Create a new JSON command.
+
+ Create a dynamically allocated `J` object with one field `"cmd"` whose value is
+ the passed in request string. The difference between a command and a request is
+ that the Notecard does not send a response to commands, only to requests.
+
+ @param request The name of the command (e.g. `card.attn`).
+
+ @returns A `J` object with the "cmd" field populated.
+
+ */
+J *NoteNewCommand(const char *request)
+{
+    J *reqdoc = JCreateObject();
+    if (reqdoc != NULL) {
+        JAddStringToObject(reqdoc, c_cmd, request);
+    }
+    return reqdoc;
+}
+
+/*!
+ @brief Send a request to the Notecard.
+
+ The passed in request object is always freed, regardless of if the request was
+ successful or not. The response from the Notecard, if any, is freed and not
+ returned to the caller.
+
+ @param req Pointer to a `J` request object.
+
+ @returns `true` if successful and `false` if an error occurs (e.g. out of
+          memory or the response from the Notecard has an "err" field). If req
+          is a command rather than a request, a `true` return value indicates
+          that the command was sent without error. However, since the Notecard
+          sends no response to commands, it does not guarantee that the
+          command was received and processed by the Notecard.
+
+ @see `NoteRequestResponse` if you need to work with the response.
+ */
+bool NoteRequest(J *req)
+{
+    J *rsp = NoteRequestResponse(req);
+    if (rsp == NULL) {
+        return false;
+    }
+
+    // Check for a transaction error, and exit
+    bool success = JIsNullString(rsp, c_err);
+    JDelete(rsp);
+
+    return success;
+}
+
+/*!
+ @brief Send a request to the Notecard, retrying it until it succeeds or it
+        times out.
+
+ The passed in request object is always freed, regardless of if the request was
+ successful or not. The response from the Notecard, if any, is freed and not
+ returned to the caller.
+
+ @param req Pointer to a `J` request object.
+ @param timeoutSeconds Time limit for retires, in seconds, if there is no
+        response, or if the response contains an I/O error.
+
+ @returns `true` if successful and `false` if an error occurs (e.g. out of
+          memory or the response from the Notecard has an "err" field).
+
+ @see `NoteRequestResponseWithRetry` if you need to work with the response.
+ */
+bool NoteRequestWithRetry(J *req, uint32_t timeoutSeconds)
+{
+    J *rsp = NoteRequestResponseWithRetry(req, timeoutSeconds);
+    // If there is no response return false
+    if (rsp == NULL) {
+        return false;
+    }
+
+    // Check for a transaction error, and exit
+    bool success = JIsNullString(rsp, c_err);
+    JDelete(rsp);
+
+    return success;
+}
+
+/*!
+ @brief Send a request to the Notecard and return the response.
+
+ The passed in request object is always freed, regardless of if the request was
+ successful or not.
+
+ @param req Pointer to a `J` request object.
+
+ @returns A `J` object with the response or NULL if there was an error sending
+          the request.
+
+ @see `NoteResponseError` to check the response for errors.
+ */
+J *NoteRequestResponse(J *req)
+{
+    // Exit if null request. This allows safe execution of the form
+    // NoteRequestResponse(NoteNewRequest("xxx"))
+    if (req == NULL) {
+        return NULL;
+    }
+    // Execute the transaction
+    J *rsp = NoteTransaction(req);
+    if (rsp == NULL) {
+        JDelete(req);
+        return NULL;
+    }
+    // Free the request and exit
+    JDelete(req);
+    return rsp;
+}
+
+/*!
+ @brief Send a request to the Notecard, retrying it until it succeeds or it
+        times out, and return the response.
+
+ The passed in request object is always freed, regardless of if the request was
+ successful or not.
+
+ @param req Pointer to a `J` request object.
+ @param timeoutSeconds Time limit for retires, in seconds, if there is no
+        response, or if the response contains an I/O error.
+
+ @returns A `J` object with the response or NULL if there was an error sending
+          the request.
+
+ @see `NoteResponseError` to check the response for errors.
+ */
+J *NoteRequestResponseWithRetry(J *req, uint32_t timeoutSeconds)
+{
+    // Exit if null request. This allows safe execution of the form
+    // NoteRequestResponse(NoteNewRequest("xxx"))
+    if (req == NULL) {
+        return NULL;
+    }
+
+    J *rsp;
+
+    // Calculate expiry time in milliseconds
+    uint32_t startMs = _GetMs();
+    uint32_t timeoutMs = timeoutSeconds * 1000;
+
+    while(true) {
+        // Execute the transaction
+        rsp = NoteTransaction(req);
+
+        // Loop if there is no response, or if there is an io error
+        if ((rsp == NULL) || (JContainsString(rsp, c_err, c_ioerr) && !JContainsString(rsp, c_err, c_unsupported))) {
+
+            // Free error response
+            if (rsp != NULL) {
+                JDelete(rsp);
+                rsp = NULL;
+            }
+        } else {
+
+            // Exit loop on non-null response without io error
+            break;
+        }
+
+        // Exit loop on timeout
+        if (_GetMs() - startMs >= timeoutMs) {
+            break;
+        }
+    }
+
+    // Free the request
+    JDelete(req);
+
+    // Return the response
+    return rsp;
+}
+
+/*!
+ @brief Send a request to the Notecard and return the response.
+
+ Unlike `NoteRequestResponse`, this function expects the request to be a valid
+ JSON C-string, rather than a `J` object. The string is expected to be
+ newline-terminated, otherwise the call produces undefined behavior. The
+ response is returned as a dynamically allocated JSON C-string. The response
+ string is verbatim what was sent by the Notecard, which IS newline-terminated.
+ The caller is responsible for freeing the response string. If the request was a
+ command (i.e. it uses "cmd" instead of "req"), this function returns NULL,
+ because the Notecard does not send a response to commands.
+
+ @param reqJSON A valid newline-terminated JSON C-string containing the request.
+
+ @returns A newline-terminated JSON C-string with the response, or NULL
+          if there was no response or if there was an error.
+
+ @note When a "cmd" is sent, it is not possible to determine if an error occurred.
+*/
+char * NoteRequestResponseJSON(const char *reqJSON)
+{
+    uint32_t transactionTimeoutMs = (CARD_INTER_TRANSACTION_TIMEOUT_SEC * 1000);
+    char *rspJSON = NULL;
+
+    if (reqJSON == NULL) {
+        return NULL;
+    }
+
+    // Make sure that we get access to the Notecard before transacting.
+    if (!_TransactionStart(transactionTimeoutMs)) {
+        return NULL;
+    }
+
+    _LockNote();
+
+    // Manually tokenize the string to search for multiple embedded commands (cannot use strtok)
+    for (;;) {
+        const char *endPtr;
+        const char * const newlinePtr = strchr(reqJSON, '\n');
+
+        // If string is not newline-terminated, then allocate a new string and terminate it
+        if (NULL == newlinePtr) {
+            // All JSON strings should be newline-terminated to meet the specification, however
+            // this is required to ensure backward compatibility with the previous implementation.
+            const size_t tempLen = strlen(reqJSON);
+            if (0 == tempLen) {
+                NOTE_C_LOG_ERROR(ERRSTR("request: jsonbuf zero length", c_bad));
+                break;
+            }
+
+            NOTE_C_LOG_WARN(ERRSTR("Memory allocation due to malformed request (not newline-terminated)", c_bad));
+            char * const temp = _Malloc(tempLen + 2);  // +2 for newline and null-terminator
+            if (temp == NULL) {
+                NOTE_C_LOG_ERROR(ERRSTR("request: jsonbuf malloc failed", c_mem));
+                break;
+            }
+
+            memcpy(temp, reqJSON, tempLen);
+            temp[tempLen] = '\n';
+            temp[tempLen + 1] = '\0';
+            reqJSON = temp;
+            endPtr = &temp[tempLen];
+        } else {
+            endPtr = newlinePtr;
+        }
+        const size_t reqLen = ((endPtr - reqJSON) + 1);
+
+        bool isCmd = false;
+        if (strstr(reqJSON, "\"cmd\":") != NULL) {
+            // Only call `JParse()` after verifying the provided request
+            // appears to contain a command (i.e. we find `"cmd":`).
+            J *jsonObj = JParse(reqJSON);
+            if (!jsonObj) {
+                // Invalid JSON.
+                if (NULL == newlinePtr) {
+                    _Free((void *)reqJSON);
+                }
+                break;
+            }
+            isCmd = JIsPresent(jsonObj, "cmd");
+            JDelete(jsonObj);
+        }
+
+        if (!isCmd) {
+            const char *errstr = _Transaction(reqJSON, reqLen, &rspJSON, transactionTimeoutMs);
+            if (errstr != NULL) {
+                NOTE_C_LOG_ERROR(errstr);
+                uint32_t id = 0;
+                if (reqJSON != NULL) {
+                    J *req = JParse(reqJSON);
+                    if (req != NULL) {
+                        id = JGetInt(req, "id");
+                        JDelete(req);
+                    }
+                }
+                J *errdoc = errDoc(id, errstr);
+                if (errdoc != NULL) {
+                    char *errdocJSON = JPrintUnformatted(errdoc);
+                    JDelete(errdoc);
+                    if (errdocJSON != NULL) {
+                        uint32_t errdocJSONLen = strlen(errdocJSON);
+                        rspJSON = (char *) _Malloc(errdocJSONLen+2);
+                        if (rspJSON != NULL) {
+                            memcpy(rspJSON, errdocJSON, errdocJSONLen);
+                            rspJSON[errdocJSONLen++] = '\n';
+                            rspJSON[errdocJSONLen] = '\0';
+                        }
+                        _Free((void *)errdocJSON);
+                    }
+                }
+            }
+            if (NULL == newlinePtr) {
+                _Free((void *)reqJSON);
+            }
+            break;
+        } else {
+            // If it's a command, the Notecard will not respond, so we pass NULL for
+            // the response parameter.
+            const char *errstr = _Transaction(reqJSON, reqLen, NULL, transactionTimeoutMs);
+            reqJSON = (endPtr + 1);
+            if (errstr != NULL) {
+                NOTE_C_LOG_ERROR(errstr);
+            }
+        }
+
+        // Clean up if we allocated a new string
+        if (NULL == newlinePtr) {
+            _Free((void *)reqJSON);
+        }
+    }
+
+    _UnlockNote();
+    _TransactionStop();
+
+    return rspJSON;
+}
+
+/*!
+ @brief Send a request to the Notecard and return the response.
+
+ This function doesn't free the passed in request object. The caller is
+ responsible for freeing it.
+
+ @param req Pointer to a `J` request object.
+
+ @returns A `J` object with the response or NULL if there was an error sending
+          the request.
+
+ @see `NoteResponseError` to check the response for errors.
+ */
+J *NoteTransaction(J *req)
+{
+    return noteTransactionShouldLock(req, true);
+}
+
+/**************************************************************************/
+/*!
+  @brief Same as `NoteTransaction`, but takes an additional parameter that
+  indicates if the Notecard should be locked.
+  @param   req
+  The `J` cJSON request object.
+  @param   lockNotecard
+  Set to `true` if the Notecard should be locked and `false` otherwise.
+  @returns a `J` cJSON object with the response, or NULL if there is
+  insufficient memory.
+*/
+/**************************************************************************/
+J *noteTransactionShouldLock(J *req, bool lockNotecard)
+{
+    // Validate in case of memory failure of the requestor
+    if (req == NULL) {
+        return NULL;
+    }
+
+    // Make sure that we get access to the notecard hardware before we begin
+    if (!_TransactionStart(CARD_INTER_TRANSACTION_TIMEOUT_SEC * 1000)) {
+        return NULL;
+    }
+
+    // Determine the request or command type
+    const char *reqType = JGetString(req, "req");
+    const char *cmdType = JGetString(req, "cmd");
+
+    // Add the user agent object only when we're doing a hub.set and only when we're
+    // specifying the product UID.  The intent is that we only piggyback user agent
+    // data when the host is initializing the Notecard, as opposed to every time
+    // the host does a hub.set to change mode.
+#ifndef NOTE_DISABLE_USER_AGENT
+    if (!JIsPresent(req, "body") && (strcmp(reqType, "hub.set") == 0) && JIsPresent(req, "product")) {
+        J *body = NoteUserAgent();
+        if (body != NULL) {
+            JAddItemToObject(req, "body", body);
+        }
+    }
+#endif
+
+    // Determine whether or not a response will be expected, by virtue of "cmd" being present
+    bool noResponseExpected = (reqType[0] == '\0' && cmdType[0] != '\0');
+
+    // If a reset of the module is required for any reason, do it now.
+    // We must do this before acquiring lock.
+    if (resetRequired) {
+        if (!NoteReset()) {
+            _TransactionStop();
+            return NULL;
+        }
+    }
+
+    if (lockNotecard) {
+        _LockNote();
+    }
+
+    // Extract the ID of the request so that errors can be returned with the same ID
+    uint32_t id = JGetInt(req, "id");
+
+    // Serialize the JSON request
+    char *json = JPrintUnformatted(req);
+    if (json == NULL) {
+        J *errRsp = errDoc(id, ERRSTR("can't convert to JSON", c_bad));
+        if (lockNotecard) {
+            _UnlockNote();
+        }
+        _TransactionStop();
+        return errRsp;
+    }
+
+    // If it is a request (as opposed to a command), include a CRC so that the
+    // request might be retried if it is received in a corrupted state.  (We can
+    // only do this on requests because for cmd's there is no 'response channel'
+    // where we can find out that the cmd failed.  Note that a Seqno is included
+    // as part of the CRC data so that two identical requests occurring within the
+    // modulus of seqno never are mistaken as being the same request being retried.
+    uint8_t lastRequestRetries = 0;
+#ifndef NOTE_C_LOW_MEM
+    bool lastRequestCrcAdded = false;
+    if (!noResponseExpected) {
+        char *newJson = crcAdd(json, lastRequestSeqno);
+        if (newJson != NULL) {
+            JFree(json);
+            json = newJson;
+            lastRequestCrcAdded = true;
+        }
+    }
+#endif // !NOTE_C_LOW_MEM
+
+    // When note.add or web.* requests are used to transfer binary data, the
+    // time to complete the transaction can vary depending on the size of
+    // the payload and network conditions. Therefore, it's possible for
+    // these transactions to timeout prematurely.
+    //
+    // The algorithm below, executes the following logic:
+    //   - If the request is a `note.add`, set the timeout value to the
+    //     value of the "milliseconds" parameter, if it exists. If it
+    //     doesn't, use the "seconds" parameter. If that doesn't exist,
+    //     use the standard timeout of `CARD_INTER_TRANSACTION_TIMEOUT_SEC`.
+    //   - If the request is a `web.*`, follow the same logic, but instead
+    //     of using the standard timeout, use the Notecard timeout of 90
+    //     seconds for all `web.*` transactions.
+    uint32_t transactionTimeoutMs = (CARD_INTER_TRANSACTION_TIMEOUT_SEC * 1000);
+
+    // Interrogate the request
+    if (JContainsString(req, (reqType ? "req" : "cmd"), "note.add")) {
+        if (JIsPresent(req, "milliseconds")) {
+            NOTE_C_LOG_DEBUG("Using `milliseconds` parameter value for "
+                             "timeout.");
+            transactionTimeoutMs = JGetInt(req, "milliseconds");
+        } else if (JIsPresent(req, "seconds")) {
+            NOTE_C_LOG_DEBUG("Using `seconds` parameter value for timeout.");
+            transactionTimeoutMs = (JGetInt(req, "seconds") * 1000);
+        }
+    } else if (JContainsString(req, (reqType ? "req" : "cmd"), "web.")) {
+        NOTE_C_LOG_DEBUG("web.* request received.");
+        if (JIsPresent(req, "milliseconds")) {
+            NOTE_C_LOG_DEBUG("Using `milliseconds` parameter value for "
+                             "timeout.");
+            transactionTimeoutMs = JGetInt(req, "milliseconds");
+        } else if (JIsPresent(req, "seconds")) {
+            NOTE_C_LOG_DEBUG("Using `seconds` parameter value for timeout.");
+            transactionTimeoutMs = (JGetInt(req, "seconds") * 1000);
+        } else {
+            NOTE_C_LOG_DEBUG("No `milliseconds` or `seconds` parameter "
+                             "provided. Defaulting to 90-second timeout.");
+            transactionTimeoutMs = (90 * 1000);
+        }
+    }
+
+    // If we're performing retries, this is where we come back to
+    const char *errStr = NULL;
+    char *responseJSON = NULL;
+    J *rsp = NULL;
+    while (true) {
+        // If no retry possibility, break out
+        if (lastRequestRetries > CARD_REQUEST_RETRIES_ALLOWED) {
+            break;
+        } else {
+            // free on retry
+            JDelete(rsp);
+        }
+
+        // reset variables
+        rsp = NULL;
+        responseJSON = NULL;
+
+        // Trace
+        if (suppressShowTransactions == 0) {
+            NOTE_C_LOG_INFO(json);
+        }
+
+        // Swap NULL-terminator for newline-terminator
+        const size_t jsonLen = strlen(json);
+        json[jsonLen] = '\n';
+
+        // Perform the transaction
+        if (noResponseExpected) {
+            errStr = _Transaction(json, (jsonLen + 1), NULL, transactionTimeoutMs);
+            break;
+        }
+        errStr = _Transaction(json, (jsonLen + 1), &responseJSON, transactionTimeoutMs);
+
+        // Swap newline-terminator for NULL-terminator
+        json[jsonLen] = '\0';
+
+        // If there's an I/O error on the transaction, retry
+        if (errStr != NULL) {
+            JFree(responseJSON);
+            resetRequired = !_Reset();
+            lastRequestRetries++;
+            NOTE_C_LOG_WARN(ERRSTR("retrying I/O error detected by host", c_iobad));
+            _DelayMs(500);
+            continue;
+        }
+
+#ifndef NOTE_C_LOW_MEM
+        // If we sent a CRC in the request, examine the response JSON to see if
+        // it has a CRC error.  Note that the CRC is stripped from the
+        // responseJSON as a side-effect of this method.
+        if (lastRequestCrcAdded && crcError(responseJSON, lastRequestSeqno)) {
+            JFree(responseJSON);
+            errStr = "crc error {io}";
+            lastRequestRetries++;
+            NOTE_C_LOG_ERROR(ERRSTR("CRC error on response", c_iobad));
+            _DelayMs(500);
+            continue;
+        }
+#endif // !NOTE_C_LOW_MEM
+
+        // See if the response JSON can't be unmarshaled, or if it contains an {io} error
+        rsp = JParse(responseJSON);
+        bool isBadBin = false;
+        bool isIoError = false;
+        if (rsp != NULL) {
+            isBadBin = JContainsString(rsp, c_err, c_badbinerr);
+            isIoError = JContainsString(rsp, c_err, c_ioerr) && !JContainsString(rsp, c_err, c_unsupported);
+        } else {
+            // Failed to parse response as JSON
+            if (responseJSON == NULL) {
+                NOTE_C_LOG_ERROR(ERRSTR("response expected, but response is NULL.", c_ioerr));
+            } else {
+#ifndef NOTE_C_LOW_MEM
+                _DebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, "[ERROR] ");
+                _DebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, "invalid JSON: ");
+                _DebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, responseJSON);
+#else
+                NOTE_C_LOG_ERROR(c_ioerr);
+#endif
+            }
+            isIoError = true;
+        }
+        if (isIoError || isBadBin) {
+            NOTE_C_LOG_ERROR(JGetString(rsp, c_err));
+            JFree(responseJSON);
+
+            if (isBadBin) {
+                errStr = ERRSTR("notecard binary i/o error {bad-bin}{io}", c_badbinerr);
+                NOTE_C_LOG_DEBUG("{bad-bin} is not elibigle for retry");
+                break;
+            } else {
+                errStr = ERRSTR("notecard i/o error {io}", c_ioerr);
+                lastRequestRetries++;
+                NOTE_C_LOG_WARN(ERRSTR("retrying I/O error detected by notecard", c_iobad));
+                _DelayMs(500);
+                continue;
+            }
+        }
+
+        // Transaction completed
+        break;
+    }
+
+    // Bump the request sequence number now that we've processed this request, success or error
+#ifndef NOTE_C_LOW_MEM
+    lastRequestSeqno++;
+#endif
+
+    // Free the original serialized JSON request
+    JFree(json);
+
+    // If error, queue up a reset
+    if (errStr != NULL) {
+        JDelete(rsp);
+        NoteResetRequired();
+        J *errRsp = errDoc(id, errStr);
+        if (lockNotecard) {
+            _UnlockNote();
+        }
+        _TransactionStop();
+        return errRsp;
+    }
+
+    // Exit with a blank object (with no err field) if no response expected
+    if (noResponseExpected) {
+        if (lockNotecard) {
+            _UnlockNote();
+        }
+        _TransactionStop();
+        return JCreateObject();
+    }
+
+    // Debug
+    if (suppressShowTransactions == 0) {
+        NOTE_C_LOG_INFO(responseJSON);
+    }
+
+    // Discard the buffer now that it has been logged
+    JFree(responseJSON);
+
+    if (lockNotecard) {
+        _UnlockNote();
+    }
+
+    _TransactionStop();
+
+    // Done
+    return rsp;
+
+}
+
+/*!
+ @brief Mark that a reset will be required before doing further I/O on a given
+        port.
+ */
+void NoteResetRequired(void)
+{
+    resetRequired = true;
+}
+
+/*!
+ @brief Initialize or re-initialize the module.
+
+ @returns True if the reset was successful and false if not.
+ */
+bool NoteReset(void)
+{
+    _LockNote();
+    resetRequired = !_Reset();
+    _UnlockNote();
+    return !resetRequired;
+}
+
+/*!
+ @brief Check to see if a Notecard error is present in a JSON string.
+
+ Only Notecard errors enclosed in `{}` (e.g. `{io}` for an I/O error) are
+ guaranteed by the API.
+
+ @param errstr The string to check for errors.
+ @param errtype The error substring to search for in errstr.
+
+ @returns `true` if errstr contains errtype and `false` otherwise.
+ */
+bool NoteErrorContains(const char *errstr, const char *errtype)
+{
+    return (strstr(errstr, errtype) != NULL);
+}
+
+/*!
+ @brief Clean error strings out of the specified buffer.
+
+ Notecard errors are enclosed in {} (e.g. {io} for an I/O error). This
+ function takes the input string and removes all errors from it, meaning it
+ removes any substrings matching the pattern {some error string}, including the
+ braces.
+
+ @param begin A C-string to to clean of errors.
+ */
+void NoteErrorClean(char *begin)
+{
+    while (true) {
+        char *end = &begin[strlen(begin)+1];
+        char *beginBrace = strchr(begin, '{');
+        if (beginBrace == NULL) {
+            break;
+        }
+        if (beginBrace>begin && *(beginBrace-1) == ' ') {
+            beginBrace--;
+        }
+        char *endBrace = strchr(beginBrace, '}');
+        if (endBrace == NULL) {
+            break;
+        }
+        char *afterBrace = endBrace + 1;
+        memmove(beginBrace, afterBrace, end-afterBrace);
+    }
+}
+
+#ifndef NOTE_C_LOW_MEM
+
+/*!
+ @brief Convert a hex string to a 64-bit unsigned integer.
+
+ @param p The hex string to convert.
+ @param maxLen The length of the hex string.
+
+ @returns The converted number.
+ */
+uint64_t n_atoh(char *p, int maxLen)
+{
+    uint64_t n = 0;
+    char *ep = p+maxLen;
+    while (p < ep) {
+        char ch = *p++;
+        bool digit = (ch >= '0' && ch <= '9');
+        bool lcase = (ch >= 'a' && ch <= 'f');
+        bool space = (ch == ' ');
+        bool ucase = (ch >= 'A' && ch <= 'F');
+        if (!digit && !lcase && !space && !ucase) {
+            break;
+        }
+        n *= 16;
+        if (digit) {
+            n += ch - '0';
+        } else if (lcase) {
+            n += 10 + (ch - 'a');
+        } else if (ucase) {
+            n += 10 + (ch - 'A');
+        }
+    }
+    return (n);
+}
+
+static uint32_t lut[16] = {
+    0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC, 0x76DC4190, 0x6B6B51F4,
+    0x4DB26158, 0x5005713C, 0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C,
+    0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C
+};
+
+/*!
+ @brief Compute the CRC32 of the passed in buffer.
+
+ Small lookup-table half-byte CRC32 algorithm. See
+ https://create.stephan-brumme.com/crc32/#half-byte
+
+ @param data The buffer.
+ @param length The length of the buffer.
+
+ @returns The CRC32 of the buffer.
+ */
+NOTE_C_STATIC int32_t crc32(const void* data, size_t length)
+{
+    uint32_t previousCrc32 = 0;
+    uint32_t crc = ~previousCrc32;
+    unsigned char* current = (unsigned char*) data;
+    while (length--) {
+        crc = lut[(crc ^  *current      ) & 0x0F] ^ (crc >> 4);
+        crc = lut[(crc ^ (*current >> 4)) & 0x0F] ^ (crc >> 4);
+        current++;
+    }
+    return ~crc;
+}
+
+/*!
+ @brief Append a "crc" field to the passed in JSON buffer.
+
+ The "crc" field has a value of the form "SSSS:CCCCCCCC", where SSSS is the
+ passed in sequence number and CCCCCCCC is the CRC32.
+
+ @param json The JSON buffer to both add the CRC32 to and to compute the
+        CRC32 over.
+ @param seqno A 16-bit sequence number to include as a part of the CRC.
+
+ @returns A dynamically-allocated version of the passed in buffer with the CRC
+          field added or NULL on error.
+ */
+NOTE_C_STATIC char *crcAdd(char *json, uint16_t seqno)
+{
+
+    // Allocate a block the size of the input json plus the size of
+    // the field to be added.  Note that the input JSON ends in '"}' and
+    // this will be replaced with a combination of 4 hex digits of the
+    // seqno plus 8 hex digits of the CRC32, and the '}' will be
+    // transformed into ',"crc":"SSSS:CCCCCCCC"}' where SSSS is the
+    // seqno and CCCCCCCC is the crc32.  Note that the comma is
+    // replaced with a space if the input json doesn't contain
+    // any fields, so that we always return compliant JSON.
+    size_t jsonLen = strlen(json);
+    // Minimum JSON is "{}" and must end with a closing "}".
+    if (jsonLen < 2 || json[jsonLen-1] != '}') {
+        return NULL;
+    }
+    char *newJson = (char *) _Malloc(jsonLen+CRC_FIELD_LENGTH+1);
+    if (newJson == NULL) {
+        return NULL;
+    }
+    bool isEmptyObject = (memchr(json, ':', jsonLen) == NULL);
+    size_t newJsonLen = jsonLen-1;
+    memcpy(newJson, json, newJsonLen);
+    newJson[newJsonLen++] = (isEmptyObject ? ' ' : ',');    // Replace }
+    newJson[newJsonLen++] = '"';                            // +1
+    newJson[newJsonLen++] = 'c';                            // +2
+    newJson[newJsonLen++] = 'r';                            // +3
+    newJson[newJsonLen++] = 'c';                            // +4
+    newJson[newJsonLen++] = '"';                            // +5
+    newJson[newJsonLen++] = ':';                            // +6
+    newJson[newJsonLen++] = '"';                            // +7
+    n_htoa16(seqno, (uint8_t *) &newJson[newJsonLen]);
+    newJsonLen += 4;                                        // +11
+    newJson[newJsonLen++] = ':';                            // +12
+    n_htoa32(crc32(json, jsonLen), &newJson[newJsonLen]);
+    newJsonLen += 8;                                        // +20
+    newJson[newJsonLen++] = '"';                            // +21
+    newJson[newJsonLen++] = '}';                            // +22 == CRC_FIELD_LENGTH
+    newJson[newJsonLen] = '\0';                             // null-terminated as it came in
+    return newJson;
+}
+
+/*!
+ @brief Check the passed in JSON for CRC and sequence number errors.
+
+ If the calculated CRC32 doesn't match what's in the buffer, that's an error. If
+ the sequence number in the buffer doesn't match shouldBeSeqno, that's an error.
+ If there is no CRC field in the buffer, that's not an error UNLESS this
+ function has been given a buffer with a CRC field before. In this case, the
+ lack of a CRC field is an error.
+
+ @param json The JSON buffer for which the CRC should be checked. Note that the
+        CRC is stripped from the input JSON regardless of whether or not there
+        was an error.
+ @param shouldBeSeqno The expected sequence number.
+
+ @returns `true` if there's an error and `false` otherwise.
+ */
+NOTE_C_STATIC bool crcError(char *json, uint16_t shouldBeSeqno)
+{
+    // Strip off any crlf for crc calculation
+    size_t jsonLen = strlen(json);
+    while (jsonLen > 0 && json[jsonLen-1] <= ' ') {
+        jsonLen--;
+    }
+    // Minimum valid JSON is "{}" (2 bytes) and must end with a closing "}".
+    if (jsonLen < CRC_FIELD_LENGTH+2 || json[jsonLen-1] != '}') {
+        return false;
+    }
+    // See if it has a compliant CRC field
+    size_t fieldOffset = ((jsonLen-1) - CRC_FIELD_LENGTH);
+    if (memcmp(&json[fieldOffset+CRC_FIELD_NAME_OFFSET], CRC_FIELD_NAME_TEST, sizeof(CRC_FIELD_NAME_TEST)-1) != 0) {
+        // If we've seen a CRC before, we should see one every time
+        return notecardSupportsCrc ? true : false;
+    }
+    // If we get here, we've seen at least one CRC from the Notecard, so we should expect it.
+    notecardSupportsCrc = true;
+    char *p = &json[fieldOffset + CRC_FIELD_NAME_OFFSET + (sizeof(CRC_FIELD_NAME_TEST)-1)];
+    uint16_t actualSeqno = (uint16_t) n_atoh(p, 4);
+    uint32_t actualCrc32 = (uint32_t) n_atoh(p+5, 8);
+    json[fieldOffset++] = '}';
+    json[fieldOffset] = '\0';
+    uint32_t shouldBeCrc32 = crc32(json, fieldOffset);
+    return (shouldBeSeqno != actualSeqno || shouldBeCrc32 != actualCrc32);
+}
+
+#endif // !NOTE_C_LOW_MEM
diff --git a/src/note-c/n_serial.c b/src/note-c/n_serial.c
new file mode 100644
index 0000000..ede4189
--- /dev/null
+++ b/src/note-c/n_serial.c
@@ -0,0 +1,316 @@
+/*!
+ * @file n_serial.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <stdlib.h>
+
+#include "n_lib.h"
+
+/**************************************************************************/
+/*!
+  @brief  Given a JSON string, perform a serial transaction with the Notecard.
+
+  @param   request A string containing the JSON request object, which MUST BE
+            terminated with a newline character.
+  @param   reqLen the string length of the JSON request.
+  @param   response [out] A c-string buffer that will contain the newline ('\n')
+            terminated JSON response from the Notercard. If NULL, no response
+            will be captured.
+  @param   timeoutMs The maximum amount of time, in milliseconds, to wait
+            for data to arrive. Passing zero (0) disables the timeout.
+
+  @returns a c-string with an error, or `NULL` if no error occurred.
+*/
+/**************************************************************************/
+const char *serialNoteTransaction(const char *request, size_t reqLen, char **response, uint32_t timeoutMs)
+{
+    // Strip off the newline and optional carriage return characters. This
+    // allows for standardized output to be reapplied.
+    reqLen--;  // remove newline
+    if (request[reqLen - 1] == '\r') {
+        reqLen--; // remove carriage return if it exists
+    }
+
+    const char *err = serialChunkedTransmit((uint8_t *)request, reqLen, true);
+    if (err) {
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Append the carriage return and newline to the transaction.
+    _SerialTransmit((uint8_t *)c_newline, c_newline_len, true);
+
+    // If no reply expected, we're done
+    if (response == NULL) {
+        return NULL;
+    }
+
+    // Wait for something to become available, processing timeout errors
+    // up-front because the json parse operation immediately following is
+    // subject to the serial port timeout. We'd like more flexibility in
+    // max timeout and ultimately in our error handling.
+    for (const uint32_t startMs = _GetMs(); !_SerialAvailable(); ) {
+        if (timeoutMs && (_GetMs() - startMs) >= timeoutMs) {
+            NOTE_C_LOG_DEBUG(ERRSTR("reply to request didn't arrive from module in time", c_iotimeout));
+            return ERRSTR("transaction timeout {io}", c_iotimeout);
+        }
+        if (!cardTurboIO) {
+            _DelayMs(10);
+        }
+    }
+
+    // Allocate a buffer for input, noting that we always put the +1 in the
+    // alloc so we can be assured that it can be null-terminated. This must be
+    // the case because json parsing requires a null-terminated string.
+    uint32_t available = 0;
+    uint32_t jsonbufAllocLen = ALLOC_CHUNK;
+    uint8_t *jsonbuf = (uint8_t *)_Malloc(jsonbufAllocLen + 1);
+    if (jsonbuf == NULL) {
+        const char *err = ERRSTR("transaction: jsonbuf malloc failed", c_mem);
+        NOTE_C_LOG_ERROR(err);
+        return err;
+    }
+
+    // Receive the Notecard response
+    uint32_t jsonbufLen = 0;
+    do {
+        uint32_t jsonbufAvailLen = (jsonbufAllocLen - jsonbufLen);
+
+        // Append into the json buffer
+        const char *err = serialChunkedReceive((uint8_t *)(jsonbuf + jsonbufLen), &jsonbufAvailLen, true, (CARD_INTRA_TRANSACTION_TIMEOUT_SEC * 1000), &available);
+        if (err) {
+            _Free(jsonbuf);
+            NOTE_C_LOG_ERROR(ERRSTR("error occured during receive", c_iobad));
+            return err;
+        }
+        jsonbufLen += jsonbufAvailLen;
+
+        if (available) {
+            // When more bytes are available than we have buffer to accommodate
+            // (i.e. overflow), then we allocate blocks of size `ALLOC_CHUNK` to
+            // reduce heap fragmentation.
+            // NOTE: We always put the +1 in the allocation so we can be assured
+            // that it can be null-terminated, because the json parser requires
+            // a null-terminated string.
+            jsonbufAllocLen += (ALLOC_CHUNK * ((available / ALLOC_CHUNK) + ((available % ALLOC_CHUNK) > 0)));
+            uint8_t *jsonbufNew = (uint8_t *)_Malloc(jsonbufAllocLen + 1);
+            if (jsonbufNew == NULL) {
+                const char *err = ERRSTR("transaction: jsonbuf grow malloc failed", c_mem);
+                NOTE_C_LOG_ERROR(err);
+                _Free(jsonbuf);
+                return err;
+            }
+            memcpy(jsonbufNew, jsonbuf, jsonbufLen);
+            _Free(jsonbuf);
+            jsonbuf = jsonbufNew;
+            NOTE_C_LOG_DEBUG("additional receive buffer chunk allocated");
+        }
+    } while (available);
+
+    // Null-terminate it, using the +1 space that we'd allocated in the buffer
+    jsonbuf[jsonbufLen] = '\0';
+
+    // Return it
+    *response = (char *)jsonbuf;
+    return NULL;
+}
+
+//**************************************************************************/
+/*!
+    @brief  Initialize or re-initialize the Serial bus, returning false if
+            anything fails.
+
+    @returns a boolean. `true` if the reset was successful, `false`, if not.
+*/
+/**************************************************************************/
+bool serialNoteReset(void)
+{
+    NOTE_C_LOG_DEBUG("resetting Serial interface...");
+
+    // Reset the Serial subsystem and exit if failure
+    _DelayMs(CARD_REQUEST_SERIAL_SEGMENT_DELAY_MS);
+    if (!_SerialReset()) {
+        NOTE_C_LOG_ERROR(ERRSTR("unable to reset Serial interface.", c_err));
+        return false;
+    }
+
+    // The guaranteed behavior for robust resyncing is to send two newlines
+    // and  wait for two echoed blank lines in return.
+    bool notecardReady = false;
+    for (size_t retries = 0; retries < CARD_RESET_SYNC_RETRIES ; ++retries) {
+
+        // Send a newline to the module to clean out request/response processing
+        // NOTE: This MUST always be `\n` and not `\r\n`, because there are some
+        //       versions of the Notecard firmware will not respond to `\r\n`
+        //       after communicating over I2C.
+        _SerialTransmit((uint8_t *)"\n", 1, true);
+
+        // Drain all communications for 500ms
+        bool somethingFound = false;
+        bool nonControlCharFound = false;
+
+        // Read Serial data for at least CARD_RESET_DRAIN_MS continously
+        for (uint32_t startMs = _GetMs() ; (_GetMs() - startMs) < CARD_RESET_DRAIN_MS ;) {
+            // Determine if Serial data is available
+            while (_SerialAvailable()) {
+                somethingFound = true;
+                // The Notecard responds to a bare `\n` with `\r\n`. If we get
+                // any other characters back, it means the host and Notecard
+                // aren't synced up yet and we need to transmit `\n` again.
+                char ch = _SerialReceive();
+                if (ch != '\n' && ch != '\r') {
+                    nonControlCharFound = true;
+                    // Reset the timer with each non-control character
+                    startMs = _GetMs();
+                }
+            }
+            _DelayMs(1);
+        }
+
+        // If all we got back is newlines, we're ready
+        if (somethingFound && !nonControlCharFound) {
+            notecardReady = true;
+            break;
+        }
+
+        NOTE_C_LOG_ERROR(somethingFound ? ERRSTR("unrecognized data from notecard", c_iobad) : ERRSTR("notecard not responding", c_iobad));
+
+        _DelayMs(CARD_RESET_DRAIN_MS);
+        if (!_SerialReset()) {
+            NOTE_C_LOG_ERROR(ERRSTR("unable to reset Serial interface.", c_err));
+            return false;
+        }
+
+        NOTE_C_LOG_DEBUG("retrying Serial interface reset.")
+    }
+
+    // Done
+    return notecardReady;
+}
+
+/**************************************************************************/
+/*!
+  @brief  Receive bytes over Serial from the Notecard.
+
+  @param   buffer A buffer to receive bytes into.
+  @param   size (in/out)
+            - (in) The size of the buffer in bytes.
+            - (out) The length of the received data in bytes.
+  @param   delay Respect standard processing delays.
+  @param   timeoutMs The maximum amount of time, in milliseconds, to wait for
+            serial data to arrive. Passing zero (0) disables the timeout.
+  @param   available (out) The amount of bytes unable to fit into the provided buffer.
+
+  @returns  A c-string with an error, or `NULL` if no error ocurred.
+*/
+/**************************************************************************/
+const char *serialChunkedReceive(uint8_t *buffer, uint32_t *size, bool delay, uint32_t timeoutMs, uint32_t *available)
+{
+    size_t received = 0;
+    bool overflow = (received >= *size);
+    uint32_t startMs = _GetMs();
+    for (bool eop = false ; !overflow && !eop ;) {
+        while (!_SerialAvailable()) {
+            if (timeoutMs && (_GetMs() - startMs >= timeoutMs)) {
+                *size = received;
+                if (received) {
+                    NOTE_C_LOG_ERROR(ERRSTR("received only partial reply before timeout", c_iobad));
+                }
+                return ERRSTR("timeout: transaction incomplete {io}",c_iotimeout);
+            }
+            // Yield while awaiting the first byte (lazy). After the first byte,
+            // start to spin for the remaining bytes (greedy).
+            if (delay && received == 0) {
+                _DelayMs(1);
+            }
+        }
+
+        // Once we've received any character, we will no longer wait patiently
+        timeoutMs = (CARD_INTRA_TRANSACTION_TIMEOUT_SEC * 1000);
+        startMs = _GetMs();
+
+        // Receive the next character
+        char ch = _SerialReceive();
+
+        // Place into the buffer
+        buffer[received++] = ch;
+
+        // Look for end-of-packet marker
+        eop = (ch == '\n');
+
+        // Check overflow condition
+        overflow = ((received >= *size) && !eop);
+        if (overflow) {
+            // We haven't received a newline, so we're not done with this
+            // packet. If the newline never comes, for whatever reason, when
+            // this function is called again, we'll timeout. We don't just
+            // use _SerialAvailable to set *available here because we're
+            // typically reading faster than the serial buffer fills, and so
+            // _SerialAvailable may return 0.
+            *available = 1;
+            break;
+        } else {
+            *available = 0;
+        }
+    }
+
+    // Return it
+    *size = received;
+    return NULL;
+}
+
+/**************************************************************************/
+/*!
+  @brief  Transmit bytes over serial to the Notecard.
+
+  @param   buffer A buffer of bytes to transmit.
+  @param   size The count of bytes in the buffer to send.
+  @param   delay Respect standard processing delays.
+
+  @returns  A c-string with an error, or `NULL` if no error ocurred.
+*/
+/**************************************************************************/
+const char *serialChunkedTransmit(uint8_t *buffer, uint32_t size, bool delay)
+{
+    // Transmit the request in segments so as not to overwhelm the Notecard's
+    // interrupt buffers
+    uint32_t segOff = 0;
+    uint32_t segLeft = size;
+
+    if (sizeof(size_t) != 4) { // Give the compiler a hint to eliminate the code
+        // Ensure truncation does not occur on 16-bit microcontrollers
+        const size_t castSize = (size_t)size;
+        if (castSize != size) {
+            const char *err = ERRSTR("Cannot transmit provided size; limit to `size_t`", c_iobad);
+            NOTE_C_LOG_ERROR(err);
+            return err;
+        }
+    }
+
+    while (true) {
+        size_t segLen = segLeft;
+        if (segLen > CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN) {
+            segLen = CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN;
+        }
+        _SerialTransmit(&buffer[segOff], segLen, false);
+        segOff += segLen;
+        segLeft -= segLen;
+        if (segLeft == 0) {
+            break;
+        }
+        if (delay) {
+            _DelayMs(CARD_REQUEST_SERIAL_SEGMENT_DELAY_MS);
+        }
+    }
+
+    return NULL;
+}
diff --git a/src/note-c/n_str.c b/src/note-c/n_str.c
new file mode 100644
index 0000000..5f4423b
--- /dev/null
+++ b/src/note-c/n_str.c
@@ -0,0 +1,99 @@
+/*!
+ * @file n_str.c
+ *
+ *      $OpenBSD: strlcpy.c,v 1.10 2005/08/08 08:05:37 espie Exp $
+ *      $OpenBSD: strlcat.c,v 1.12 2005/03/30 20:13:52 otto Exp $
+ *
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * 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.
+ */
+
+#include <string.h>
+#include "note.h"
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+#if defined(_MSC_VER)
+size_t strlcpy(char *dst, const char *src, size_t siz)
+#else
+__attribute__((weak)) size_t strlcpy(char *dst, const char *src, size_t siz)
+#endif
+{
+    char *d = dst;
+    const char *s = src;
+    size_t n = siz;
+
+    /* Copy as many bytes as will fit */
+    if (n != 0) {
+        while (--n != 0) {
+            if ((*d++ = *s++) == '\0') {
+                break;
+            }
+        }
+    }
+
+    /* Not enough room in dst, add NUL and traverse rest of src */
+    if (n == 0) {
+        if (siz != 0) {
+            *d = '\0';    /* NUL-terminate dst */
+        }
+        while (*s++)
+            ;
+    }
+
+    return(s - src - 1);    /* count does not include NUL */
+}
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+#if defined(_MSC_VER)
+size_t strlcat(char *dst, const char *src, size_t siz)
+#else
+__attribute__((weak)) size_t strlcat(char *dst, const char *src, size_t siz)
+#endif
+{
+    char *d = dst;
+    const char *s = src;
+    size_t n = siz;
+    size_t dlen;
+
+    /* Find the end of dst and adjust bytes left but don't go past end */
+    while (n-- != 0 && *d != '\0') {
+        d++;
+    }
+    dlen = d - dst;
+    n = siz - dlen;
+
+    if (n == 0) {
+        return(dlen + strlen(s));
+    }
+    while (*s != '\0') {
+        if (n != 1) {
+            *d++ = *s;
+            n--;
+        }
+        s++;
+    }
+    *d = '\0';
+
+    return(dlen + (s - src));    /* count does not include NUL */
+}
diff --git a/src/note-c/n_ua.c b/src/note-c/n_ua.c
new file mode 100644
index 0000000..f4a46ac
--- /dev/null
+++ b/src/note-c/n_ua.c
@@ -0,0 +1,209 @@
+/*!
+ * @file n_ua.c
+ *
+ * Written by Ray Ozzie and Blues Inc. team.
+ *
+ * Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#ifndef NOTE_C_LOW_MEM
+
+#include "n_lib.h"
+
+// Override-able statics
+static char *n_agent = (char *) ("note-c" " " NOTE_C_VERSION);
+static int n_cpu_cores = 0;
+static int n_cpu_mem = 0;
+static int n_cpu_mhz = 0;
+static char *n_cpu_vendor = NULL;
+static char *n_os_family = NULL;
+static char *n_os_name = NULL;
+static char *n_os_platform = NULL;
+static char *n_os_version = NULL;
+
+#if defined(ARDUINO_ARCH_ARC32)
+static char *n_cpu_name = (char *) "arc32";
+#elif defined(ARDUINO_ARCH_AVR)
+static char *n_cpu_name = (char *) "avr";
+#elif defined(ARDUINO_ARCH_ESP32)
+static char *n_cpu_name = (char *) "esp32";
+#elif defined(ARDUINO_ARCH_ESP8266)
+static char *n_cpu_name = (char *) "esp8266";
+#elif defined(ARDUINO_ARCH_MEGAAVR)
+static char *n_cpu_name = (char *) "megaavr";
+#elif defined(ARDUINO_ARCH_NRF52840)
+static char *n_cpu_name = (char *) "nrf52840";
+#elif defined(ARDUINO_ARCH_NRF52)
+static char *n_cpu_name = (char *) "nrf52";
+#elif defined(ARDUINO_ARCH_NRF51)
+static char *n_cpu_name = (char *) "nrf51";
+#elif defined(ARDUINO_ARCH_PIC32)
+static char *n_cpu_name = (char *) "pic32";
+#elif defined(ARDUINO_ARCH_SAMD)
+static char *n_cpu_name = (char *) "samd";
+#elif defined(ARDUINO_ARCH_SAM)
+static char *n_cpu_name = (char *) "sam";
+#elif defined(ARDUINO_ARCH_SPRESENSE)
+static char *n_cpu_name = (char *) "spresence";
+#elif defined(ARDUINO_ARCH_STM32F0)
+static char *n_cpu_name = (char *) "stm32f0";
+#elif defined(ARDUINO_ARCH_STM32F1)
+static char *n_cpu_name = (char *) "stm32f1";
+#elif defined(ARDUINO_ARCH_STM32F4)
+static char *n_cpu_name = (char *) "stm32f4";
+#elif defined(ARDUINO_ARCH_STM32G0)
+static char *n_cpu_name = (char *) "stm32g0";
+#elif defined(ARDUINO_SWAN_R5)
+static char *n_cpu_name = (char *) "swan_r5";
+#elif defined(ARDUINO_ARCH_STM32L4)
+static char *n_cpu_name = (char *) "stm32l4";
+#elif defined(ARDUINO_ARCH_STM32U5)
+static char *n_cpu_name = (char *) "stm32u5";
+#elif defined(ARDUINO_ARCH_STM32)
+static char *n_cpu_name = (char *) "stm32";
+#else
+static char *n_cpu_name = NULL;
+#endif
+
+/**************************************************************************/
+/*!
+    @brief  Override-able method to add more data to the user agent object
+  @returns a `J` cJSON object with the user agent object.
+*/
+/**************************************************************************/
+#if defined(_MSC_VER)
+void NoteUserAgentUpdate(J *ua)
+#else
+__attribute__((weak)) void NoteUserAgentUpdate(J *ua)
+#endif
+{
+    ((void)ua);	// avoid compiler warning
+}
+
+/**************************************************************************/
+/*!
+    @brief  Override-able method to return user agent object
+  @returns a `J` cJSON object with the user agent object.
+*/
+/**************************************************************************/
+#if defined(_MSC_VER)
+J *NoteUserAgent()
+#else
+__attribute__((weak)) J *NoteUserAgent()
+#endif
+{
+
+    J *ua = JCreateObject();
+    if (ua == NULL) {
+        return ua;
+    }
+
+#if defined(__cplusplus)
+#define PLUS " c++"
+#else
+#define PLUS ""
+#endif
+
+#if defined(__ICCARM__)
+    char *compiler = (char *) ("iar arm" PLUS " " NOTE_C_STRINGIZE(__VER__));
+#elif defined(__IAR_SYSTEMS_ICC__)
+    char *compiler = (char *) ("iar" PLUS " " NOTE_C_STRINGIZE(__VER__));
+#elif defined(__clang__)
+    char *compiler = (char *) ("clang" PLUS " " __VERSION__);
+#elif defined(__ATOLLIC__) && defined(__GNUC__)
+    char *compiler = (char *) ("atollic gcc" PLUS " " __VERSION__);
+#elif defined(__GNUC__)
+    char *compiler = (char *) ("gcc" PLUS " " __VERSION__);
+#elif defined(_MSC_FULL_VER)
+    char *compiler = (char *) ("msc" PLUS " " _MSC_FULL_VER);
+#elif defined(__STDC_VERSION___)
+    char *compiler = (char *) ("STDC" PLUS " " __STDC_VERSION__);
+#else
+    char *compiler = (char *) ("unknown" PLUS " " __VERSION__)
+#endif
+
+    JAddStringToObject(ua, "agent", n_agent);
+    JAddStringToObject(ua, "compiler", compiler);
+    JAddStringToObject(ua, "req_interface", noteActiveInterface());
+
+    // Add CPU Details
+    if (n_cpu_cores != 0) {
+        JAddNumberToObject(ua, "cpu_cores", n_cpu_cores);
+    }
+    if (n_cpu_mem != 0) {
+        JAddNumberToObject(ua, "cpu_mem", n_cpu_mem);
+    }
+    if (n_cpu_mhz != 0) {
+        JAddNumberToObject(ua, "cpu_mhz", n_cpu_mhz);
+    }
+    if (n_cpu_name != NULL) {
+        JAddStringToObject(ua, "cpu_name", n_cpu_name);
+    }
+    if (n_cpu_vendor != NULL) {
+        JAddStringToObject(ua, "cpu_vendor", n_cpu_vendor);
+    }
+
+    // Add Operating System Details
+    if (n_os_family != NULL) {
+        JAddStringToObject(ua, "os_family", n_os_family);
+    }
+    if (n_os_name != NULL) {
+        JAddStringToObject(ua, "os_name", n_os_name);
+    }
+    if (n_os_platform != NULL) {
+        JAddStringToObject(ua, "os_platform", n_os_platform);
+    }
+    if (n_os_version != NULL) {
+        JAddStringToObject(ua, "os_version", n_os_version);
+    }
+
+    // Add more data to the UA from a higher level
+    NoteUserAgentUpdate(ua);
+
+    return ua;
+
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set key UA fields from a higher level library context
+*/
+/**************************************************************************/
+void NoteSetUserAgent(char *agent)
+{
+    n_agent = agent;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set key UA fields from a higher level library context
+*/
+/**************************************************************************/
+void NoteSetUserAgentOS(char *os_name, char *os_platform, char *os_family, char *os_version)
+{
+    n_os_family = os_family;
+    n_os_name = os_name;
+    n_os_platform = os_platform;
+    n_os_version = os_version;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set key UA fields from a higher level library context
+*/
+/**************************************************************************/
+void NoteSetUserAgentCPU(int cpu_mem, int cpu_mhz, int cpu_cores, char *cpu_vendor, char *cpu_name)
+{
+    n_cpu_cores = cpu_cores;
+    n_cpu_mem = cpu_mem;
+    n_cpu_mhz = cpu_mhz;
+    n_cpu_name = cpu_name;
+    n_cpu_vendor = cpu_vendor;
+}
+
+#endif
diff --git a/src/note-c/note.h b/src/note-c/note.h
new file mode 100644
index 0000000..045c5d5
--- /dev/null
+++ b/src/note-c/note.h
@@ -0,0 +1,566 @@
+/*!
+ @file note.h
+
+ Written by Ray Ozzie and Blues Inc. team.
+
+ Copyright (c) 2019 Blues Inc. MIT License. Use of this source code is
+ governed by licenses granted by the copyright holder including that found in
+ the
+ <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ file.
+
+ This library bundles the <a href="https://github.com/DaveGamble/cJSON">cJSON
+ JSON parser library</a>.
+ */
+
+#pragma once
+
+// In case they're not yet defined
+#include <float.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#define _NOTE_C_STRINGIZE(x) #x
+#define NOTE_C_STRINGIZE(x) _NOTE_C_STRINGIZE(x)
+
+#define NOTE_C_VERSION_MAJOR 2
+#define NOTE_C_VERSION_MINOR 2
+#define NOTE_C_VERSION_PATCH 1
+
+#define NOTE_C_VERSION NOTE_C_STRINGIZE(NOTE_C_VERSION_MAJOR) "." NOTE_C_STRINGIZE(NOTE_C_VERSION_MINOR) "." NOTE_C_STRINGIZE(NOTE_C_VERSION_PATCH)
+
+// If double and float are the same size, then we must be on a small MCU. Turn
+// on NOTE_C_LOW_MEM to conserve memory.
+#if defined(FLT_MAX_EXP) && defined(DBL_MAX_EXP)
+#if (FLT_MAX_EXP == DBL_MAX_EXP)
+#define NOTE_C_LOW_MEM
+#endif
+#elif defined(__FLT_MAX_EXP__) && defined(__DBL_MAX_EXP__)
+#if (__FLT_MAX_EXP__ == __DBL_MAX_EXP__)
+#define NOTE_C_LOW_MEM
+#endif
+#else
+#error What are floating point exponent length symbols for this compiler?
+#endif
+
+// NOTE_LOWMEM is the old name of NOTE_C_LOW_MEM. If NOTE_LOWMEM is defined,
+// we define NOTE_C_LOW_MEM as well, for backwards compatibility. NOTE_FLOAT is
+// also no longer used internally, but used to be defined when NOTE_LOWMEM was
+// defined. It's also preserved here for backwards compatibility.
+#ifdef NOTE_LOWMEM
+#define NOTE_C_LOW_MEM
+#define NOTE_FLOAT
+#endif
+
+#ifdef NOTE_C_LOW_MEM
+#define ERRSTR(x,y) (y)
+#else
+#define ERRSTR(x,y) (x)
+#endif
+
+/*!
+ @brief The floating point type used for JSON handling in note-c.
+ */
+#ifdef NOTE_C_TEST_SINGLE_PRECISION
+typedef float JNUMBER;
+#else
+typedef double JNUMBER;
+#endif
+
+/*!
+ @brief The signed integer type used for JSON handling in note-c.
+ */
+typedef int64_t JINTEGER;
+#define JINTEGER_MIN INT64_MIN
+#define JINTEGER_MAX INT64_MAX
+
+/*!
+ @brief The unsigned integer type used for JSON handling in note-c.
+ */
+typedef uint64_t JUINTEGER;
+
+// UNIX Epoch time (also known as POSIX time) is the  number of seconds that have elapsed since
+// 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC).  In this project, it always
+// originates from the Notecard, which synchronizes the time from both the cell network and GPS.
+typedef JUINTEGER JTIME;
+
+// C-callable functions
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// cJSON wrappers
+#include "n_cjson.h"
+
+// Notecard hook functions
+
+/*!
+ @typedef mutexFn
+
+ @brief The type for the various mutex (i.e. lock/unlock) hooks.
+ */
+typedef void (*mutexFn) (void);
+/*!
+ @typedef mallocFn
+
+ @brief The type for the memory allocation hook.
+
+ @param size The number of bytes to allocate.
+
+ @returns A pointer to the newly allocated memory or NULL on failure.
+ */
+typedef void * (*mallocFn) (size_t size);
+/*!
+ @typedef freeFn
+
+ @brief The type for the memory freeing hook.
+
+ @param mem Pointer to the memory to free.
+ */
+typedef void (*freeFn) (void * mem);
+/*!
+ @typedef delayMsFn
+
+ @brief The type for the millisecond delay hook.
+
+ @param ms The number of milliseconds to delay for.
+ */
+typedef void (*delayMsFn) (uint32_t ms);
+/*!
+ @typedef getMsFn
+
+ @brief The type for the millisecond counter hook.
+
+ @returns The value of the millisecond counter.
+ */
+typedef uint32_t (*getMsFn) (void);
+typedef size_t (*debugOutputFn) (const char *text);
+
+/*!
+ @typedef serialResetFn
+
+ @brief The type for the serial reset hook.
+
+ This hook is used to reset the serial peripheral used to communicate with the
+ Notecard.
+
+ @returns `true` on success and `false` on failure.
+ */
+typedef bool (*serialResetFn) (void);
+/*!
+ @typedef serialTransmitFn
+
+ @brief The type for the serial transmit hook.
+
+ @param txBuf A buffer of bytes to transmit to the Notecard.
+ @param txBufSize The size, in bytes, of `txBuf`.
+ @param flush If true, flush the serial peripheral's transmit buffer.
+ */
+typedef void (*serialTransmitFn) (uint8_t *txBuf, size_t txBufSize, bool flush);
+/*!
+ @typedef serialAvailableFn
+
+ @brief The type for the serial available hook.
+
+ @return `true` if there's data to read and `false` otherwise.
+ */
+typedef bool (*serialAvailableFn) (void);
+
+/*!
+ @typedef serialReceiveFn
+
+ @brief The type for the serial receive hook.
+
+ @return The received byte.
+ */
+typedef char (*serialReceiveFn) (void);
+/*!
+ @typedef i2cResetFn
+
+ @brief The type for the I2C reset hook.
+
+ This hook is used to reset the I2C peripheral used to communicate with the
+ Notecard.
+
+ @param address The I2C address of the Notecard.
+ */
+typedef bool (*i2cResetFn) (uint16_t address);
+/*!
+ @typedef i2cTransmitFn
+
+ @brief The type for the I2C transmit hook.
+
+ This hook is used to send a buffer of bytes to the Notecard.
+
+ @param address The I2C address of the Notecard to transmit the data to.
+ @param txBuf A buffer of bytes to transmit to the Notecard.
+ @param txBufSize The size, in bytes, of `txBuf`.
+
+ @returns NULL on success and an error string on failure.
+ */
+typedef const char * (*i2cTransmitFn) (uint16_t address, uint8_t* txBuf,
+                                       uint16_t txBufSize);
+/*!
+ @typedef i2cReceiveFn
+
+ @brief The type for the I2C receive hook.
+
+ This hook is used to receive a buffer of bytes from the Notecard.
+
+ @param address The I2C address of the Notecard sending the data to receive.
+ @param rxBuf A buffer to hold the data received from the Notecard.
+ @param rxBufSize The size, in bytes, of rxBuf.
+ @param available The number of bytes remaining to be received, if any.
+
+ @returns NULL on success and an error string on failure.
+ */
+typedef const char * (*i2cReceiveFn) (uint16_t address, uint8_t* rxBuf,
+                                      uint16_t rxBufSize, uint32_t *available);
+typedef bool (*txnStartFn) (uint32_t timeoutMs);
+typedef void (*txnStopFn) (void);
+
+// External API
+bool NoteReset(void);
+void NoteResetRequired(void);
+#define NoteNewBody JCreateObject
+#define NoteAddBodyToObject(a, b) JAddItemToObject(a, "body", b)
+#define NoteGetBody(a) JGetObject(a, "body")
+J *NoteNewRequest(const char *request);
+J *NoteNewCommand(const char *request);
+J *NoteRequestResponse(J *req);
+J *NoteRequestResponseWithRetry(J *req, uint32_t timeoutSeconds);
+char * NoteRequestResponseJSON(const char *reqJSON);
+void NoteSuspendTransactionDebug(void);
+void NoteResumeTransactionDebug(void);
+#define SYNCSTATUS_LEVEL_MAJOR         0
+#define SYNCSTATUS_LEVEL_MINOR         1
+#define SYNCSTATUS_LEVEL_DETAILED      2
+#define SYNCSTATUS_LEVEL_ALGORITHMIC   3
+#define SYNCSTATUS_LEVEL_ALL          -1
+bool NoteDebugSyncStatus(int pollFrequencyMs, int maxLevel);
+bool NoteRequest(J *req);
+bool NoteRequestWithRetry(J *req, uint32_t timeoutSeconds);
+/*!
+ @brief Check if the Notecard response contains an error.
+
+ @param rsp The response to check.
+
+ @returns `true` if there's an error and `false` if there's not.
+ */
+#define NoteResponseError(rsp) (!JIsNullString(rsp, "err"))
+#define NoteResponseErrorContains(rsp, errstr) (JContainsString(rsp, "err", errstr))
+/*!
+ @brief Free a response from the Notecard.
+
+ @param rsp The response to free.
+ */
+#define NoteDeleteResponse(rsp) JDelete(rsp)
+J *NoteTransaction(J *req);
+bool NoteErrorContains(const char *errstr, const char *errtype);
+void NoteErrorClean(char *errbuf);
+void NoteSetFnDebugOutput(debugOutputFn fn);
+void NoteSetFnTransaction(txnStartFn startFn, txnStopFn stopFn);
+void NoteSetFnMutex(mutexFn lockI2Cfn, mutexFn unlockI2Cfn, mutexFn lockNotefn,
+                    mutexFn unlockNotefn);
+void NoteSetFnI2CMutex(mutexFn lockI2Cfn, mutexFn unlockI2Cfn);
+void NoteSetFnNoteMutex(mutexFn lockFn, mutexFn unlockFn);
+void NoteSetFnDefault(mallocFn mallocfn, freeFn freefn, delayMsFn delayfn,
+                      getMsFn millisfn);
+void NoteSetFn(mallocFn mallocHook, freeFn freeHook, delayMsFn delayMsHook,
+               getMsFn getMsHook);
+void NoteSetFnSerial(serialResetFn resetFn, serialTransmitFn transmitFn,
+                     serialAvailableFn availFn, serialReceiveFn receiveFn);
+void NoteSetFnI2C(uint32_t notecardAddr, uint32_t maxTransmitSize,
+                  i2cResetFn resetFn, i2cTransmitFn transmitFn,
+                  i2cReceiveFn receiveFn);
+void NoteSetFnDisabled(void);
+void NoteSetI2CAddress(uint32_t i2caddress);
+
+// The Notecard, whose default I2C address is below, uses a serial-to-i2c
+// protocol whose "byte count" must fit into a single byte and which must not
+// include a 2-byte header field.  This is why the maximum that can be
+// transmitted by note-c in a single I2C I/O is 255 - 2 = 253 bytes.
+
+/*!
+ @brief The default I2C address of the Notecard.
+ */
+#define NOTE_I2C_ADDR_DEFAULT	0x17
+
+// Serial-to-i2c protocol header size in bytes
+#ifndef NOTE_I2C_HEADER_SIZE
+#define NOTE_I2C_HEADER_SIZE 2
+#endif
+
+// Maximum bytes capable of being transmitted in a single read/write operation
+#ifndef NOTE_I2C_MAX_MAX
+#define NOTE_I2C_MAX_MAX (UCHAR_MAX - NOTE_I2C_HEADER_SIZE)
+#endif
+
+// In ARDUINO implementations, which to date is the largest use of this library,
+// the Wire package is implemented in a broad variety of ways by different
+// vendors.  The default implementation has a mere 32-byte static I2C buffer,
+// which means that the maximum to be transmitted in a single I/O (given our
+// 2-byte serial-to-i2c protocol header) is 30 bytes.  However, if we know
+// the specific platform (such as STM32DUINO) we can relax this restriction.
+#if defined(NOTE_I2C_MAX_DEFAULT)
+// user is overriding it at compile time
+#elif defined(ARDUINO_ARCH_STM32)
+// we know that stm32duino dynamically allocates I/O buffer
+#define NOTE_I2C_MAX_DEFAULT NOTE_I2C_MAX_MAX
+#else
+// default to what's known to be safe for all Arduino implementations
+/*!
+ @brief The maximum number of bytes to request from or transmit to the Notecard
+        in a single chunk.
+ */
+#define NOTE_I2C_MAX_DEFAULT	30
+#endif
+
+// User agent
+J *NoteUserAgent(void);
+void NoteUserAgentUpdate(J *ua);
+void NoteSetUserAgent(char *agent);
+void NoteSetUserAgentOS(char *os_name, char *os_platform, char *os_family, char *os_version);
+void NoteSetUserAgentCPU(int cpu_mem, int cpu_mhz, int cpu_cores, char *cpu_vendor, char *cpu_name);
+
+// Calls to the functions set above
+void NoteDebug(const char *message);
+void NoteDebugln(const char *message);
+void NoteDebugIntln(const char *message, int n);
+void NoteDebugf(const char *format, ...);
+
+#define NOTE_C_LOG_LEVEL_ERROR  0
+#define NOTE_C_LOG_LEVEL_WARN   1
+#define NOTE_C_LOG_LEVEL_INFO   2
+#define NOTE_C_LOG_LEVEL_DEBUG  3
+
+void NoteDebugWithLevel(uint8_t level, const char *msg);
+void NoteDebugWithLevelLn(uint8_t level, const char *msg);
+
+#ifdef NOTE_C_LOG_SHOW_FILE_AND_LINE
+#define NOTE_C_LOG_FILE_AND_LINE(lvl) do { \
+  NoteDebugWithLevel(lvl, __FILE__ ":" NOTE_C_STRINGIZE(__LINE__) " "); \
+} while (0);
+#else
+#define NOTE_C_LOG_FILE_AND_LINE(lvl)
+#endif
+
+#define NOTE_C_LOG_ERROR(msg) do { \
+  NOTE_C_LOG_FILE_AND_LINE(NOTE_C_LOG_LEVEL_ERROR); \
+  NoteDebugWithLevel(NOTE_C_LOG_LEVEL_ERROR, "[ERROR] "); \
+  NoteDebugWithLevelLn(NOTE_C_LOG_LEVEL_ERROR, msg); \
+} while (0);
+
+#define NOTE_C_LOG_WARN(msg) do { \
+  NOTE_C_LOG_FILE_AND_LINE(NOTE_C_LOG_LEVEL_WARN); \
+  NoteDebugWithLevel(NOTE_C_LOG_LEVEL_WARN, "[WARN] "); \
+  NoteDebugWithLevelLn(NOTE_C_LOG_LEVEL_WARN, msg); \
+} while (0);
+
+#define NOTE_C_LOG_INFO(msg) do { \
+  NOTE_C_LOG_FILE_AND_LINE(NOTE_C_LOG_LEVEL_INFO); \
+  NoteDebugWithLevel(NOTE_C_LOG_LEVEL_INFO, "[INFO] "); \
+  NoteDebugWithLevelLn(NOTE_C_LOG_LEVEL_INFO, msg); \
+} while (0);
+
+#define NOTE_C_LOG_DEBUG(msg) do { \
+  NOTE_C_LOG_FILE_AND_LINE(NOTE_C_LOG_LEVEL_DEBUG); \
+  NoteDebugWithLevel(NOTE_C_LOG_LEVEL_DEBUG, "[DEBUG] "); \
+  NoteDebugWithLevelLn(NOTE_C_LOG_LEVEL_DEBUG, msg); \
+} while (0);
+
+// The max log level for NoteDebugWithLevel is only configurable at
+// compile-time, via NOTE_C_LOG_LEVEL.
+#ifndef NOTE_C_LOG_LEVEL
+#define NOTE_C_LOG_LEVEL NOTE_C_LOG_LEVEL_INFO
+#endif
+
+void *NoteMalloc(size_t size);
+void NoteFree(void *);
+uint32_t NoteGetMs(void);
+void NoteDelayMs(uint32_t ms);
+void NoteLockI2C(void);
+void NoteUnlockI2C(void);
+uint32_t NoteI2CAddress(void);
+uint32_t NoteI2CMax(void);
+uint32_t NoteMemAvailable(void);
+bool NotePrint(const char *text);
+void NotePrintln(const char *line);
+bool NotePrintf(const char *format, ...);
+
+// String helpers to help encourage the world to abandon the horribly-error-prone strn*
+size_t strlcpy(char *dst, const char *src, size_t siz);
+size_t strlcat(char *dst, const char *src, size_t siz);
+
+// JSON helpers
+void JInit(void);
+void JCheck(void);
+bool JIsPresent(J *json, const char *field);
+char *JGetString(J *json, const char *field);
+JNUMBER JGetNumber(J *json, const char *field);
+J *JGetArray(J *json, const char *field);
+J *JGetObject(J *json, const char *field);
+JINTEGER JGetInt(J *json, const char *field);
+bool JGetBool(J *json, const char *field);
+JNUMBER JNumberValue(J *item);
+char *JStringValue(J *item);
+bool JBoolValue(J *item);
+JINTEGER JIntValue(J *item);
+bool JIsNullString(J *json, const char *field);
+bool JIsExactString(J *json, const char *field, const char *teststr);
+bool JContainsString(J *json, const char *field, const char *substr);
+bool JAddBinaryToObject(J *json, const char *fieldName, const void *binaryData, uint32_t binaryDataLen);
+bool JGetBinaryFromObject(J *json, const char *fieldName, uint8_t **retBinaryData, uint32_t *retBinaryDataLen);
+const char *JGetItemName(const J * item);
+char *JAllocString(uint8_t *buffer, uint32_t len);
+const char *JType(J *item);
+
+#define JTYPE_NOT_PRESENT		0
+#define JTYPE_BOOL_TRUE			1
+#define JTYPE_BOOL_FALSE		2
+#define JTYPE_BOOL              JTYPE_BOOL_TRUE
+#define JTYPE_NULL				3
+#define JTYPE_NUMBER_ZERO		4
+#define JTYPE_NUMBER			5
+#define JTYPE_STRING_BLANK		6
+#define JTYPE_STRING_ZERO		7
+#define JTYPE_STRING_NUMBER		8
+#define JTYPE_STRING_BOOL_TRUE 	9
+#define JTYPE_STRING_BOOL_FALSE	10
+#define JTYPE_STRING			11
+#define JTYPE_OBJECT			12
+#define JTYPE_ARRAY				13
+int JGetType(J *json, const char *field);
+int JGetItemType(J *item);
+int JBaseItemType(int type);
+#define JGetObjectItemName(j) (j->string)
+
+// Helper functions for apps that wish to limit their C library dependencies
+#define JNTOA_PRECISION (16)
+#define JNTOA_MAX       (44)
+char * JNtoA(JNUMBER f, char * buf, int precision);
+JNUMBER JAtoN(const char *string, char **endPtr);
+void JItoA(JINTEGER n, char *s);
+JINTEGER JAtoI(const char *s);
+int JB64EncodeLen(int len);
+int JB64Encode(char * coded_dst, const char *plain_src,int len_plain_src);
+int JB64DecodeLen(const char * coded_src);
+int JB64Decode(char * plain_dst, const char *coded_src);
+
+// MD5 Helper functions
+typedef struct {
+    unsigned long buf[4];
+    unsigned long bits[2];
+    unsigned char in[64];
+} NoteMD5Context;
+#define NOTE_MD5_HASH_SIZE 16
+#define NOTE_MD5_HASH_STRING_SIZE (((NOTE_MD5_HASH_SIZE)*2)+1)
+void NoteMD5Init(NoteMD5Context *ctx);
+void NoteMD5Update(NoteMD5Context *ctx, unsigned char const *buf, unsigned long len);
+void NoteMD5Final(unsigned char *digest, NoteMD5Context *ctx);
+void NoteMD5Transform(unsigned long buf[4], const unsigned char inraw[64]);
+void NoteMD5Hash(unsigned char* data, unsigned long len, unsigned char *retHash);
+void NoteMD5HashString(unsigned char *data, unsigned long len, char *strbuf, unsigned long buflen);
+void NoteMD5HashToString(unsigned char *hash, char *strbuf, unsigned long buflen);
+
+// High-level helper functions that are both useful and serve to show developers
+// how to call the API
+uint32_t NoteBinaryCodecDecode(const uint8_t *encData, uint32_t encDataLen,
+                               uint8_t *decBuf, uint32_t decBufSize);
+uint32_t NoteBinaryCodecEncode(const uint8_t *decData, uint32_t decDataLen,
+                               uint8_t *encBuf, uint32_t encBufSize);
+uint32_t NoteBinaryCodecMaxDecodedLength(uint32_t bufferSize);
+uint32_t NoteBinaryCodecMaxEncodedLength(uint32_t unencodedLength);
+const char * NoteBinaryStoreDecodedLength(uint32_t *len);
+const char * NoteBinaryStoreEncodedLength(uint32_t *len);
+const char * NoteBinaryStoreReceive(uint8_t *buffer, uint32_t bufLen,
+                                    uint32_t decodedOffset, uint32_t decodedLen);
+const char * NoteBinaryStoreReset(void);
+const char * NoteBinaryStoreTransmit(uint8_t *unencodedData, uint32_t unencodedLen,
+                                     uint32_t bufLen, uint32_t notecardOffset);
+uint32_t NoteSetSTSecs(uint32_t secs);
+bool NoteTimeValid(void);
+bool NoteTimeValidST(void);
+JTIME NoteTime(void);
+JTIME NoteTimeST(void);
+void NoteTimeRefreshMins(uint32_t mins);
+void NoteTimeSet(JTIME secondsUTC, int offset, char *zone, char *country, char *area);
+bool NoteLocalTimeST(uint16_t *retYear, uint8_t *retMonth, uint8_t *retDay, uint8_t *retHour, uint8_t *retMinute, uint8_t *retSecond, char **retWeekday, char **retZone);
+bool NoteRegion(char **retCountry, char **retArea, char **retZone, int *retZoneOffset);
+bool NoteLocationValid(char *errbuf, uint32_t errbuflen);
+bool NoteLocationValidST(char *errbuf, uint32_t errbuflen);
+void NoteTurboIO(bool enable);
+JINTEGER NoteGetEnvInt(const char *variable, JINTEGER defaultVal);
+JNUMBER NoteGetEnvNumber(const char *variable, JNUMBER defaultVal);
+bool NoteGetEnv(const char *variable, const char *defaultVal, char *buf, uint32_t buflen);
+bool NoteSetEnvDefault(const char *variable, char *buf);
+bool NoteSetEnvDefaultNumber(const char *variable, JNUMBER defaultVal);
+bool NoteSetEnvDefaultInt(const char *variable, JINTEGER defaultVal);
+bool NoteIsConnected(void);
+bool NoteIsConnectedST(void);
+bool NoteGetNetStatus(char *statusBuf, int statusBufLen);
+bool NoteGetVersion(char *versionBuf, int versionBufLen);
+bool NoteGetLocation(JNUMBER *retLat, JNUMBER *retLon, JTIME *time, char *statusBuf, int statusBufLen);
+bool NoteSetLocation(JNUMBER lat, JNUMBER lon);
+bool NoteClearLocation(void);
+bool NoteGetLocationMode(char *modeBuf, int modeBufLen);
+bool NoteSetLocationMode(const char *mode, uint32_t seconds);
+bool NoteGetServiceConfig(char *productBuf, int productBufLen, char *serviceBuf, int serviceBufLen, char *deviceBuf, int deviceBufLen, char *snBuf, int snBufLen);
+bool NoteGetServiceConfigST(char *productBuf, int productBufLen, char *serviceBuf, int serviceBufLen, char *deviceBuf, int deviceBufLen, char *snBuf, int snBufLen);
+bool NoteGetStatus(char *statusBuf, int statusBufLen, JTIME *bootTime, bool *retUSB, bool *retSignals);
+bool NoteGetStatusST(char *statusBuf, int statusBufLen, JTIME *bootTime, bool *retUSB, bool *retSignals);
+bool NoteSleep(char *stateb64, uint32_t seconds, const char *modes);
+bool NoteWake(int stateLen, void *state);
+bool NoteFactoryReset(bool deleteConfigSettings);
+bool NoteSetSerialNumber(const char *sn);
+bool NoteSetProductID(const char *productID);
+bool NoteSetUploadMode(const char *uploadMode, int uploadMinutes, bool align);
+bool NoteSetSyncMode(const char *uploadMode, int uploadMinutes, int downloadMinutes, bool align, bool sync);
+#define NoteSend NoteAdd
+bool NoteAdd(const char *target, J *body, bool urgent);
+bool NoteSendToRoute(const char *method, const char *routeAlias, char *notefile, J *body);
+bool NoteGetVoltage(JNUMBER *voltage);
+bool NoteGetTemperature(JNUMBER *temp);
+bool NoteGetContact(char *nameBuf, int nameBufLen, char *orgBuf, int orgBufLen, char *roleBuf, int roleBufLen, char *emailBuf, int emailBufLen);
+bool NoteSetContact(char *nameBuf, char *orgBuf, char *roleBuf, char *emailBuf);
+
+// Definitions necessary for payload descriptor
+#define NP_SEGTYPE_LEN 4
+#define NP_SEGLEN_LEN sizeof(uint32_t)
+#define NP_SEGHDR_LEN (NP_SEGTYPE_LEN + NP_SEGLEN_LEN)
+typedef struct {
+    uint8_t *data;
+    uint32_t alloc;
+    uint32_t length;
+} NotePayloadDesc;
+bool NotePayloadSaveAndSleep(NotePayloadDesc *desc, uint32_t seconds, const char *modes);
+bool NotePayloadRetrieveAfterSleep(NotePayloadDesc *desc);
+void NotePayloadSet(NotePayloadDesc *desc, uint8_t *buf, uint32_t buflen);
+void NotePayloadFree(NotePayloadDesc *desc);
+bool NotePayloadAddSegment(NotePayloadDesc *desc, const char segtype[NP_SEGTYPE_LEN], void *pdata, uint32_t plen);
+bool NotePayloadFindSegment(NotePayloadDesc *desc, const char segtype[NP_SEGTYPE_LEN], void *pdata, uint32_t *plen);
+bool NotePayloadGetSegment(NotePayloadDesc *desc, const char segtype[NP_SEGTYPE_LEN], void *pdata, uint32_t len);
+
+// Hard-wired constants used to specify field types when creating note templates
+#define TBOOL           true                 // bool
+#define TINT8           11                   // 1-byte signed integer
+#define TINT16          12                   // 2-byte signed integer
+#define TINT24          13                   // 3-byte signed integer
+#define TINT32          14                   // 4-byte signed integer
+#define TINT64          18                   // 8-byte signed integer (note-c support depends upon platform)
+#define TUINT8          21                   // 1-byte unsigned integer (requires notecard firmware >= build 14444)
+#define TUINT16         22                   // 2-byte unsigned integer (requires notecard firmware >= build 14444)
+#define TUINT24         23                   // 3-byte unsigned integer (requires notecard firmware >= build 14444)
+#define TUINT32         24                   // 4-byte unsigned integer (requires notecard firmware >= build 14444)
+#define TFLOAT16        12.1                 // 2-byte IEEE 754 floating point
+#define TFLOAT32        14.1                 // 4-byte IEEE 754 floating point (a.k.a. "float")
+#define TFLOAT64        18.1                 // 8-byte IEEE 754 floating point (a.k.a. "double")
+#define TSTRING(N)      _NOTE_C_STRINGIZE(N) // UTF-8 text of N bytes maximum (fixed-length reserved buffer)
+#define TSTRINGV        _NOTE_C_STRINGIZE(0) // variable-length string
+bool NoteTemplate(const char *notefileID, J *templateBody);
+
+// End of C-callable functions
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/note-c/scripts/build_docs.sh b/src/note-c/scripts/build_docs.sh
new file mode 100755
index 0000000..2335f53
--- /dev/null
+++ b/src/note-c/scripts/build_docs.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+ROOT_SRC_DIR="$SCRIPT_DIR/.."
+
+pushd $ROOT_SRC_DIR $@ > /dev/null
+
+cmake -B build/ -DNOTE_C_BUILD_DOCS=1
+if [[ $? -ne 0 ]]; then
+    echo "Failed to run CMake."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+cmake --build build/ -- docs -j
+if [[ $? -ne 0 ]]; then
+    echo "Failed to build docs."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+echo "Built docs."
+popd $@ > /dev/null
diff --git a/src/note-c/scripts/check_libc_dependencies.sh b/src/note-c/scripts/check_libc_dependencies.sh
new file mode 100755
index 0000000..6e31e2d
--- /dev/null
+++ b/src/note-c/scripts/check_libc_dependencies.sh
@@ -0,0 +1,92 @@
+#!/bin/bash
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+ROOT_SRC_DIR="$SCRIPT_DIR/.."
+
+if [[ ! -f "$ROOT_SRC_DIR/CMakeLists.txt" ]]; then
+    echo "Failed to find note-c root directory. (did the location of check_libc_dependencies.sh change?)"
+    exit 1
+fi
+
+pushd $ROOT_SRC_DIR $@ > /dev/null
+
+CMAKE_OPTIONS="-DNOTE_C_NO_LIBC=1"
+
+cmake -B build/ $CMAKE_OPTIONS
+if [[ $? -ne 0 ]]; then
+    echo "Failed to run CMake."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+PERMITTED_FNS=(
+    # The mem* functions are ok.
+    "memchr"
+    "memcmp"
+    "memcpy"
+    "memmove"
+    "memset"
+    # These string functions are ok.
+    "strchr"
+    "strcmp"
+    "strlen"
+    "strncmp"
+    "strstr"
+    # strtol comes from us using atoi in NoteGetEnvInt.
+    "strtol"
+    # Used by NotePrintf.
+    "vsnprintf"
+)
+
+# Function to check if an element is in an array.
+element_in_array() {
+    local element="$1"
+    local array=("${@:2}")
+
+    for item in "${array[@]}"; do
+        if [ "$item" == "$element" ]; then
+            return 0  # Element found in array
+        fi
+    done
+    return 1  # Element not found in array
+}
+
+BUILD_OUTPUT=$(cmake --build build/ -j 2>&1)
+if [[ $? -ne 0 ]]; then
+    # Iterate over the lines from the build output to get all the undefined
+    # references.
+    UNDEF_REFS=()
+    while IFS= read -r LINE; do
+        PATTERN="undefined reference to \`(.*)'"
+        if [[ $LINE =~ $PATTERN ]]; then
+            UNDEF_REFS+=("${BASH_REMATCH[1]}")
+        fi
+    done <<< "$BUILD_OUTPUT"
+
+    # Remove duplicates
+    UNDEF_REFS=($(printf "%s\n" "${UNDEF_REFS[@]}" | sort -u))
+
+    # Check if each function that caused an undefined reference error is
+    # permitted.
+    FAIL=0
+    for UNDEF_REF in "${UNDEF_REFS[@]}"; do
+        if element_in_array "$UNDEF_REF" "${PERMITTED_FNS[@]}"; then
+            echo "$UNDEF_REF is permitted."
+        else
+            echo "$UNDEF_REF is NOT permitted"
+            FAIL=1
+        fi
+    done
+
+    if [ "$FAIL" -eq 1 ]; then
+        echo "Unpermitted libc functions found."
+        popd $@ > /dev/null
+        exit 1
+    fi
+else
+    echo "Build unexpectedly succeeded. The build should fail because certain permitted libc functions shouldn't be found when linking."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+popd $@ > /dev/null
diff --git a/src/note-c/scripts/check_runner_config.sh b/src/note-c/scripts/check_runner_config.sh
new file mode 100755
index 0000000..e266c10
--- /dev/null
+++ b/src/note-c/scripts/check_runner_config.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+
+function env_var_defined() {
+    [ -v $1 ] || echo "Environment variable '$1' not set."
+}
+
+function check_all() {
+    env_var_defined "NOTEHUB_CLIENT_ID"
+    env_var_defined "NOTEHUB_CLIENT_SECRET"
+    env_var_defined "NOTEHUB_PROJECT_UID"
+    env_var_defined "NOTEHUB_PRODUCT_UID"
+    env_var_defined "MD5SRV_PORT"
+    env_var_defined "MD5SRV_ADDRESS"
+    env_var_defined "MD5SRV_TOKEN"
+    env_var_defined "SWAN_SERIAL"
+    env_var_defined "STLINK_PROGRAMMER_PORT"
+
+    # these are defined in the workflow itself, but good to check in case of errors causing them to be unset
+    env_var_defined "NOTEHUB_API"
+    env_var_defined "NOTEHUB"
+    env_var_defined "PIO_PROJECT_DIR"
+    env_var_defined "NOTEHUB_PROXY_ROUTE_LABEL"
+    env_var_defined "NOTEHUB_PROXY_ROUTE_ALIAS"
+    env_var_defined "NOTEHUB_HTTP_ROUTE_LABEL"
+
+
+}
+
+errors=$(check_all)
+if [ -n "$errors" ]; then
+    echo "$errors"   # quoted to preserve newlines
+    echo "There are configuration errors. See the log above for details."
+    exit 1
+fi
+
+exit 0
diff --git a/src/note-c/scripts/git_hooks/pre-push b/src/note-c/scripts/git_hooks/pre-push
new file mode 100755
index 0000000..08b31a7
--- /dev/null
+++ b/src/note-c/scripts/git_hooks/pre-push
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+PRE_PUSH_HOOK_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+NOTE_C_DIR=$PRE_PUSH_HOOK_DIR/../..
+SCRIPTS_DIR=$NOTE_C_DIR/scripts
+
+$SCRIPTS_DIR/run_astyle.sh
+if [ $? -ne 0 ]; then
+    echo "run_astyle.sh failed."
+    exit 1
+fi
+
+$SCRIPTS_DIR/build_docs.sh
+if [ $? -ne 0 ]; then
+    echo "build_docs.sh failed."
+    exit 1
+fi
+
+$SCRIPTS_DIR/run_unit_tests.sh
+if [ $? -ne 0 ]; then
+    echo "run_unit_tests.sh failed."
+    exit 1
+fi
diff --git a/src/note-c/scripts/run_astyle.sh b/src/note-c/scripts/run_astyle.sh
new file mode 100755
index 0000000..f055821
--- /dev/null
+++ b/src/note-c/scripts/run_astyle.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+#
+# This script will automatically format all version-controlled C and C++ files
+# in the repository using the astyle tool with the One True Brace Style (OTBS).
+# If a file shouldn't be formatted, it needs to be listed in the EXCLUDE_FILES
+# array below with a path relative to the source code root.
+#
+
+if [[ ! $(which astyle) ]]; then
+    echo "astyle binary not found. Please install it and try again."
+    exit 1
+fi
+
+# These files won't be formatted.
+EXCLUDE_FILES=(
+    test/include/fff.h
+)
+
+if [[ `git diff` ]]; then
+    echo "Local unstaged changes detected. Please stage, commit, stash, or discard any changes prior to running this script."
+    exit 1
+fi
+
+# Run astyle on all version-controlled C and C++ files.
+for FILE in $(git ls-files '*.c' '*.h' '*.cpp' '*.hpp')
+do
+    # Skip files listed in EXCLUDE_FILES.
+    if [[ ! " ${EXCLUDE_FILES[*]} " =~ " ${FILE} " ]]; then
+        astyle --suffix=none --style=otbs $FILE
+    fi
+done
+
+# If there are new formatting changes after running astyle, exit with a non-zero
+# value.
+if [[ `git diff` ]]; then
+    echo "New formatting changes left in working tree."
+    exit 1
+else
+    echo "No new formatting changes."
+fi
diff --git a/src/note-c/scripts/run_md5srv.sh b/src/note-c/scripts/run_md5srv.sh
new file mode 100755
index 0000000..4e30380
--- /dev/null
+++ b/src/note-c/scripts/run_md5srv.sh
@@ -0,0 +1,4 @@
+. venv/bin/activate
+python3 ./test/hitl/scripts/md5srv.py --dir md5srv-files --save > md5srv.log 2>&1 &
+MD5SRV_PID=$!
+echo "MD5SRV_PID=$MD5SRV_PID" >> $GITHUB_ENV
diff --git a/src/note-c/scripts/run_tunnelmole.sh b/src/note-c/scripts/run_tunnelmole.sh
new file mode 100755
index 0000000..5979d9b
--- /dev/null
+++ b/src/note-c/scripts/run_tunnelmole.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+if [ -n "$MD5SRV_PORT" ]; then
+    echo "INFO: Using MD5 server port $MD5SRV_PORT." >&2
+else
+    echo "ERROR: MD5SRV_PORT not defined." >&2
+    exit 1
+fi
+
+if ! which tmole > /dev/null 2>&1; then
+    echo "ERROR: tmole command not found." >&2
+    exit 1
+fi
+
+echo "INFO: Starting tmole..." >&2
+tmole $MD5SRV_PORT > tmole.log 2>&1 &
+TMOLE_PID=$!
+echo "INFO: tmole PID is $TMOLE_PID." >&2
+echo "TMOLE_PID=$TMOLE_PID" >> $GITHUB_ENV
+timeout 10 bash -c "until test -e tmole.log; do sleep 0.1; done"
+if [ $? -ne 0 ]; then
+    echo "ERROR: tmole failed to start." >&2
+    exit 1
+fi
+
+sleep 1
+
+
+TIMEOUT=8
+SECONDS=0
+MD5SRV_URL=""
+# Check tmole.log for the MD5 server URL every second.
+until [ "$SECONDS" -ge "$TIMEOUT" ]
+do
+    MD5SRV_URL=$(grep -oP "^https://[\w\d\.-]+" tmole.log)
+
+    if [ -n "$MD5SRV_URL" ]; then
+        break
+    else
+        SECONDS=$((SECONDS+1))
+        sleep 1
+    fi
+done
+
+if [ -z "$MD5SRV_URL" ]; then
+    echo "ERROR: Timed out waiting for MD5 server URL to get written to tmole.log." >&2
+    exit 1
+fi
+
+echo "INFO: Got MD5 server URL from tmole.log." >&2
+echo "MD5SRV_URL=$MD5SRV_URL" >> $GITHUB_ENV
+echo "INFO: tmole ready. Logging to `realpath tmole.log`" >&2
diff --git a/src/note-c/scripts/run_unit_tests.sh b/src/note-c/scripts/run_unit_tests.sh
new file mode 100755
index 0000000..172c24d
--- /dev/null
+++ b/src/note-c/scripts/run_unit_tests.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+COVERAGE=0
+MEM_CHECK=0
+LOW_MEM=0
+SINGLE_PRECISION=0
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --coverage) COVERAGE=1 ;;
+        --mem-check) MEM_CHECK=1 ;;
+        --low-mem) LOW_MEM=1 ;;
+        --single-precision) SINGLE_PRECISION=1 ;;
+        *) echo "Unknown parameter: $1"; exit 1 ;;
+    esac
+    shift
+done
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+ROOT_SRC_DIR="$SCRIPT_DIR/.."
+
+if [[ ! -f "$ROOT_SRC_DIR/CMakeLists.txt" ]]; then
+    echo "Failed to find note-c root directory. (did the location of run_unit_tests.sh change?)"
+    exit 1
+fi
+
+pushd $ROOT_SRC_DIR $@ > /dev/null
+
+CMAKE_OPTIONS="-DNOTE_C_BUILD_TESTS=1"
+BUILD_OPTIONS=""
+CTEST_OPTIONS=""
+if [[ $COVERAGE -eq 1 ]]; then
+    CMAKE_OPTIONS="${CMAKE_OPTIONS} -DNOTE_C_COVERAGE=1"
+    BUILD_OPTIONS="${BUILD_OPTIONS} coverage"
+fi
+if [[ $MEM_CHECK -eq 1 ]]; then
+    CMAKE_OPTIONS="${CMAKE_OPTIONS} -DNOTE_C_MEM_CHECK=1"
+    CTEST_OPTIONS="${CTEST_OPTIONS} -T memcheck"
+
+    # This fixes a problem when running valgrind in a Docker container when the
+    # host machine is running Fedora. See https://stackoverflow.com/a/75293014.
+    ulimit -n 1024
+fi
+if [[ $LOW_MEM -eq 1 ]]; then
+    CMAKE_OPTIONS="${CMAKE_OPTIONS} -DNOTE_C_LOW_MEM=1"
+fi
+if [[ $SINGLE_PRECISION -eq 1 ]]; then
+    CMAKE_OPTIONS="${CMAKE_OPTIONS} -DNOTE_C_TEST_SINGLE_PRECISION=1"
+fi
+
+cmake -B build/ $CMAKE_OPTIONS
+if [[ $? -ne 0 ]]; then
+    echo "Failed to run CMake."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+cmake --build build/ -- $BUILD_OPTIONS -j
+if [[ $? -ne 0 ]]; then
+    echo "Failed to build code."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+ctest --test-dir build/ --output-on-failure ${CTEST_OPTIONS}
+if [[ $? -ne 0 ]]; then
+    echo "ctest failed."
+    popd $@ > /dev/null
+    exit 1
+fi
+
+echo "Tests passed."
+popd $@ > /dev/null
diff --git a/src/note-c/scripts/wait_for_file.sh b/src/note-c/scripts/wait_for_file.sh
new file mode 100755
index 0000000..faf7189
--- /dev/null
+++ b/src/note-c/scripts/wait_for_file.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+# $1 filename to wait for
+set -e
+
+if [ -z "$1" ]; then
+  echo "Expected 1 argument: <filename>"
+  exit 1
+else
+  echo "Waiting for file $1..."
+fi
+
+while ! test -e "$1"; do
+  sleep 0.5
+done
diff --git a/src/note-c/test/CMakeLists.txt b/src/note-c/test/CMakeLists.txt
new file mode 100644
index 0000000..7607ac8
--- /dev/null
+++ b/src/note-c/test/CMakeLists.txt
@@ -0,0 +1,212 @@
+include(FetchContent)
+
+# Catch2 v3 requires C++14.
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+option(BUILD_CATCH "Fetch and build Catch2 from source." OFF)
+
+macro(download_catch2)
+    message(STATUS "Downloading Catch2...")
+    FetchContent_Declare(
+      Catch2
+      GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+      GIT_TAG        v3.2.0
+    )
+    FetchContent_MakeAvailable(Catch2)
+    list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
+endmacro(download_catch2)
+
+if(BUILD_CATCH)
+    download_catch2()
+else()
+    find_package(Catch2 3)
+
+    if(Catch2_FOUND)
+        message(STATUS "Found Catch2: ${Catch2_CONFIG}")
+    else()
+        message(FATAL_ERROR "Couldn't find installed Catch2. To download Catch2 and build from source, re-run cmake with -DBUILD_CATCH=1.")
+    endif(Catch2_FOUND)
+endif(BUILD_CATCH)
+
+include(Catch)
+
+set(TEST_TARGETS "")
+
+macro(add_test TEST_NAME)
+    add_executable(
+        ${TEST_NAME}
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/${TEST_NAME}.cpp
+    )
+    target_include_directories(${TEST_NAME}
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+        PRIVATE ${NOTE_C_SRC_DIR}
+    )
+    target_link_libraries(${TEST_NAME}
+        PRIVATE note_c
+        PRIVATE Catch2::Catch2WithMain
+    )
+    target_compile_options(${TEST_NAME}
+        PRIVATE -Og
+        PRIVATE -ggdb
+    )
+
+    list(APPEND TEST_TARGETS ${TEST_NAME})
+
+    catch_discover_tests(${TEST_NAME})
+endmacro(add_test)
+
+add_test(crcAdd_test)
+add_test(crcError_test)
+add_test(i2cChunkedReceive_test)
+add_test(i2cChunkedTransmit_test)
+add_test(i2cNoteQueryLength_test)
+add_test(i2cNoteReset_test)
+add_test(i2cNoteTransaction_test)
+add_test(JAddBinaryToObject_test)
+add_test(JAllocString_test)
+add_test(JAtoI_test)
+add_test(JAtoN_test)
+add_test(JBaseItemType_test)
+add_test(JBoolValue_test)
+add_test(JContainsString_test)
+add_test(JGetArray_test)
+add_test(JGetBinaryFromObject_test)
+add_test(JGetBool_test)
+add_test(JGetInt_test)
+add_test(JGetItemName_test)
+add_test(JGetNumber_test)
+add_test(JGetObject_test)
+add_test(JGetString_test)
+add_test(JGetType_test)
+add_test(JIntValue_test)
+add_test(JIsExactString_test)
+add_test(JIsNullString_test)
+add_test(JIsPresent_test)
+add_test(JItoA_test)
+add_test(JNtoA_test)
+add_test(JNumberValue_test)
+add_test(JPrintUnformatted_test)
+add_test(JSON_number_handling_test)
+add_test(JStringValue_test)
+add_test(Jtolower_test)
+add_test(JType_test)
+add_test(NoteAdd_test)
+add_test(NoteBinaryCodecDecode_test)
+add_test(NoteBinaryCodecEncode_test)
+add_test(NoteBinaryCodecMaxDecodedLength_test)
+add_test(NoteBinaryCodecMaxEncodedLength_test)
+add_test(NoteBinaryStoreDecodedLength_test)
+add_test(NoteBinaryStoreEncodedLength_test)
+add_test(NoteBinaryStoreReceive_test)
+add_test(NoteBinaryStoreReset_test)
+add_test(NoteBinaryStoreTransmit_test)
+add_test(NoteClearLocation_test)
+add_test(NoteDebug_test)
+add_test(NoteDebugf_test)
+add_test(NoteDebugSyncStatus_test)
+add_test(NoteErrorClean_test)
+add_test(NoteFactoryReset_test)
+add_test(NoteGetContact_test)
+add_test(NoteGetEnv_test)
+add_test(NoteGetEnvNumber_test)
+add_test(NoteGetLocation_test)
+add_test(NoteGetLocationMode_test)
+add_test(NoteGetNetStatus_test)
+add_test(NoteGetServiceConfig_test)
+add_test(NoteGetStatus_test)
+add_test(NoteGetTemperature_test)
+add_test(NoteGetVersion_test)
+add_test(NoteGetVoltage_test)
+add_test(NoteIsConnected_test)
+add_test(NoteLocalTimeST_test)
+add_test(NoteLocationValid_test)
+add_test(NoteNewCommand_test)
+add_test(NoteNewRequest_test)
+add_test(NotePayload_test)
+add_test(NotePayloadRetrieveAfterSleep_test)
+add_test(NotePayloadSaveAndSleep_test)
+add_test(NotePrint_test)
+add_test(NotePrintf_test)
+add_test(NotePrintln_test)
+add_test(NoteRegion_test)
+add_test(NoteRequest_test)
+add_test(NoteRequestResponse_test)
+add_test(NoteRequestResponseJSON_test)
+add_test(NoteRequestResponseWithRetry_test)
+add_test(NoteRequestWithRetry_test)
+add_test(NoteReset_test)
+add_test(NoteResponseError_test)
+add_test(NoteSendToRoute_test)
+add_test(NoteSerialHooks_test)
+add_test(NoteSetContact_test)
+add_test(NoteSetEnvDefault_test)
+add_test(NoteSetEnvDefaultNumber_test)
+add_test(NoteSetFn_test)
+add_test(NoteSetFnI2C_test)
+add_test(NoteSetFnI2CMutex_test)
+add_test(NoteSetFnMutex_test)
+add_test(NoteSetFnNoteMutex_test)
+add_test(NoteSetFnSerial_test)
+add_test(NoteSetLocation_test)
+add_test(NoteSetLocationMode_test)
+add_test(NoteSetProductID_test)
+add_test(NoteSetSerialNumber_test)
+add_test(NoteSetSyncMode_test)
+add_test(NoteSetUploadMode_test)
+add_test(NoteSleep_test)
+add_test(NoteTemplate_test)
+add_test(NoteTime_test)
+add_test(NoteTimeSet_test)
+add_test(NoteTransaction_test)
+add_test(NoteTransactionHooks_test)
+add_test(NoteUserAgent_test)
+add_test(NoteWake_test)
+add_test(serialChunkedReceive_test)
+add_test(serialChunkedTransmit_test)
+add_test(serialNoteReset_test)
+add_test(serialNoteTransaction_test)
+
+if(NOTE_C_COVERAGE)
+    find_program(LCOV lcov REQUIRED)
+    message(STATUS "Found lcov: ${LCOV}")
+
+    target_compile_options(note_c PUBLIC --coverage -g -O0)
+    target_link_libraries(note_c gcov)
+
+    # Create the coverage directory and run ctest.
+    add_custom_target(
+        coverage
+        COMMAND mkdir -p coverage
+        # Zero out the coverage counters from any previous runs.
+        COMMAND lcov --zerocounters --directory ${NOTE_C_SRC_DIR}
+        COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure
+        WORKING_DIRECTORY ${CMAKE_CURENT_BINARY_DIR}
+    )
+    # These files are third party code that we aren't interested in testing
+    # ourselves, so we don't care about coverage for them.
+    set(
+        EXCLUDE_FROM_COVERAGE
+        "n_atof.c;n_b64.c;n_cjson.c;n_ftoa.c;n_md5.c;n_str.c"
+    )
+    foreach(EXCLUDE_FILE ${EXCLUDE_FROM_COVERAGE})
+        string(APPEND LCOV_EXCLUDE "--exclude '*/${EXCLUDE_FILE}' ")
+    endforeach()
+    # We don't care about coverage for the tests themselves.
+    string(APPEND LCOV_EXCLUDE "--exclude '*/test/*' ")
+    separate_arguments(LCOV_EXCLUDE_LIST NATIVE_COMMAND "${LCOV_EXCLUDE}")
+    # Run lcov to produce a coverage report in the coverage directory.
+    add_custom_command(
+        TARGET coverage POST_BUILD
+        COMMAND lcov --capture --no-external --directory ${NOTE_C_SRC_DIR} --rc lcov_branch_coverage=1 ${LCOV_EXCLUDE_LIST} --output-file lcov.info
+        COMMAND lcov --summary --rc lcov_branch_coverage=1 lcov.info
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/coverage
+    )
+    # The tests have to be built before we can generate the coverage report.
+    add_dependencies(coverage ${TEST_TARGETS})
+    # Delete the coverage directory when make clean is run.
+    set_property(
+        DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES
+        ${CMAKE_CURRENT_BINARY_DIR}/coverage
+    )
+endif(NOTE_C_COVERAGE)
diff --git a/src/note-c/test/README.md b/src/note-c/test/README.md
new file mode 100644
index 0000000..7a8919c
--- /dev/null
+++ b/src/note-c/test/README.md
@@ -0,0 +1,80 @@
+# Testing
+
+This directory contains note-c unit tests written in C++ using Catch2. The
+[Fake Function Framework](https://github.com/meekrosoft/fff) (fff) is used for
+mocking and is bundled with the test code (see fff.h).
+
+## Dependencies
+
+- [CMake](https://cmake.org/install), version 3.13+.
+- [Catch2](https://github.com/catchorg/Catch2), v3.
+  - If Catch2 isn't installed, we'll attempt to download and build Catch2 from
+    source.
+  - We require C++14, which is the minimum expected by Catch2 v3.
+
+## Running the Tests
+
+```sh
+mkdir build
+cd build
+cmake ..
+make -j
+ctest
+```
+
+Alternatively, scripts/run_unit_tests.sh will do all these steps for you. This
+script is also used by our CI pipeline (see the Dockerfile in
+.github/actions/run_unit_tests).
+
+### Notes
+
+- We forbid in-source builds, so creating a build directory (e.g. `mkdir build`)
+and building in there is mandatory.
+
+## CMake Options
+
+- BUILD_CATCH: Download and build Catch2 from source, rather than looking for an
+installed verison. Default: OFF.
+- COVERAGE: Adds the target `coverage` to the build. Requires lcov. To generate
+a coverage report, run `make coverage`.
+
+## Development
+
+For the most part, each function in the API gets its own test executable in
+test/src. The naming convention is FunctionName_test.cpp. Some functions make
+sense to test together, like the NotePayload* family, so they're exercised in
+one executable (NotePayload_test.cpp, in this case). Any functions that are
+mocked need to be added to the list of mocked functions in the root
+CMakeLists.txt (see MOCKED_FNS). Once written, the test needs to be added to
+test/CMakeLists.txt with a call to the `add_test` macro.
+
+Assuming you ran cmake with coverage enabled (`-DCOVERAGE=1`), ran `make
+coverage`, and are in the build directory, you can view the coverage report as
+HTML with:
+
+```sh
+cd test/coverage
+genhtml lcov.info -o tmp
+```
+
+This will generate HTML under test/coverage/tmp. Open index.html in your
+browser to view the report.
+
+### Style
+
+#### `CHECK` vs. `REQUIRE`
+
+[Catch2 offers 2 primary assertion macros]
+(https://github.com/catchorg/Catch2/blob/devel/docs/assertions.md): `REQUIRE`
+and `CHECK`. We prefer `CHECK` anywhere you need to assert something in a test
+case. However, if it doesn't make sense or it would cause a fault to continue a
+test case, `REQUIRE` should be used to exit the case immediately on failure.
+Example:
+
+```c
+REQUIRE(sizeof(expectedBuf) == actualLength);
+CHECK(!memcmp(expectedBuf, actualBuf, actualLength));
+```
+
+Here we don't want to continue if the lengths of the two buffers differ, as the
+`memcmp` may segfault.
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardBinary.cpp b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardBinary.cpp
new file mode 100644
index 0000000..b72bfe4
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardBinary.cpp
@@ -0,0 +1,15 @@
+#include "NotecardBinary.h"
+
+Notecard notecard;
+
+
+BinaryImage small_binary = { .name = "small", .length=small_img_len, .data=small_img_map };
+
+
+BufferBinaryGenerator small_image(small_binary);
+
+
+// ensure the virtual destructor is defined.
+BinaryGenerator::~BinaryGenerator() {}
+
+
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardBinary.h b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardBinary.h
new file mode 100644
index 0000000..703a7af
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardBinary.h
@@ -0,0 +1,1294 @@
+
+#pragma once
+
+#include <Arduino.h>
+#include <Notecard.h>
+#include <random>
+#include <math.h>
+#include <assert.h>
+#include "NotecardComms.h"
+#include "small_img.h"
+
+
+extern Notecard notecard;
+
+#define TINY_SIZE (2*1024)
+#define TINY_SIZE_NAME 2k
+#define SMALL_SIZE (20*1024)
+#define SMALL_SIZE_NAME 20k
+#define MEDIUM_SIZE (60*1024)
+#define MEDIUM_SIZE_NAME 60k
+#define LARGE_SIZE (91*1023)    // not a power of 2
+#define LARGE_SIZE_NAME 90k9
+#define XLARGE_SIZE (120*1023)  // ditto
+#define XLARGE_SIZE_NAME 119k8
+
+
+struct BinaryImage {
+    const char* name;
+    size_t length;
+    const uint8_t* data;
+};
+
+/**
+ * @brief Interface describing a generator that produces a stream of bytes.
+ *
+ */
+struct BinaryGenerator {
+
+    BinaryGenerator() {}
+    virtual ~BinaryGenerator();
+
+    virtual size_t length() const=0;
+    virtual size_t offset() const=0;
+    virtual size_t remaining() const
+    {
+        return length()-offset();
+    }
+    virtual bool isEOF() const
+    {
+        return remaining()==0;
+    }
+
+    virtual void reset()=0;
+    virtual int read()=0;
+    virtual size_t read(uint8_t* buf, size_t length)=0;
+    virtual size_t skip(size_t count)=0;
+};
+
+/**
+ * @brief Manages the offset and length, and provides a simple implementation of
+ * read(buffer, length).
+ */
+class AbstractBinaryGenerator : public BinaryGenerator
+{
+
+protected:
+    size_t _offset;
+    const size_t _length;
+
+    void resetOffset()
+    {
+        _offset = 0;
+    }
+    void incOffset(size_t amount)
+    {
+        _offset += amount;
+    }
+
+    virtual int readNext()=0;
+
+public:
+    AbstractBinaryGenerator(size_t length) : _offset(0), _length(length) {}
+
+    bool isEOF() const
+    {
+        return _offset >= _length;
+    }
+
+    virtual size_t offset() const override
+    {
+        return _offset;
+    }
+    virtual size_t length() const override
+    {
+        return _length;
+    }
+
+    int read() override
+    {
+        if (isEOF()) {
+            return -1;
+        } else {
+            int ch = readNext();
+            _offset++;
+            return ch;
+        }
+    }
+
+    size_t skip(size_t length) override
+    {
+        length = std::min(remaining(), length);
+        size_t count = 0;
+        while (length --> 0) {
+            int ch = readNext();
+            (void)ch;
+            assert(ch >= 0);
+            count++;
+        }
+        incOffset(count);
+        return count;
+    }
+
+    size_t read(uint8_t* buf, size_t length) override
+    {
+        length = std::min(remaining(), length);
+        size_t count = 0;
+        while (length --> 0) {
+            int ch = readNext();
+            assert(ch >= 0);
+            buf[count++] = uint8_t(ch);
+        }
+        incOffset(count);
+        return count;
+    }
+};
+
+/**
+ * @brief Maintains a view of another generator.
+ *
+ */
+class BinaryGeneratorView : public AbstractBinaryGenerator
+{
+    BinaryGenerator& _image;
+    size_t _viewOffset;
+
+    int readNext() override
+    {
+        return _image.read();
+    }
+
+public:
+
+    BinaryGeneratorView(BinaryGenerator& image, size_t offset, size_t length)
+        : AbstractBinaryGenerator(length), _image(image), _viewOffset(offset)
+    {
+    }
+
+    void reset() override
+    {
+        _image.reset();
+        _image.skip(_viewOffset);
+        resetOffset();
+    }
+
+    size_t read(uint8_t* buf, size_t length) override
+    {
+        // cap the length to what's remaining in this view
+        length = std::min(remaining(), length);
+        size_t count = _image.read(buf, length);
+        incOffset(count);
+        return count;
+    }
+
+};
+
+/**
+ * @brief Generates binary data from a buffer. The length of the generated data
+ * is assumed to be less than or equal to the length of the buffer.
+ */
+class BufferBinaryGenerator : public AbstractBinaryGenerator
+{
+    const uint8_t* _buffer;
+
+    int readNext() override
+    {
+        return _buffer[_offset];
+    }
+
+public:
+    BufferBinaryGenerator(const uint8_t* buffer, size_t length)
+        : AbstractBinaryGenerator(length), _buffer(buffer)
+    {}
+
+    BufferBinaryGenerator(const BinaryImage& image):
+        AbstractBinaryGenerator(image.length), _buffer(image.data) {}
+
+    void reset() override
+    {
+        resetOffset();
+    }
+
+    size_t read(uint8_t* buffer, size_t length) override
+    {
+        size_t toRead = std::min(remaining(), length);
+        memcpy(buffer, _buffer+offset(), toRead);
+        incOffset(toRead);
+        return toRead;
+    }
+};
+
+
+class RandomBinaryGenerator: public AbstractBinaryGenerator
+{
+    std::uniform_int_distribution<uint8_t> _distribution;
+    std::ranlux24_base _generator;
+    int _seed;
+
+protected:
+    int readNext()
+    {
+        return _distribution(_generator);
+    }
+
+public:
+    RandomBinaryGenerator(size_t length, uint32_t seed)
+        : AbstractBinaryGenerator(length), _seed(seed)
+    {
+        _generator.seed(_seed);
+    }
+
+    void reset()
+    {
+        resetOffset();
+        _generator.seed(_seed);
+    }
+};
+
+
+class RepeatedBinaryGenerator: public AbstractBinaryGenerator
+{
+    BinaryGenerator& _source;
+
+    int readNext() override
+    {
+        if (_source.isEOF()) {
+            _source.reset();
+        }
+        return _source.read();
+    }
+
+public:
+
+    RepeatedBinaryGenerator(BinaryGenerator& source, size_t length)
+        : AbstractBinaryGenerator(length), _source(source) {}
+
+    void reset() override
+    {
+        resetOffset();
+        _source.reset();
+    }
+
+    size_t read(uint8_t* buffer, size_t length)
+    {
+        size_t toRead = std::min(length, remaining());
+        size_t count = 0;
+        while (toRead > 0) {
+            size_t bytesRead = _source.read(buffer+count, toRead);
+            toRead -= bytesRead;
+            count += bytesRead;
+            if (!bytesRead) {
+                _source.reset();
+            }
+        }
+        incOffset(count);
+        return count;
+    }
+};
+
+class NotecardBinary
+{
+
+public:
+
+    static const size_t MAX_CHUNK_SIZE = 4096;
+    static const size_t MAX_I2C_CHUNK_SIZE = MAX_CHUNK_SIZE;
+    static const size_t MAX_SERIAL_CHUNK_SIZE = MAX_CHUNK_SIZE;
+    static const size_t MAX_AUX_SERIAL_CHUNK_SIZE = MAX_CHUNK_SIZE;
+
+    size_t maxChunkSize(NotecardInterface iface)
+    {
+        size_t chunkSize = 0;
+        switch (iface) {
+        case NOTECARD_IF_I2C:
+            chunkSize = MAX_I2C_CHUNK_SIZE;
+            break;
+        case NOTECARD_IF_SERIAL:
+            chunkSize = MAX_SERIAL_CHUNK_SIZE;
+            break;
+        case NOTECARD_IF_AUX_SERIAL:
+            chunkSize = MAX_AUX_SERIAL_CHUNK_SIZE;
+            break;
+        }
+        return chunkSize;
+    }
+
+
+    void notecardDebugStreamInitialize()
+    {
+#if defined(NOTECARD_DEBUG_STLINK)
+        dbgSerial.begin(115200);
+#endif
+        notecard.setDebugOutputStream(dbgSerial);
+    }
+
+    bool notecardConnectionMode()
+    {
+        J *req = notecard.newRequest("hub.set");
+
+#if !defined(PRODUCT_UID) && defined(DEFAULT_PRODUCT_UID)
+#define PRODUCT_UID DEFAULT_PRODUCT_UID
+#endif
+
+// This is the unique Product Identifier for your device
+#ifndef PRODUCT_UID
+#define PRODUCT_UID "" // "com.my-company.my-name:my-project"
+#pragma message "PRODUCT_UID is not defined in this example. Please ensure your Notecard has a product identifier set before running this example or define it in code here. More details at https://dev.blues.io/tools-and-sdks/samples/product-uid"
+#endif
+
+        if (PRODUCT_UID[0]) {
+            JAddStringToObject(req, "product", PRODUCT_UID);
+        }
+
+        JAddStringToObject(req, "mode", "continuous");
+
+        return notecard.sendRequestWithRetry(req, 5); // 5 seconds
+    }
+
+    /**
+     * @brief This struct is passed to the transfer callback after each iteration of the Notecard's
+     * binary buffer being filled to the requested capacity.
+     */
+    struct TransferDetails {
+        const char* name;                   // a name for this transfer
+        size_t transferred;                 // bytes transferred so far (not including this transfer)
+        size_t total;                       // the total number of bytes to be transferred
+        size_t currentTransferIndex;        // The index (i.e. chunk) of this transfer, 0-based.
+        size_t currentTransferSize;         // the current transfer size (the combined size of all card.binary.pot requests)
+        const uint8_t* currentTransferMD5;  // MD5 of the current transfer data
+        BinaryGenerator& currentTransferImage;      // the current image for this transfer
+        bool isComplete;                    // true when this is the last transfer
+        BinaryGenerator& totalImage;        // the complete image
+        const uint8_t* totalMD5;            // MD5 hash for the complete transfer. valid only when isComplete is true.
+        size_t totalChunks;                 // the total number of chunks sent. Valid only when isComplete is true.
+    };
+
+    struct TransferHandlerContext {
+        int tries;
+    };
+
+    using transfer_cb_t = std::function<bool(const TransferDetails&, TransferHandlerContext&)>;
+
+    /**
+     * @brief A no-op callback that returns success. Use this when no action is needed after filling the Notecard binary buffer beyond
+     * the validation that always happens.
+     */
+    static bool accept_transfer_callback(const TransferDetails& details, const TransferHandlerContext& ctx)
+    {
+        return true;
+    }
+
+
+    struct BinaryTransfer {
+        /**
+         * @brief The name of the image being transferred.
+         */
+        const char* imageName;
+
+        /**
+         * @brief The complete image to sent, chunked, and with a maximum card.binary buffer size.
+         */
+        BinaryGenerator& image;
+        /**
+         * @brief The size of each chunk of data sent to the notecard.
+         */
+        size_t chunkSize;
+        /**
+         * @brief A work buffer used to hold each encoded chunk.
+         */
+        uint8_t* buffer;
+        /**
+         * @brief The size of the work buffer
+         */
+        size_t bufferLength;
+
+        /**
+         * @brief The maximum amount of data to put in the Notecard's binary buffer.
+         */
+        size_t maxBinarySize;
+
+        /**
+         * @brief When true, validate the data using `card.binary.get`.
+         */
+        bool validate;
+
+        /**
+         * @brief The chunk sizes to use for retrieving the binary via card.binary.get.
+         * Default is to use maxCardBinary.
+         */
+        const int32_t* validateChunkSizes;
+        size_t validateChunkSizesCount;
+
+
+        /**
+         * @brief A transfer callback. Once the data has been (optionally) validated, invoke the callback to
+         * process the binary on the notecard further. (E.g. via note.add or web.get)
+         */
+        transfer_cb_t transfer_cb;
+    };
+
+    bool transferBinary(const BinaryTransfer& tx)
+    {
+        return _transferBinary(tx.imageName, tx.image, tx.chunkSize, tx.buffer, tx.bufferLength, tx.maxBinarySize, tx.validate, tx.validateChunkSizes, tx.validateChunkSizesCount, tx.transfer_cb);
+    }
+
+    /**
+     * @brief Transfers an image to the notecard in chunks of `chunkSize`, with a maximum
+     * transferred to the Notecard being `maxBinarySize` until all the data has been transferred.
+     * A callback is provided to allow the caller to handle each complete buffer transfer to the notecard,
+     * before the buffer is reset and the next one begins.
+     * @param imageName The name of the image.
+     * @param image The binary image to send.
+     * @param chunkSize The size of each chunk sent with `card.binary.put`
+     * @param buffer A transfer buffer large enough to hold each encoded chunk.
+     * @param bufferLength The length of the transfer buffer.
+     * @param maxBinarySize The maximum amount of data to transfer via successive calls to `card.binary.put` before
+     *  clearing the buffer.
+     * @param validate When true `card.binary.get` is used to validate the buffer contents. Note: This has the
+     *  side-effect of clearing the buffer.
+     * @param validateChunkSizes The chunk sizes to use when validating the binary buffer using `card.binary.get`.
+     * @param validateChunkSizesCount The number of chunk sizes in the validateChunkSizes array. When 0, the entire buffer is validated
+     * with one call to `card.binary.get`.
+     * @param transfer_cb Callback function that is invoked after every successful complete transfer to the Notecard.
+     * @return true
+     * @return false
+     */
+    bool _transferBinary(const char* imageName, BinaryGenerator& image, size_t chunkSize, uint8_t* buffer, size_t bufferLength, size_t maxBinarySize, bool validate, const int32_t* validateChunkSizes, size_t validateChunkSizesCount, transfer_cb_t transfer_cb)
+    {
+        const size_t totalSize = image.length();
+        if (totalSize==0) {
+            dbgSerial.println("Image length is 0!");
+            return false;
+        }
+
+        if (!checkBufferSize(chunkSize, bufferLength)) {
+            return false;
+        }
+
+        dbgSerial.print("Sending image of size ");
+        dbgSerial.print(totalSize, DEC);
+        dbgSerial.print(", in transport chunks of size ");
+        dbgSerial.print(chunkSize, DEC);
+        dbgSerial.print(", with a maximum Notecard binary size of ");
+        dbgSerial.println(maxBinarySize, DEC);
+
+        image.reset();
+        size_t totalTransferred = 0;
+        size_t totalTransferCount = 0;
+        uint8_t totalMD5[NOTE_MD5_HASH_SIZE];
+        NoteMD5Context totalMD5Context;
+        NoteMD5Init(&totalMD5Context);
+
+        // transfer up to maxTransferSize bytes via chunked NoteBinaryTransmit
+        while (totalTransferred!=totalSize) {
+            uint8_t currentMD5[NOTE_MD5_HASH_SIZE];
+            NoteMD5Context currentMD5Context;
+            NoteMD5Init(&currentMD5Context);
+
+            size_t chunkIndex = 0;
+            const size_t binaryTransferSize = std::min(maxBinarySize, image.remaining());
+            BinaryGeneratorView transferImage(image, totalTransferred, binaryTransferSize);
+            size_t bytesToTransfer = binaryTransferSize;
+            // do the transfer in chunks
+            while (bytesToTransfer) {
+                const size_t thisChunk = bytesToTransfer >= chunkSize ? chunkSize : bytesToTransfer;
+                const size_t offset = chunkSize * chunkIndex;
+                dbgSerial.print("Sending transport chunk ");
+                dbgSerial.print(chunkIndex, DEC);
+                dbgSerial.print(", offset: ");
+                dbgSerial.print(offset, DEC);
+                dbgSerial.print(", length: ");
+                dbgSerial.print(thisChunk, DEC);
+                dbgSerial.println("...");
+
+                size_t bytesRead = transferImage.read(buffer, thisChunk);
+                if (bytesRead != thisChunk) {
+                    dbgSerial.print("Insufficient data from image: expected ");
+                    dbgSerial.print(thisChunk, DEC);
+                    dbgSerial.print(", got ");
+                    dbgSerial.println(bytesRead, DEC);
+                    return false;
+                }
+
+                // update the MD5 contexts before note-c modifies the buffer
+                NoteMD5Update(&currentMD5Context, buffer, thisChunk);
+                NoteMD5Update(&totalMD5Context, buffer, thisChunk);
+
+                auto bufferFull = []() -> bool { return false; };
+
+                if (transferBinaryChunk(buffer, thisChunk, bufferLength, offset, bufferFull)) {
+                    bytesToTransfer -= thisChunk;
+                    chunkIndex++;
+                } else {
+                    // exit the loop so we can print out messages and optionally handle
+                    // validation (even on error)
+                    goto outer; // sometimes necessary since we dont have labelled breaks in C++
+                }
+
+            }
+outer:
+            const size_t actualTransferSize = binaryTransferSize-bytesToTransfer;
+            if (bytesToTransfer) {
+                dbgSerial.print("TRANSFER FAILED: ");
+                dbgSerial.print(imageName);
+                dbgSerial.print(" - transferred ");
+                dbgSerial.print(actualTransferSize, DEC);
+                dbgSerial.print("(0x");
+                dbgSerial.print(actualTransferSize, HEX);
+                dbgSerial.print(") bytes of ");
+                dbgSerial.print(binaryTransferSize, DEC);
+                dbgSerial.print("(0x");
+                dbgSerial.print(binaryTransferSize, HEX);
+                dbgSerial.println(")");
+                return false;
+            }
+
+            NoteMD5Final(currentMD5, &currentMD5Context);
+
+            dbgSerial.print(imageName);
+            dbgSerial.print(": Successfully transferred ");
+            dbgSerial.print(binaryTransferSize, DEC);
+            dbgSerial.print("(0x");
+            dbgSerial.print(binaryTransferSize, HEX);
+            dbgSerial.println(") bytes.");
+            dbgSerial.println("Validating received binary data...");
+
+            TransferDetails tx = {
+                .name = imageName,
+                .transferred = totalTransferred,
+                .total = totalSize,
+                .currentTransferIndex = totalTransferCount,
+                .currentTransferSize = binaryTransferSize,
+                .currentTransferMD5 = currentMD5,
+                .currentTransferImage = transferImage,
+                .isComplete =  (totalTransferred + binaryTransferSize)==totalSize,
+                .totalImage = image,
+                .totalMD5 = totalMD5,
+            };
+
+            if (tx.isComplete) {
+                NoteMD5Final(totalMD5, &totalMD5Context);
+                tx.totalChunks = tx.currentTransferIndex+1;
+            }
+
+            if (validate) {
+                int32_t defaultSizes[1] = { 0 };
+                if (!validateChunkSizesCount || !validateChunkSizes) {
+                    validateChunkSizesCount = 1;
+                    validateChunkSizes = defaultSizes;
+                }
+                for (size_t idx=0; idx<validateChunkSizesCount; idx++) {
+                    int32_t validateChunkSize = validateChunkSizes[idx];
+                    int32_t actualChunkSize = validateChunkSize;
+                    if (actualChunkSize<=0) {
+                        actualChunkSize += tx.currentTransferImage.length();
+                    }
+                    dbgSerial.print("Validating buffer contents with length given=");
+                    dbgSerial.print(validateChunkSize, DEC);
+                    dbgSerial.print(" (actual=");
+                    dbgSerial.print(actualChunkSize, DEC);
+                    dbgSerial.println(")");
+                    if (!validateBinaryReceived(tx, buffer, bufferLength, actualChunkSize)) {
+                        dbgSerial.print("FAIL: validation failed with chunk size given=");
+                        dbgSerial.print(validateChunkSize, DEC);
+                        dbgSerial.print(" (actual=");
+                        dbgSerial.print(actualChunkSize, DEC);
+                        dbgSerial.println(")");
+                        return false;
+                    }
+                }
+            }
+
+            int tries = 0;
+            TransferHandlerContext ctx = { .tries = 0 };
+            while (++ctx.tries <= 5) {
+                if (!transfer_cb(tx, ctx)) {
+                    dbgSerial.print("FAIL: (try ");
+                    dbgSerial.print(ctx.tries, DEC);
+                    dbgSerial.print(") ");
+                    dbgSerial.print(imageName);
+                    dbgSerial.println(" - Validation cancelled by transfer handler");
+                    if (ctx.tries<0) {
+                        dbgSerial.println("Handler is not idempotent, giving up.");
+                    }
+                } else {
+                    if (tries>1) {
+                        dbgSerial.print("SUCCESS: (try ");
+                        dbgSerial.print(ctx.tries, DEC);
+                        dbgSerial.print(") ");
+                        dbgSerial.print(imageName);
+                        dbgSerial.println(" - transfer handler successful");
+                    }
+                    ctx.tries = 0;  // say we're good
+                    break;
+                }
+            }
+            if (ctx.tries) {
+                return false;
+            }
+
+            totalTransferred += actualTransferSize;
+            totalTransferCount++;
+            if (totalTransferred!=totalSize) {
+                // reset the buffer for the next load
+                NoteBinaryStoreReset();
+            }
+        }
+        return totalTransferred==totalSize;
+    }
+
+    bool checkBufferSize(size_t chunkSize, size_t bufferSize)
+    {
+        size_t requiredSize = NoteBinaryCodecMaxEncodedLength(chunkSize);
+
+        NoteDebugf("Requested size: %u, available size: %u\n", requiredSize, bufferSize);
+
+        if (requiredSize > bufferSize) {
+            NoteDebugf("The required buffer size is larger than the allocated buffer: %d > %d\n", requiredSize, bufferSize);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * @brief Compares the buffer sent to the notecard with the data read back.
+     * @param tx    Current transfer details.
+     * @param buffer Scratch buffer for running the validation.
+     * @param bufferLength Length of the scratch buffer.
+     * @param validateChunkSize
+     * @return true
+     * @return false
+     */
+    static bool validateBinaryReceived(const TransferDetails& tx, uint8_t* buffer, size_t bufferLength, size_t validateChunkSize)
+    {
+        bool success = false;
+
+        tx.currentTransferImage.reset();    // back to the beginning to the image can be re-read.
+        size_t rxBufferSize = NoteBinaryCodecMaxEncodedLength(validateChunkSize);
+        uint8_t* rxBuffer = nullptr;
+        const char* err;
+
+        dbgSerial.print("Validating card binary, ");
+        dbgSerial.print(tx.transferred, DEC);
+        dbgSerial.print("/");
+        dbgSerial.print(tx.total, DEC);
+        dbgSerial.print(" size ");
+        dbgSerial.println(tx.currentTransferSize, DEC);
+
+        if (nullptr==(rxBuffer=(uint8_t*)malloc(rxBufferSize))) {
+            dbgSerial.print("Unable to allocate ");
+            dbgSerial.print(rxBufferSize, DEC);
+            dbgSerial.println(" bytes for receive buffer.");
+        } else {
+            size_t offset = 0;
+            size_t totalBytesRead = 0;
+            bool ok = true;
+            while (ok && tx.currentTransferImage.remaining()) {
+                ok = false;
+                const size_t chunkLength = std::min(tx.currentTransferImage.remaining(), validateChunkSize);
+                if ((err = NoteBinaryStoreReceive(rxBuffer, rxBufferSize, offset, chunkLength))!=nullptr) {
+                    dbgSerial.print("Error receiving binary: ");
+                    dbgSerial.println(err);
+                } else {
+                    dbgSerial.print("card.binary.get Receive buffer size requested: ");
+                    dbgSerial.println(rxBufferSize, DEC);
+                    dbgSerial.print("Validating received data, length ");
+                    dbgSerial.print(chunkLength, DEC);
+                    dbgSerial.print("(0x");
+                    dbgSerial.print(chunkLength, HEX);
+                    dbgSerial.println(")...");
+                    size_t chunkBytesRead = 0;
+                    // read and validate the image against the buffer in chunks.
+                    BinaryGenerator& image = tx.currentTransferImage;   // alias
+                    while (chunkBytesRead < chunkLength) {
+                        size_t thisChunk = std::min(bufferLength, chunkLength);
+                        size_t chunkRead = image.read(buffer, thisChunk);
+                        assert(chunkRead == thisChunk);
+
+                        for (size_t i=0; i<chunkRead; i++) {
+                            const uint8_t* src = rxBuffer+chunkBytesRead;
+                            if (src[i]!=buffer[i]) {
+                                size_t offset = chunkBytesRead + i;
+                                dbgSerial.print("Received buffer differs from image at offset ");
+                                dbgSerial.print(offset, DEC);
+                                dbgSerial.print("(0x");
+                                dbgSerial.print(offset, HEX);
+                                dbgSerial.print("): ");
+                                dbgSerial.print(buffer[i], DEC);
+                                dbgSerial.print(" != ");
+                                dbgSerial.println(src[i], DEC);
+                                goto cancel;
+                            }
+                        }
+                        chunkBytesRead += chunkRead;
+                    }
+                    totalBytesRead += chunkBytesRead;
+                    ok = true;
+                }
+            }
+cancel:
+            if (totalBytesRead==tx.currentTransferImage.length()) {
+                dbgSerial.println("Validated received data.");
+
+#if defined(NOTE_BINARY_CHECK_EXTRA_DATA_TIMEOUT)
+                // This is not necessary to catch the error, since other requests afterwards will fail.
+                // note-c also includes a test for extra data, but it doesn't always succeed at lower baudrates
+                // see how much data is left on the serial bus
+                size_t duration = 0;
+                size_t size = readDataUntilTimeout(Serial1, NOTE_BINARY_CHECK_EXTRA_DATA_TIMEOUT, rxBuffer, rxBufferSize, receivedLength, duration);
+                if (size) {
+                    dbgSerial.print("additional data after binary: ");
+                    dbgSerial.print(size, DEC);
+                    dbgSerial.print("(0x");
+                    dbgSerial.print(size, HEX);
+                    dbgSerial.print(") bytes read in ");
+                    dbgSerial.print(duration, DEC);
+                    dbgSerial.println("ms");
+                } else
+#endif
+                    success = true;
+            }
+        }
+        free(rxBuffer);
+
+        return success;
+    }
+
+    bool transferBinaryChunk(uint8_t* chunk, size_t chunkLength, size_t bufferLength, size_t offset, std::function<bool()> binaryBufferFull)
+    {
+        const char *err = NoteBinaryStoreTransmit(chunk, chunkLength, bufferLength, offset);
+
+        if (err) {
+            dbgSerial.print("Error transferring binary chunk: ");
+            dbgSerial.println(err);
+            if (!strstr(err, "exceeds available memory")) {
+                return binaryBufferFull();
+            }
+            return false;
+        }
+        return true;
+    }
+
+    static bool waitForNotecardConnected(uint32_t timeoutMs)
+    {
+        uint32_t start = millis();
+        bool connected = false;
+        while (!connected && millis()-start<timeoutMs) {
+            if (J *rsp = NoteRequestResponse(NoteNewRequest("hub.status"))) {
+                if (!NoteResponseError(rsp)) {
+                    connected = JGetBool(rsp, "connected");
+                    if (!connected) {
+                        delay(10000);
+                    }
+                } else {
+                    delay(2000);
+                }
+                JDelete(rsp);
+            }
+        }
+        return connected;
+    }
+};
+
+
+#ifndef NOT_CONNECTED_TIMEOUT
+#define NOT_CONNECTED_TIMEOUT 5*60*1000
+#endif
+
+
+#define MIME_APPLICATION_OCTETSTREAM "application/octet-stream"
+
+/**
+ * @brief Helpers needed by file handlers.
+ *
+ */
+class FileHandler
+{
+protected:
+    /**
+     * @brief The route alias to the MD5 server. Used to retrieve the chunks sent, the complete transfer MD5/length
+     * and to delete the directory containing the chunk(s).
+     */
+    const char* alias;
+    /**
+     * @brief When non-null, sets the `content` property of the `web.get` request.
+     * This is a workaround for a bug in Notehub that tests for `binary/octet-stream` rather than
+     * the IANA-registered `application/octet-stream`.
+     */
+    const char* chunkContent;
+public:
+
+    FileHandler(const char* alias, const char* chunkContent) :
+        alias(alias), chunkContent(chunkContent) {}
+
+    bool validateReceivedContent(const NotecardBinary::TransferDetails& tx, const char* name, bool chunked)
+    {
+        // to verify chunks and the total content, the md5 server must be started with the `--save` flag
+        bool success = true;
+
+        if (chunked) {
+            // this is also used with `note.add` which may return before Notehub has routed
+            // the event. Try for a while.
+            bool shouldRetry = true;
+            int retries = 10;   // it can take a minute for the note to be sent and routed
+            while (shouldRetry && retries-->0) {
+                success = validateReceivedChunk(tx, name, &shouldRetry);
+                if (!success) {
+                    delay(10000);
+                }
+            }
+        }
+        if (success && tx.isComplete) {
+            success = validateTotalContent(tx, name, chunked);
+        }
+        if (!success || tx.isComplete) {
+            success = success && deleteContent(tx, name);
+        }
+        return success;
+    }
+
+    J* parseWebResponse(size_t length)
+    {
+        // decode the json response as a troubleshooting aid
+        size_t rxSize = NoteBinaryCodecMaxEncodedLength(length);
+        uint8_t rxBuf[rxSize];
+        uint32_t dataLen = length;
+        J* response = nullptr;
+        const char* err = NoteBinaryStoreReceive(rxBuf, rxSize, 0, dataLen);
+        if (err) {
+            dbgSerial.print("error retrieving payload: ");
+            dbgSerial.println(err);
+        } else {
+            dbgSerial.print("response content from card.binary: ");
+            dbgSerial.println((const char*)rxBuf);
+            response = JParse((char*)rxBuf);
+        }
+        return response;
+    }
+
+private:
+    /**
+     * @brief Performs a web.get request and compares the content with the chunk just processed.
+     * This doesn't depend on the state of the binary buffer, and is idempotent.
+     * @param tx        The transfer details about the current part of the image to verify.
+     * @param name      The name of the image as given to the endpoint.
+     * @param shouldRetry  [out] whether the error represents a retriable error.
+     */
+    bool validateReceivedChunk(const NotecardBinary::TransferDetails& tx, const char* name, bool* shouldRetry)
+    {
+        bool success = false;
+        bool retry = false;
+        J *req = notecard.newRequest("web.get");
+        JAddStringToObject(req, "route", alias);
+        if (name) {
+            char buf[256];
+            buf[0] = 0;
+            snprintf(buf, sizeof(buf), "%s?chunk=%d", name, tx.currentTransferIndex);
+            JAddStringToObject(req, "name", buf);
+        }
+        // todo - remove this
+        JAddStringToObject(req, "content", "application/octet-stream");
+        JAddBoolToObject(req, "binary", true);
+        J* rsp = notecard.requestAndResponse(req);
+        if (!rsp) {
+            dbgSerial.println("NULL response to `web.get`");
+        } else {
+            int result = JGetNumber(rsp, "result");
+            J* body = JGetObject(rsp, "body");
+            int cobs = JGetNumber(rsp, "cobs");
+            int length = JGetNumber(rsp, "length");
+
+            const char* err = JGetString(rsp, "err");
+            retry = result==404 || result==503 || result==504;
+            if (err && err[0]) {
+                dbgSerial.print("web.get failed with error: ");
+                dbgSerial.println(err);
+            } else if (result<200 || result>=300) {
+                dbgSerial.print("web.get result was: ");
+                dbgSerial.println(result, DEC);
+            } else if (!body) {
+                dbgSerial.println("web.get body is not present");
+            } else if (!cobs) {
+                dbgSerial.println("web.get expected response property 'cobs' is not present");
+            } else if (!length) {
+                dbgSerial.println("web.get expected response property 'length' is not present");
+            } else if (length!=int(tx.currentTransferSize)) {
+                dbgSerial.print("web.get length!=chunkTransferSize (");
+                dbgSerial.print(length, DEC);
+                dbgSerial.print("!=");
+                dbgSerial.print(tx.currentTransferSize, DEC);
+                dbgSerial.println(")");
+            } else {
+                // validate the binary buffer against the last chunk sent
+                size_t bufferLength = 4097; // just to be nasty ;-)
+                uint8_t* buffer = (uint8_t*)malloc(bufferLength);
+                if (buffer) {
+                    // TODO: NOTE_C_BINARY_RX_ALL doesn't work at present. Using the real size.
+                    success = NotecardBinary::validateBinaryReceived(tx, buffer, bufferLength, length);
+                    free(buffer);
+                } else {
+                    dbgSerial.println("Unable to allocate 4k buffer to verify content");
+                }
+            }
+            if (!success && length && length<1024) {
+                J* response_content = parseWebResponse(length);
+                JDelete(response_content);
+            }
+
+            JDelete(rsp);
+        }
+        *shouldRetry = retry && !success;
+        return success;
+    }
+
+    /**
+     * @brief Validates all chunks sent to the endpoint by retrieving the md5 and length
+     * of all chunks sent.
+     *
+     * @param tx
+     * @param name
+     * @param chunked Whether there were multiple chunks sent to the endpoint or not.
+     */
+    bool validateTotalContent(const NotecardBinary::TransferDetails& tx, const char* name, bool chunked)
+    {
+        // get the total md5 for all chunks
+        bool success = false;
+        J *req = notecard.newRequest("web.get");
+        JAddStringToObject(req, "route", alias);
+        if (name) {
+            JAddStringToObject(req, "name", name);
+        }
+        J* rsp = notecard.requestAndResponse(req);
+        if (!rsp) {
+            dbgSerial.println("NULL response to `web.get`");
+        } else {
+            int result = JGetNumber(rsp, "result");
+            J* body = JGetObject(rsp, "body");
+            int cobs = JGetNumber(rsp, "cobs");
+            const char* err = JGetString(rsp, "err");
+            if (err && err[0]) {
+                dbgSerial.print("web.get failed with error: ");
+                dbgSerial.println(err);
+            } else if (result<200 || result>=300) {
+                dbgSerial.print("web.get result was: ");
+                dbgSerial.println(result, DEC);
+            } else if (!body) {
+                dbgSerial.println("web.get body is not present");
+            } else if (cobs) {
+                dbgSerial.println("web.get unexpected response property 'cobs' is present");
+            } else {
+                size_t expectedChunks = chunked ? tx.totalChunks : 1;
+                size_t actualLength = JGetNumber(body, "length");
+                size_t actualChunks = JGetNumber(body, "chunks");
+                const char* actualMD5String = JGetString(body, "md5");
+                char expectedMD5String[NOTE_MD5_HASH_STRING_SIZE];
+                NoteMD5HashToString((uint8_t*)tx.totalMD5, expectedMD5String, sizeof(expectedMD5String));
+                if (!actualMD5String) {
+                    actualMD5String = "not a string";
+                }
+                if (strcmp(actualMD5String, expectedMD5String)) {
+                    dbgSerial.print("web.get MD5 actual!=expected: ");
+                    dbgSerial.print(actualMD5String);
+                    dbgSerial.print(" != ");
+                    dbgSerial.println(expectedMD5String);
+                } else if (actualLength!=tx.total) {
+                    dbgSerial.print("web.get total length: actual != expected: ");
+                    dbgSerial.print(actualLength, DEC);
+                    dbgSerial.print(" != ");
+                    dbgSerial.println(tx.total, DEC);
+                } else if (actualChunks!=expectedChunks) {
+                    dbgSerial.print("web.get total chunks: actual != expected: ");
+                    dbgSerial.print(actualChunks, DEC);
+                    dbgSerial.print(" != ");
+                    dbgSerial.println(expectedChunks, DEC);
+                } else {
+                    dbgSerial.print("web.get response validated: md5=");
+                    dbgSerial.print(actualMD5String);
+                    dbgSerial.print(", chunks=");
+                    dbgSerial.print(actualChunks, DEC);
+                    dbgSerial.print(", length=");
+                    dbgSerial.println(actualLength, DEC);
+                    success = true;
+                }
+            }
+            JDelete(rsp);
+        }
+        return success;
+    }
+
+    /**
+     * @brief Perform a `web.delete` request to remove the directory containing the
+     * saved files.
+     */
+    bool deleteContent(const NotecardBinary::TransferDetails& tx, const char* name)
+    {
+        bool success = false;
+        if (J* req = notecard.newRequest("web.delete")) {
+            JAddStringToObject(req, "route", alias);
+            if (name) {
+                JAddStringToObject(req, "name", name);
+            }
+            J* rsp = notecard.requestAndResponse(req);
+            if (rsp) {
+                int result = JGetNumber(rsp, "result");
+                if (result != 200) {
+                    dbgSerial.print("HTTP status (");
+                    dbgSerial.print(result, DEC);
+                    dbgSerial.print(") trying to delete ");
+                    dbgSerial.println(name);
+                } else {
+                    success = true;
+                }
+                JDelete(rsp);
+            } else {
+                dbgSerial.println("NULL response received to `web.delete`.");
+            }
+        } else {
+            dbgSerial.println("Could not create request.");
+        }
+        return success;
+    }
+};
+
+/**
+ * @brief Posts data to the md5 server endpoint and validates the expected length and md5 against
+ * the response received. Can operated in chunked mode, or unchunked mode (from the perspective
+ * of the endpoint.)
+ *
+ * In Chunked mode, the endpoint receives each filled card.binary buffer as it arrives.
+ * In Unchunked mode, the endpoint receives just one payload containing the entire image.
+ *
+ * After the data has been sent, a `web.get` request is used to retrieve the total length and md5
+ * for the entire image, and the number of chunks received.
+ */
+class WebPostHandler : public FileHandler
+{
+    const char* name;
+    const char* content;
+    bool chunked;   // When true send each chunk directly to the endpoint. When false, have notehub combine the chunks and send all at once.
+    bool webPut;
+
+public:
+    /**
+     * @brief Construct a new Web Post Handler object
+     *
+     * @param alias
+     * @param name
+     * @param content
+     * @param chunked When true, each completed binary transfer is sent to the server. When false
+     *  the transfers are combined and sent to the server in one hit.
+     * @param verify  In chunked mode, verify the md5 of all chunks received by the server.
+     */
+    WebPostHandler(const char* alias, const char* name, const char* content, bool chunked, bool webPut)
+        : FileHandler(alias, MIME_APPLICATION_OCTETSTREAM), name(name), content(content), chunked(chunked), webPut(webPut) {}
+
+    /**
+     * @brief Sends a web.post request with the binary buffer as content. In chunked mode,
+     * each request is sent to the endpoint immediately. In non-chunked mode, the requests
+     * are assembled by notehub and sent as a single request to the endpoint.
+     *
+     * @param tx
+     * @return true
+     * @return false
+     */
+    bool handleTransfer(const NotecardBinary::TransferDetails& tx, const NotecardBinary::TransferHandlerContext& ctx)
+    {
+        bool success = false;
+
+        if (!NotecardBinary::waitForNotecardConnected(NOT_CONNECTED_TIMEOUT)) {
+            dbgSerial.println("Cannot perform web.* request, Notecard not connected.");
+            return false;
+        }
+
+        if (tx.currentTransferSize==tx.total) {
+            chunked = false;    // only one chunk equal to the total
+        }
+
+        // in "chunked" mode, each chunk is sent to the server (no offset/total in web.post).
+        // The expected MD5 is the current transfer MD5
+        // in "non-chunked" mode, only the last request (when tx.isComplete is true) sends data to the route
+        // No response is expected.
+        const uint8_t* expectedMD5 = chunked ? tx.currentTransferMD5 : tx.totalMD5;
+        const size_t expectedLength = chunked ? tx.currentTransferSize : tx.total;
+
+        if (J *req = notecard.newRequest(webPut ? "web.put" : "web.post")) {
+            JAddStringToObject(req, "route", alias);
+            if (name) {
+                char buf[256];
+                buf[0] = 0;
+                strncat(buf, name, sizeof(buf)-1);
+                if (chunked) {
+                    snprintf(buf, sizeof(buf), "%s?chunk=%d", name, tx.currentTransferIndex);
+                }
+                JAddStringToObject(req, "name", buf);
+            }
+            if (content) {
+                JAddStringToObject(req, "content", content);
+            }
+            JAddBoolToObject(req, "binary", true);
+            JAddBoolToObject(req, "verify", true);
+            if (!chunked) { // have notehub concatenate all the chunks
+                JAddNumberToObject(req, "offset", tx.transferred);
+                JAddNumberToObject(req, "total", tx.total);
+            }
+            J* rsp = notecard.requestAndResponse(req);
+            if (rsp) {
+                int result = JGetNumber(rsp, "result");
+                J* body = JGetObject(rsp, "body");
+                int cobs = JGetNumber(rsp, "cobs");
+                int length = JGetNumber(rsp, "length");
+                J* response_content = nullptr;
+                const char* err = nullptr;
+                if (cobs && length) {
+                    response_content = parseWebResponse(length);
+                }
+
+                err = JGetString(rsp, "err");
+                if (err && err[0]) {
+                    dbgSerial.print("web.post failed with error: ");
+                    dbgSerial.println(err);
+                }
+                // Notehub returns 100: Continue for all web.post with offset apart from the last
+                else if (!chunked && !tx.isComplete && result!=100) {
+                    dbgSerial.print("expected web.post result of 100 for all fragments apart from the last, but was: ");
+                    dbgSerial.println(result, DEC);
+                } else if ((chunked || tx.isComplete) && (result!=200)) {
+                    dbgSerial.print("web.post result of 200 expected, but was: ");
+                    dbgSerial.println(result, DEC);
+                }
+                // only get a "real" response from the endpoint when chunking, or when the final fragment is sent to notehub
+                else if (!chunked && !tx.isComplete) {
+                    success = true;
+                } else {
+                    if (!body) {
+                        dbgSerial.println("web.post body is not present");
+                    } else if (!cobs) {
+                        dbgSerial.println("web.post response 'cobs' not present");
+                    } else if (!length) {
+                        dbgSerial.println("web.post response 'length' not present");
+                    } else {
+                        char expectedMD5String[NOTE_MD5_HASH_STRING_SIZE];
+                        // need to tighten up the note-c APIs with respect to const
+                        NoteMD5HashToString((uint8_t*)expectedMD5, expectedMD5String, sizeof(expectedMD5String));
+                        const char* receivedMD5string = JGetString(response_content, "md5");
+                        const char* contentType = JGetString(response_content, "Content-Type");
+                        size_t contentLength = JGetNumber(response_content, "length");
+
+                        if (!receivedMD5string) {
+                            receivedMD5string = "not a string";
+                        }
+                        if (strcmp(receivedMD5string, expectedMD5String)) {
+                            dbgSerial.print("web.post MD5 actual != expected: ");
+                            dbgSerial.print(receivedMD5string);
+                            dbgSerial.print(" != ");
+                            dbgSerial.println(expectedMD5String);
+                        } else if (content && (!contentType || strcmp(contentType, content))) {
+                            dbgSerial.print("web.post Content-Type actual != expected: ");
+                            dbgSerial.print(contentType);
+                            dbgSerial.print(" != ");
+                            dbgSerial.println(content);
+                        } else if (!contentLength || (contentLength!=expectedLength)) {
+                            dbgSerial.print("web.post Content-Length actual != expected: ");
+                            dbgSerial.print(contentLength);
+                            dbgSerial.print(" != ");
+                            dbgSerial.println(expectedLength);
+                        } else {
+                            dbgSerial.println("web.post response validated.");
+                            success = true;
+                        }
+                    }
+                }
+                JDelete(response_content);
+                JDelete(rsp);
+            }
+
+            if (success) {
+                success = validateReceivedContent(tx, name, chunked);
+            }
+        }
+        return success;
+    }
+
+    // Turns a reference to a member function into a regular std::function by binding the 'this' argument.
+    NotecardBinary::transfer_cb_t transfer_callback()
+    {
+        using namespace std::placeholders;
+        return std::bind(&WebPostHandler::handleTransfer, this, _1, _2);
+    }
+};
+
+class NoteAddHandler : public FileHandler
+{
+    const char* name;
+public:
+    /**
+     * @brief Construct a new NoteAdd Handler object
+     * @param alias Alias of the route that directs to the MD5 server.
+     * @param name  The name of the file being transferred.
+     */
+    NoteAddHandler(const char* alias, const char* name)
+        : FileHandler(alias, MIME_APPLICATION_OCTETSTREAM), name(name) {}
+
+    /**
+     * @brief Sends a note.add request with the binary buffer as the payload.
+     *
+     * @param tx
+     * @return true
+     * @return false
+     */
+    bool handleTransfer(const NotecardBinary::TransferDetails& tx, NotecardBinary::TransferHandlerContext& ctx)
+    {
+        bool success = false;
+        bool chunked = (tx.currentTransferSize!=tx.total);   // only one chunk equal to the total
+
+        if (!NotecardBinary::waitForNotecardConnected(NOT_CONNECTED_TIMEOUT)) {
+            dbgSerial.println("Cannot perform note.add request, Notecard not connected.");
+            return false;
+        }
+
+        if (J* req = notecard.newRequest("note.add")) {
+            JAddStringToObject(req, "file", "cardbinary.qo");
+            JAddBoolToObject(req, "binary", true);
+            JAddBoolToObject(req, "live", true);
+            JAddBoolToObject(req, "sync", true);
+            J* body = JAddObjectToObject(req, "body");
+            JAddStringToObject(body, "name", name);
+
+            char md5String[NOTE_MD5_HASH_STRING_SIZE];
+            NoteMD5HashToString((uint8_t*)tx.currentTransferMD5, md5String, sizeof(md5String));
+
+            JAddStringToObject(body, "md5", md5String);
+            JAddNumberToObject(body, "length", tx.currentTransferImage.length());
+            JAddNumberToObject(body, "offset", tx.transferred);
+            JAddNumberToObject(body, "total", tx.total);
+            if (chunked) {
+                JAddNumberToObject(body, "chunk", tx.currentTransferIndex);
+            }
+            J* rsp = notecard.requestAndResponse(req);
+            if (rsp) {
+                const char* err = JGetString(rsp, "err");
+                if (err && err[0]) {
+                    dbgSerial.print("note.add error: ");
+                    dbgSerial.println(err);
+                } else {
+                    success = true;
+                }
+                JDelete(rsp);
+            } else {
+                dbgSerial.println("no response from Notecard");
+            }
+        } else {
+            dbgSerial.println("Could not allocate request");
+        }
+
+        if (success) {
+            success = validateReceivedContent(tx, name, chunked);
+            // todo - check the card.binary size. If it has changed, we cannot retry
+            // since the buffer is cleared. Retry will have to happen at a higher level,
+            // resending the buffer.
+            ctx.tries = -1; // indicate this can't be retried.
+        }
+        return success;
+    }
+
+    NotecardBinary::transfer_cb_t transfer_callback()
+    {
+        using namespace std::placeholders;
+        return std::bind(&NoteAddHandler::handleTransfer, this, _1, _2);
+    }
+};
+
+extern BinaryImage small_binary;
+extern BufferBinaryGenerator small_image;
+
+
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardComms.cpp b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardComms.cpp
new file mode 100644
index 0000000..cff063f
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardComms.cpp
@@ -0,0 +1,154 @@
+
+#include "NotecardComms.h"
+#include <Arduino.h>
+
+size_t aux_serial_baudrate = NOTECARD_IF_AUX_SERIAL_BAUDRATE;
+
+#ifndef FEATHER_AUX_EN_PIN
+#define FEATHER_AUX_EN_PIN D5
+#endif
+
+bool set_aux_serial_baudrate(size_t baudrate, NotecardInterface nif)
+{
+    pinMode(FEATHER_AUX_EN_PIN, OUTPUT);
+    digitalWrite(FEATHER_AUX_EN_PIN, HIGH);
+
+    if (nif==NOTECARD_IF_AUX_SERIAL) {
+        dbgSerial.println("WARNING: trying to change aux serial baudrate over aux serial.");
+    }
+    initialize_notecard_interface(nif);
+
+    J* req = NoteNewRequest("card.aux.serial");
+    JAddStringToObject(req, "mode", "req");
+    JAddNumberToObject(req, "rate", baudrate);
+    J* rsp = NoteRequestResponseWithRetry(req, 10);
+    bool success = false;
+    if (rsp==nullptr) {
+        dbgSerial.println("No response to `card.aux.serial`.");
+    } else if (!JIsNullString(rsp, "err")) {
+        dbgSerial.println("Error response to `card.aux.serial`.");
+    }
+
+    const char* mode = JGetString(rsp, "mode");
+    size_t rate = JGetNumber(rsp, "rate");
+    if (strcmp(mode, "req")) {
+        dbgSerial.print("expected 'mode':'req', got ");
+        dbgSerial.println(mode);
+    } else if (rate != baudrate) {
+        dbgSerial.print("expected 'rate':");
+        dbgSerial.print(baudrate);
+        dbgSerial.print(", got ");
+        dbgSerial.println(rate);
+    } else {
+        aux_serial_baudrate = baudrate;
+        success = true;
+    }
+    JDelete(rsp);
+    return success;
+}
+
+bool initialize_notecard_interface(NotecardInterface iface)
+{
+    // Initialize the hardware I/O channel to the Notecard
+    switch (iface) {
+    default:
+        dbgSerial.println("Unknown Notecard interface given.");
+        return false;
+
+    case NOTECARD_IF_AUX_SERIAL:
+        // workaround a bug in note-arduino that doesn't call Serial.begin() when the serial port
+        // is changed.
+        NOTECARD_IF_AUX_SERIAL_PORT.end();
+        NOTECARD_IF_AUX_SERIAL_PORT.begin(aux_serial_baudrate);
+        notecard.begin(NOTECARD_IF_AUX_SERIAL_PORT, aux_serial_baudrate);
+        return true;
+
+    case NOTECARD_IF_SERIAL:
+        notecard.begin(NOTECARD_IF_SERIAL_PORT, NOTECARD_IF_SERIAL_BAUDRATE);
+        return true;
+
+    case NOTECARD_IF_I2C:
+        notecard.begin(NOTECARD_IF_I2C_ADDRESS);
+        return true;
+    }
+}
+
+#if 0 // Notecard.end() is vaporware ;-)
+bool uninitialize_notecard_interface(NotecardInterface iface)
+{
+    // Initialize the hardware I/O channel to the Notecard
+    switch (iface) {
+    default:
+        dbgSerial.println("Unknown Notecard interface given.");
+        return false;
+
+    case NOTECARD_IF_AUX_SERIAL:
+        notecard.end(NOTECARD_IF_AUX_SERIAL_PORT, aux_serial_baudrate);
+        return true;
+
+    case NOTECARD_IF_SERIAL:
+        notecard.end(NOTECARD_IF_SERIAL_PORT, NOTECARD_IF_SERIAL_BAUDRATE);
+        return true;
+
+    case NOTECARD_IF_I2C:
+        notecard.end(NOTECARD_IF_I2C_ADDRESS);
+        return true;
+    }
+}
+#endif
+
+extern "C" {
+    uint32_t cobsEncode(uint8_t *ptr, uint32_t length, uint8_t eop, uint8_t *dst);
+}
+
+size_t readDataUntilTimeout(Stream& serial, size_t timeout, uint8_t* buf, size_t bufLen, size_t dataLen, size_t& duration)
+{
+
+    // encode the data to match what's on the wire
+    const size_t dataShift = (bufLen - dataLen);
+    memmove(buf + dataShift, buf, dataLen);
+    size_t encLen = cobsEncode(buf + dataShift, dataLen, '\n', buf);
+    buf[encLen] = '\n';
+
+
+
+    size_t count = 0;
+    size_t begin = millis();
+    size_t matchIndex = 0;  // current index being matched in the input buffer
+    for (;;) {
+
+        size_t start = millis();
+        while (!serial.available()) {
+            if ((millis()-start)>timeout) {
+                duration = millis()-begin;
+                return count;
+            }
+        }
+
+        while (serial.available()) {
+            uint8_t ch = serial.read();
+            if (buf[matchIndex]==ch) {
+                matchIndex++;
+                if (matchIndex>=bufLen) {
+                    dbgSerial.print("matched the complete image at offset ");
+                    dbgSerial.println(count, DEC);
+                }
+            } else {
+                if (matchIndex>10) {
+                    dbgSerial.print("matched ");
+                    dbgSerial.print(matchIndex, DEC);
+                    dbgSerial.print(" bytes at offset ");
+                    dbgSerial.println(count, DEC);
+                }
+                matchIndex = 0;
+            }
+            count++;
+        }
+    }
+}
+
+
+HardwareSerial Serial2(A0,A3);
+HardwareSerial Serial3(A5,A4); // A5 is RX, A4 is TX
+
+
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardComms.h b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardComms.h
new file mode 100644
index 0000000..d05052a
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/NotecardComms.h
@@ -0,0 +1,55 @@
+
+#pragma once
+
+#include <Notecard.h>
+
+enum NotecardInterface {
+    NOTECARD_IF_I2C=1,
+    NOTECARD_IF_SERIAL,
+    NOTECARD_IF_AUX_SERIAL
+};
+
+#ifndef NOTECARD_IF_SERIAL_PORT
+#define NOTECARD_IF_SERIAL_PORT Serial3
+#endif
+
+#ifndef NOTECARD_IF_SERIAL_BAUDRATE
+#define NOTECARD_IF_SERIAL_BAUDRATE (9600)
+#endif
+
+#ifndef NOTECARD_IF_AUX_SERIAL_PORT
+#define NOTECARD_IF_AUX_SERIAL_PORT Serial1
+#endif
+
+#ifndef NOTECARD_IF_AUX_SERIAL_BAUDRATE
+#define NOTECARD_IF_AUX_SERIAL_BAUDRATE 115200
+#endif
+
+#ifndef NOTECARD_IF_I2C_ADDRESS
+#define NOTECARD_IF_I2C_ADDRESS NOTE_I2C_ADDR_DEFAULT
+#endif
+
+#if defined(NOTECARD_DEBUG_STLINK)
+HardwareSerial stlinkSerial(PIN_VCP_RX, PIN_VCP_TX);
+#define dbgSerial stlinkSerial
+#else
+#define dbgSerial Serial
+#endif
+
+bool initialize_notecard_interface(NotecardInterface iface);
+size_t readDataUntilTimeout(Stream& serial, size_t timeout, uint8_t* buf, size_t bufLen, size_t dataLen, size_t& duration);
+
+/**
+ * @brief Sets the baudrate of the aux serial interface and the mode to "req".
+ *
+ * @param baudrate The desired baudrate to set
+ * @param nif The notecard interface to use to send the request.
+ * @return true The baudrate was set
+ * @return false An error occurred. See the Notecard debug stream for details.
+ */
+bool set_aux_serial_baudrate(size_t baudrate=NOTECARD_IF_AUX_SERIAL_BAUDRATE, NotecardInterface nif=NOTECARD_IF_I2C);
+
+
+extern Notecard notecard;
+
+
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/defines.txt b/src/note-c/test/hitl/card.binary/lib/notecard_binary/defines.txt
new file mode 100644
index 0000000..0931223
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/defines.txt
@@ -0,0 +1,5 @@
+
+NOTECARD_SERIAL=<Arduino Serial Instance>
+
+// The value is presently not used, just the definition of the symbol
+NOTECARD_I2C=
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/small_img.cpp b/src/note-c/test/hitl/card.binary/lib/notecard_binary/small_img.cpp
new file mode 100644
index 0000000..5bd1c29
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/small_img.cpp
@@ -0,0 +1,4921 @@
+
+#include "small_img.h"
+
+const uint8_t small_img_map[] = {
+    0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00,
+    0x01, 0x00, 0x01, 0x00, 0x00, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x08, 0x06, 0x06, 0x07, 0x06,
+    0x05, 0x08, 0x07, 0x07, 0x07, 0x09, 0x09, 0x08, 0x0a, 0x0c, 0x14, 0x0d, 0x0c, 0x0b, 0x0b,
+    0x0c, 0x19, 0x12, 0x13, 0x0f, 0x14, 0x1d, 0x1a, 0x1f, 0x1e, 0x1d, 0x1a, 0x1c, 0x1c, 0x20,
+    0x24, 0x2e, 0x27, 0x20, 0x22, 0x2c, 0x23, 0x1c, 0x1c, 0x28, 0x37, 0x29, 0x2c, 0x30, 0x31,
+    0x34, 0x34, 0x34, 0x1f, 0x27, 0x39, 0x3d, 0x38, 0x32, 0x3c, 0x2e, 0x33, 0x34, 0x32, 0xff,
+    0xdb, 0x00, 0x43, 0x01, 0x09, 0x09, 0x09, 0x0c, 0x0b, 0x0c, 0x18, 0x0d, 0x0d, 0x18, 0x32,
+    0x21, 0x1c, 0x21, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+    0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+    0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+    0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x02, 0xc8,
+    0x04, 0xb0, 0x03, 0x01, 0x22, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xff, 0xc4, 0x00,
+    0x1f, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
+    0xff, 0xc4, 0x00, 0xb5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05,
+    0x04, 0x04, 0x00, 0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21,
+    0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+    0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a,
+    0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37,
+    0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56,
+    0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
+    0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93,
+    0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
+    0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6,
+    0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xff, 0xc4, 0x00, 0x1f, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
+    0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0xff, 0xc4, 0x00, 0xb5, 0x11, 0x00, 0x02, 0x01, 0x02,
+    0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02,
+    0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22,
+    0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15,
+    0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+    0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
+    0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66,
+    0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84,
+    0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
+    0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+    0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+    0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01,
+    0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, 0x00, 0xf0, 0x1a, 0x5a, 0x4a, 0x5a, 0xa4, 0x01,
+    0x45, 0x14, 0x55, 0x08, 0x29, 0x56, 0x92, 0x8a, 0x00, 0x7d, 0x14, 0x51, 0x40, 0x05, 0x49,
+    0x51, 0xd3, 0xd7, 0xa5, 0x00, 0x2d, 0x14, 0x51, 0x40, 0x05, 0x28, 0xa0, 0x0a, 0x70, 0x5a,
+    0x60, 0x25, 0x03, 0xad, 0x38, 0xad, 0x34, 0xf1, 0x4c, 0x07, 0x52, 0x8a, 0x4a, 0x28, 0x10,
+    0xa3, 0xad, 0x3a, 0x9b, 0x4e, 0xaa, 0x00, 0xa5, 0x1d, 0x69, 0x28, 0xa6, 0x03, 0xe9, 0x69,
+    0x28, 0x14, 0x21, 0x0f, 0x1d, 0x29, 0xc2, 0x98, 0xb4, 0xea, 0x60, 0x2d, 0x28, 0xa4, 0xa2,
+    0xa9, 0x00, 0xfa, 0x51, 0x4d, 0xa5, 0xa6, 0x03, 0x85, 0x28, 0xa4, 0xa5, 0xaa, 0x42, 0x63,
+    0xc7, 0x4a, 0x75, 0x30, 0x1a, 0x75, 0x30, 0x1c, 0x29, 0xc0, 0xd3, 0x05, 0x3a, 0xa9, 0x30,
+    0x25, 0x56, 0xc1, 0xa9, 0x04, 0x95, 0x5c, 0x1a, 0x76, 0x6a, 0xee, 0x4b, 0x44, 0xc5, 0xe8,
+    0x5e, 0x6a, 0x20, 0x69, 0xea, 0x70, 0x68, 0x0b, 0x17, 0x52, 0xce, 0x67, 0x87, 0xcc, 0x00,
+    0x60, 0xf2, 0x06, 0x79, 0xa8, 0x0d, 0x59, 0x4d, 0x41, 0x92, 0x00, 0x9b, 0x01, 0x20, 0x60,
+    0x36, 0x6a, 0xa6, 0x69, 0x99, 0xab, 0xf5, 0x1f, 0xd6, 0x8a, 0x45, 0x35, 0x30, 0x8f, 0x70,
+    0x14, 0xc4, 0xf4, 0x1d, 0x00, 0xcb, 0x66, 0x92, 0x43, 0xf3, 0x9a, 0x96, 0x35, 0xf2, 0xd0,
+    0x9a, 0xac, 0x4e, 0x5b, 0x34, 0x19, 0xad, 0x5d, 0xc7, 0xaf, 0x5a, 0x90, 0x8c, 0x0c, 0xd4,
+    0x43, 0xa8, 0xa9, 0xdb, 0x94, 0x14, 0x21, 0xb1, 0x94, 0xe0, 0x32, 0x33, 0x4d, 0x51, 0x9a,
+    0x90, 0xf0, 0xb4, 0xc9, 0x6c, 0x45, 0x19, 0xa7, 0xe0, 0x52, 0xa1, 0x5c, 0x52, 0x9c, 0x50,
+    0x43, 0x63, 0x40, 0x14, 0xea, 0x4c, 0x81, 0x48, 0x5c, 0x0a, 0x00, 0x09, 0xa4, 0xa0, 0x1c,
+    0xd2, 0x66, 0x80, 0x17, 0x3c, 0x50, 0x4d, 0x37, 0x34, 0xdd, 0xd4, 0x05, 0x89, 0x37, 0x51,
+    0xbb, 0x8a, 0x88, 0xb0, 0xa0, 0x1e, 0x3a, 0xd0, 0x3b, 0x12, 0x66, 0x9a, 0x4d, 0x30, 0x9a,
+    0x6e, 0x68, 0xb0, 0x72, 0x92, 0x66, 0x98, 0x5a, 0x9a, 0x4d, 0x25, 0x2b, 0x15, 0xca, 0x04,
+    0xd2, 0x66, 0x8a, 0x4a, 0x77, 0x18, 0x66, 0x92, 0x96, 0x9a, 0x4d, 0x21, 0x81, 0xa6, 0xe6,
+    0x82, 0x69, 0xa4, 0xd2, 0x1d, 0x85, 0x26, 0x98, 0x4d, 0x04, 0xd2, 0x13, 0x48, 0xa1, 0x09,
+    0xa4, 0xa5, 0xa4, 0x34, 0x80, 0x4a, 0x28, 0xa5, 0xa0, 0x00, 0x52, 0xd3, 0x73, 0x40, 0x34,
+    0x00, 0xee, 0x94, 0xd2, 0x69, 0x69, 0xa7, 0xa5, 0x00, 0x84, 0xcd, 0x26, 0x71, 0x45, 0x36,
+    0x90, 0xc9, 0x19, 0xc3, 0x0a, 0x8c, 0xd1, 0x4d, 0x26, 0x95, 0xc1, 0x21, 0x4d, 0x34, 0x9a,
+    0x09, 0xa6, 0x93, 0x48, 0xa0, 0x26, 0x93, 0x34, 0x84, 0xd1, 0x48, 0x61, 0x45, 0x14, 0x87,
+    0xa5, 0x26, 0x30, 0x26, 0x93, 0x34, 0x99, 0xa0, 0xd4, 0xb0, 0x10, 0x9a, 0x29, 0x28, 0xa9,
+    0x01, 0x69, 0x28, 0xa4, 0xa4, 0x02, 0xd2, 0x51, 0x45, 0x00, 0x14, 0x52, 0x52, 0xd0, 0x30,
+    0xa2, 0x8a, 0x29, 0x00, 0x52, 0x52, 0xd2, 0x50, 0x01, 0x49, 0x4b, 0x45, 0x20, 0x12, 0x8a,
+    0x5a, 0x28, 0x01, 0x29, 0x68, 0xa2, 0x80, 0x12, 0x96, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28,
+    0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x4a, 0x00, 0x28, 0xa3, 0x34, 0x99, 0xa4, 0x02,
+    0xe6, 0x93, 0x34, 0x99, 0xa4, 0xcd, 0x00, 0x3b, 0x34, 0xdc, 0xd2, 0x13, 0x49, 0x9a, 0x06,
+    0x2e, 0x69, 0x33, 0x49, 0x9a, 0x4c, 0xd2, 0x01, 0x49, 0xa4, 0xcd, 0x26, 0x69, 0x28, 0x18,
+    0xb9, 0xa4, 0xa4, 0xcd, 0x14, 0x80, 0x28, 0xa4, 0xa2, 0x80, 0x0c, 0xd2, 0x51, 0x49, 0x40,
+    0xc5, 0xa4, 0xa2, 0x8a, 0x40, 0x14, 0x94, 0x51, 0x40, 0x05, 0x25, 0x14, 0x52, 0x00, 0xa4,
+    0xa2, 0x8a, 0x06, 0x14, 0x94, 0x51, 0x48, 0x02, 0x92, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x4a,
+    0x40, 0x14, 0x51, 0x45, 0x00, 0x14, 0xa2, 0x92, 0x8a, 0x68, 0x62, 0xd1, 0x45, 0x15, 0x42,
+    0x0a, 0x28, 0xa2, 0x80, 0x1c, 0x3a, 0x52, 0xd2, 0x0e, 0x94, 0xb4, 0x00, 0x53, 0x96, 0x9b,
+    0x4a, 0xbd, 0x68, 0x01, 0xf4, 0x0e, 0xb4, 0x51, 0x40, 0x12, 0xa0, 0xcd, 0x69, 0x59, 0xe9,
+    0x17, 0x77, 0xd1, 0x19, 0x20, 0x8b, 0x28, 0x0e, 0x37, 0x13, 0x80, 0x4f, 0xb5, 0x67, 0x46,
+    0x6b, 0xaa, 0xd1, 0xb5, 0xbb, 0x3b, 0x7d, 0x39, 0x2d, 0xae, 0x18, 0xc4, 0xd1, 0xe4, 0x03,
+    0x8c, 0x86, 0x15, 0xb5, 0x34, 0x9e, 0xe4, 0x49, 0xb5, 0xb1, 0xce, 0x4f, 0x03, 0x44, 0xec,
+    0x8e, 0xa5, 0x1d, 0x4e, 0x0a, 0x9a, 0xac, 0x45, 0x69, 0x6a, 0x77, 0x8b, 0x7b, 0x7d, 0x2d,
+    0xc2, 0x29, 0x55, 0x6e, 0x00, 0x3e, 0x95, 0x9a, 0xd4, 0xa4, 0x97, 0x42, 0x90, 0x82, 0x96,
+    0x90, 0x52, 0xd4, 0x00, 0xb4, 0xa2, 0x9b, 0x4b, 0x4c, 0x07, 0x51, 0x45, 0x15, 0x40, 0x39,
+    0x69, 0x69, 0xa3, 0xad, 0x3a, 0x80, 0x16, 0x9f, 0x4c, 0xa7, 0x2f, 0x4a, 0x62, 0x1d, 0x45,
+    0x25, 0x2d, 0x34, 0x02, 0x8a, 0x75, 0x34, 0x0a, 0x5a, 0xa0, 0x1c, 0x29, 0xc2, 0x99, 0x4e,
+    0xa6, 0x02, 0x8a, 0x78, 0x39, 0x14, 0xca, 0x50, 0x71, 0x4c, 0x44, 0x94, 0xa2, 0x9b, 0x4b,
+    0x4d, 0x30, 0x1d, 0x4e, 0x14, 0xda, 0x50, 0x6a, 0xc0, 0x75, 0x2e, 0x69, 0xb4, 0xb4, 0xd3,
+    0x11, 0x22, 0x9a, 0x76, 0x71, 0x50, 0x83, 0x8a, 0x70, 0xaa, 0x13, 0x44, 0xe8, 0x6a, 0xe4,
+    0x4b, 0x9e, 0x6a, 0xa4, 0x40, 0x16, 0xad, 0x05, 0x5d, 0xa9, 0x4d, 0x1c, 0xf5, 0x5d, 0x86,
+    0xca, 0xdb, 0x53, 0x15, 0x50, 0x75, 0xa9, 0xe5, 0x3b, 0x8f, 0xd2, 0xa0, 0x1d, 0x79, 0xa1,
+    0x8a, 0x0a, 0xc8, 0x7a, 0x8e, 0x45, 0x4c, 0x3a, 0x62, 0x98, 0x9d, 0x45, 0x3d, 0x79, 0x7e,
+    0x68, 0x14, 0x81, 0x07, 0xcd, 0x44, 0x86, 0x9e, 0x07, 0xcd, 0x4c, 0x97, 0x83, 0xc5, 0x31,
+    0x2d, 0x58, 0xc0, 0x69, 0x49, 0x3e, 0xb4, 0xcc, 0xfa, 0x8a, 0x4d, 0xdf, 0x95, 0x05, 0x58,
+    0x7d, 0x14, 0xd0, 0x69, 0x73, 0x40, 0x58, 0x7a, 0x9a, 0x46, 0x3c, 0xd2, 0x67, 0x1d, 0x29,
+    0x09, 0xcf, 0x34, 0x13, 0x6d, 0x43, 0x34, 0x99, 0xa3, 0x34, 0x99, 0xa0, 0xab, 0x05, 0x14,
+    0x66, 0x9a, 0x4d, 0x03, 0xb0, 0xb4, 0x84, 0xd1, 0x91, 0x4d, 0x26, 0x90, 0x58, 0x52, 0x69,
+    0x09, 0xa6, 0xe7, 0x9a, 0x4c, 0xd0, 0x55, 0x87, 0x6e, 0xa3, 0x75, 0x33, 0x34, 0x9b, 0xa9,
+    0x5c, 0x2c, 0x38, 0x93, 0x4d, 0xcd, 0x19, 0xa4, 0xcd, 0x00, 0x06, 0x9a, 0x4d, 0x04, 0xd2,
+    0x66, 0x90, 0xc3, 0xad, 0x26, 0x3d, 0x29, 0x73, 0x48, 0x4d, 0x20, 0x0a, 0x43, 0x41, 0x34,
+    0x50, 0x01, 0x49, 0x4b, 0x49, 0x40, 0x08, 0x69, 0x09, 0xa0, 0xd2, 0x52, 0x18, 0xb9, 0xa4,
+    0x27, 0x34, 0x94, 0x50, 0x01, 0x9a, 0x69, 0xa0, 0x9a, 0x42, 0x69, 0x0e, 0xc0, 0x4d, 0x34,
+    0x9a, 0x5a, 0x4a, 0x4c, 0x62, 0x52, 0x52, 0xd2, 0x13, 0x48, 0x63, 0x4d, 0x14, 0x13, 0x45,
+    0x26, 0x30, 0xa4, 0x26, 0x8a, 0x69, 0x34, 0x9b, 0x00, 0xa4, 0x26, 0x8c, 0xd2, 0x54, 0xdc,
+    0x05, 0xa2, 0x8a, 0x4a, 0x91, 0x85, 0x25, 0x14, 0x50, 0x02, 0xd1, 0x49, 0x4b, 0x40, 0x05,
+    0x25, 0x14, 0x50, 0x01, 0x45, 0x14, 0x52, 0x00, 0xa2, 0x8a, 0x29, 0x00, 0x51, 0x45, 0x2d,
+    0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x94, 0xb4, 0x50, 0x02, 0x51, 0x4b, 0x45, 0x02, 0x12,
+    0x8a, 0x33, 0x45, 0x03, 0x0a, 0x4a, 0x33, 0x49, 0x9a, 0x00, 0x5a, 0x4a, 0x4c, 0xd2, 0x66,
+    0x90, 0x0b, 0x48, 0x4d, 0x26, 0x69, 0x33, 0x40, 0xc5, 0xcd, 0x26, 0x69, 0x33, 0x49, 0x9a,
+    0x40, 0x29, 0x34, 0xd2, 0x68, 0x34, 0x94, 0x0c, 0x33, 0x45, 0x19, 0xa4, 0xa0, 0x03, 0x34,
+    0x52, 0x51, 0x48, 0x02, 0x8a, 0x4a, 0x28, 0x00, 0xa2, 0x92, 0x8a, 0x43, 0x0a, 0x28, 0xa4,
+    0xa0, 0x02, 0x8a, 0x29, 0x28, 0x01, 0x69, 0x28, 0xa2, 0x90, 0x05, 0x25, 0x14, 0x94, 0x0c,
+    0x5a, 0x4a, 0x28, 0xa4, 0x01, 0x49, 0x45, 0x14, 0x00, 0x52, 0x51, 0x45, 0x20, 0x0a, 0x28,
+    0xa4, 0xa0, 0x02, 0x8a, 0x28, 0xa4, 0x31, 0x68, 0xa2, 0x8a, 0x60, 0x2d, 0x14, 0x51, 0x54,
+    0x20, 0xa2, 0x8a, 0x29, 0x80, 0xa3, 0xad, 0x3a, 0x99, 0x4f, 0xa0, 0x02, 0x8a, 0x28, 0xa0,
+    0x07, 0x8e, 0x94, 0xb4, 0xd5, 0xa7, 0x50, 0x03, 0x94, 0xe2, 0xa4, 0xf3, 0x2a, 0x1a, 0x5c,
+    0xd3, 0x4c, 0x09, 0x0b, 0x64, 0xd3, 0x49, 0xa6, 0xe4, 0xd2, 0xd3, 0xb8, 0x05, 0x38, 0x74,
+    0xa6, 0xd2, 0x8a, 0x00, 0x5a, 0x5a, 0x08, 0xa5, 0x03, 0x8a, 0x62, 0x14, 0x74, 0xa2, 0x90,
+    0x52, 0x34, 0x8a, 0xbd, 0x58, 0x53, 0x01, 0xd8, 0xa7, 0x0a, 0x89, 0x66, 0x46, 0x38, 0x0c,
+    0x2a, 0x41, 0xd6, 0x84, 0xee, 0x03, 0xa9, 0x47, 0x5a, 0x4a, 0x5a, 0xa4, 0x21, 0xf4, 0xb4,
+    0xd0, 0x7b, 0x53, 0x85, 0x08, 0x05, 0xeb, 0x4a, 0x28, 0x5e, 0x69, 0x76, 0x9a, 0xb0, 0x00,
+    0x69, 0xd9, 0xcd, 0x37, 0x06, 0x9e, 0x14, 0xe3, 0xa5, 0x00, 0x25, 0x2d, 0x25, 0x2d, 0x34,
+    0x26, 0x3c, 0x1e, 0xd4, 0xea, 0x8c, 0x53, 0xc7, 0x4a, 0xa0, 0x1c, 0x29, 0x69, 0xa2, 0xa4,
+    0x23, 0xe5, 0xcd, 0x52, 0x01, 0x01, 0xa7, 0x53, 0x29, 0xc0, 0xd3, 0x01, 0x69, 0xca, 0x33,
+    0x4d, 0xa9, 0xe1, 0x5c, 0xa1, 0xaa, 0x44, 0xb7, 0x64, 0x3e, 0x1f, 0xbc, 0x05, 0x69, 0x05,
+    0x3e, 0x5e, 0x4d, 0x67, 0xdb, 0xae, 0x64, 0xad, 0x1b, 0x97, 0x11, 0x43, 0xb6, 0xa8, 0xe7,
+    0xa9, 0xab, 0xb1, 0x4c, 0x36, 0x58, 0xd4, 0x67, 0x86, 0xa6, 0x45, 0x26, 0x64, 0x34, 0xf9,
+    0x3e, 0xf5, 0x05, 0x5a, 0xcc, 0x96, 0x2e, 0x5a, 0xa5, 0x23, 0x6f, 0x22, 0xa3, 0xb6, 0x19,
+    0x35, 0x3d, 0xc7, 0xc8, 0x94, 0xcc, 0xe5, 0xb8, 0x8a, 0x73, 0xcd, 0x41, 0x29, 0xcb, 0x62,
+    0xa5, 0x89, 0xb2, 0x86, 0xab, 0xc8, 0x72, 0xe6, 0x93, 0x08, 0xad, 0x44, 0x27, 0x02, 0x90,
+    0x1f, 0x4a, 0x42, 0x69, 0x57, 0xae, 0x68, 0x34, 0x1e, 0x17, 0x3f, 0x5a, 0x77, 0x4e, 0xd4,
+    0xa8, 0x0b, 0x10, 0x00, 0xc9, 0x3d, 0xaa, 0xdc, 0xb6, 0x33, 0xc5, 0x09, 0x90, 0x80, 0x54,
+    0x75, 0xc7, 0x6a, 0x08, 0x28, 0x92, 0x40, 0xeb, 0x4b, 0xda, 0x9a, 0xdd, 0x78, 0xa7, 0x76,
+    0xa0, 0x63, 0x33, 0x9a, 0x29, 0x3b, 0xd0, 0x69, 0x0c, 0x33, 0x4d, 0x26, 0x8c, 0xfb, 0xd3,
+    0x73, 0x4c, 0x76, 0x17, 0x75, 0x21, 0x34, 0x51, 0x40, 0xc6, 0x67, 0x9a, 0x0f, 0xad, 0x21,
+    0xa0, 0x9e, 0x29, 0x00, 0xe3, 0x4c, 0xa7, 0x75, 0x14, 0xd3, 0x40, 0xd0, 0xb9, 0xa4, 0x26,
+    0x90, 0x9a, 0x3a, 0xd2, 0x0b, 0x0b, 0x49, 0x45, 0x25, 0x00, 0x14, 0x94, 0xb8, 0xa0, 0x9c,
+    0x52, 0x01, 0x28, 0x34, 0x94, 0xa6, 0x80, 0x13, 0x34, 0x84, 0xd1, 0xde, 0x83, 0x48, 0x04,
+    0x34, 0xda, 0x5a, 0x42, 0x68, 0x00, 0x34, 0xd2, 0x68, 0x27, 0x9a, 0x4a, 0x45, 0x58, 0x29,
+    0x28, 0xa4, 0x34, 0x86, 0x19, 0xa4, 0xa5, 0xa6, 0xd2, 0x01, 0x4d, 0x34, 0xd2, 0xe6, 0x9a,
+    0x4e, 0x68, 0x01, 0x28, 0xa4, 0xa4, 0x26, 0xa5, 0xb1, 0x8a, 0x4d, 0x34, 0xd1, 0x49, 0x52,
+    0xc6, 0x14, 0x66, 0x92, 0x92, 0xa4, 0x05, 0xa2, 0x8c, 0x52, 0xe2, 0x80, 0x0c, 0x51, 0x4b,
+    0x49, 0x40, 0x05, 0x14, 0x52, 0x50, 0xc0, 0x28, 0xa2, 0x8a, 0x40, 0x14, 0x52, 0xd1, 0x40,
+    0x05, 0x14, 0x62, 0x96, 0x80, 0x13, 0x14, 0x62, 0x96, 0x8a, 0x00, 0x4a, 0x28, 0xa3, 0x34,
+    0x00, 0x51, 0x49, 0x9a, 0x33, 0x48, 0x02, 0x8a, 0x4c, 0xd2, 0x66, 0x80, 0x16, 0x93, 0x34,
+    0x99, 0xa4, 0xcd, 0x20, 0x1d, 0x9a, 0x6e, 0x69, 0x33, 0x48, 0x68, 0x18, 0xb9, 0xa4, 0x26,
+    0x92, 0x90, 0x9a, 0x40, 0x2e, 0x69, 0x33, 0x49, 0x49, 0x9a, 0x06, 0x2e, 0x69, 0x33, 0x49,
+    0x46, 0x69, 0x00, 0xb4, 0x94, 0x99, 0xa4, 0xcd, 0x00, 0x2e, 0x68, 0xcd, 0x25, 0x14, 0x00,
+    0x66, 0x8a, 0x29, 0x29, 0x0c, 0x5a, 0x4c, 0xd1, 0x46, 0x68, 0x00, 0xa4, 0xa2, 0x8a, 0x00,
+    0x28, 0xa4, 0xa2, 0x90, 0x05, 0x14, 0x66, 0x92, 0x81, 0x85, 0x14, 0x52, 0x52, 0x00, 0xa2,
+    0x8a, 0x4a, 0x00, 0x28, 0xa2, 0x8a, 0x00, 0x29, 0x28, 0xa2, 0x90, 0x05, 0x14, 0x52, 0x50,
+    0x01, 0x45, 0x14, 0x52, 0x18, 0x51, 0x45, 0x14, 0x08, 0x5a, 0x28, 0xa2, 0x98, 0xc0, 0x52,
+    0xd2, 0x52, 0xd5, 0x21, 0x05, 0x14, 0x51, 0x4c, 0x02, 0x95, 0x4f, 0x6a, 0x4a, 0x51, 0xd6,
+    0x80, 0x1d, 0x45, 0x14, 0x50, 0x02, 0x8e, 0xb4, 0xfa, 0x8e, 0x9e, 0x0e, 0x68, 0x01, 0x68,
+    0xa2, 0x8a, 0x00, 0x29, 0x45, 0x25, 0x14, 0xc0, 0x75, 0x03, 0xad, 0x14, 0x50, 0x04, 0x9d,
+    0x45, 0x0b, 0x80, 0x79, 0x3c, 0x50, 0x86, 0xb7, 0xfc, 0x1b, 0xe0, 0xad, 0x4b, 0xc7, 0x7a,
+    0xd7, 0xd8, 0xec, 0x81, 0x8a, 0xce, 0x22, 0x0d, 0xcd, 0xd1, 0x1f, 0x2c, 0x6b, 0xfd, 0x49,
+    0xec, 0x2a, 0x9b, 0xb6, 0xa0, 0x95, 0xcc, 0xfd, 0x03, 0xc3, 0xda, 0xc7, 0x8b, 0xb5, 0x41,
+    0xa7, 0xe8, 0xb6, 0xaf, 0x33, 0xf5, 0x77, 0xe8, 0xb1, 0xaf, 0xab, 0x37, 0x61, 0x5e, 0xe9,
+    0xe1, 0x8f, 0x80, 0x3a, 0x26, 0x9f, 0x1a, 0x4d, 0xaf, 0xdc, 0x3e, 0xa3, 0x73, 0xc1, 0x31,
+    0x46, 0x4a, 0x44, 0xa7, 0xf9, 0xb7, 0xe9, 0x5e, 0x8d, 0xe1, 0x9f, 0x0b, 0xe9, 0x5e, 0x11,
+    0xd2, 0x13, 0x4e, 0xd2, 0xad, 0xc4, 0x71, 0x8e, 0x5d, 0xcf, 0x2f, 0x2b, 0x7f, 0x79, 0x8f,
+    0x73, 0x5a, 0xe5, 0xab, 0x17, 0x2b, 0x9b, 0x46, 0x9f, 0x73, 0xce, 0x3c, 0x41, 0xf0, 0x47,
+    0xc2, 0x5a, 0xb5, 0x93, 0xa6, 0x9f, 0x6c, 0x74, 0xcb, 0xac, 0x7c, 0x92, 0xc2, 0xc4, 0xae,
+    0x7f, 0xda, 0x52, 0x79, 0x1f, 0x95, 0x78, 0x56, 0xb3, 0xf0, 0xef, 0xc5, 0xde, 0x1e, 0xd4,
+    0x9a, 0xca, 0x5d, 0x22, 0xe6, 0xed, 0x72, 0x44, 0x73, 0xdb, 0x46, 0xd2, 0x23, 0x8f, 0x50,
+    0x47, 0x4f, 0xa1, 0xc5, 0x7d, 0x76, 0x24, 0x52, 0x70, 0x18, 0x1a, 0x7d, 0x0a, 0x4d, 0x0d,
+    0xd3, 0x4c, 0xf9, 0x2a, 0xdb, 0xe1, 0x6f, 0x8f, 0x2f, 0xad, 0xfc, 0xf8, 0xf4, 0x39, 0x22,
+    0x5e, 0xcb, 0x2b, 0x2a, 0x37, 0xe4, 0xc6, 0x9b, 0x75, 0xf0, 0xb7, 0xc7, 0x76, 0x36, 0x8f,
+    0x75, 0x2e, 0x8b, 0x23, 0x22, 0x0c, 0xb2, 0xa3, 0xab, 0xb6, 0x3e, 0x80, 0xe6, 0xbe, 0xb7,
+    0xde, 0x07, 0x52, 0x28, 0xdc, 0x29, 0xf3, 0xb2, 0x7d, 0x9a, 0x3e, 0x1f, 0x86, 0x5d, 0xec,
+    0x51, 0x94, 0xab, 0xaf, 0x05, 0x4f, 0x6a, 0x9e, 0xbb, 0xef, 0x8e, 0x5a, 0x55, 0x86, 0x97,
+    0xf1, 0x02, 0xde, 0x6b, 0x14, 0x58, 0xe4, 0xbc, 0xb7, 0x13, 0x5c, 0x22, 0xf0, 0x37, 0xee,
+    0x23, 0x77, 0xe2, 0x05, 0x70, 0x26, 0xb6, 0x84, 0xae, 0x8c, 0x9a, 0xb3, 0x15, 0x7a, 0xd5,
+    0x85, 0x3c, 0x54, 0x28, 0x38, 0x26, 0x90, 0x39, 0x06, 0xb5, 0x4e, 0xc4, 0x96, 0x82, 0x8f,
+    0x4a, 0x98, 0x45, 0x94, 0x04, 0x0a, 0xaa, 0xb3, 0x8e, 0xf5, 0x76, 0xde, 0x60, 0xd8, 0x15,
+    0xb4, 0x5a, 0x64, 0xca, 0xe8, 0x82, 0x58, 0x4a, 0x80, 0x71, 0x51, 0x95, 0xf9, 0x6a, 0xd5,
+    0xe4, 0xdd, 0xaa, 0xba, 0x7c, 0xcb, 0x49, 0xa5, 0x7b, 0x02, 0x6d, 0xad, 0x48, 0xb1, 0xcd,
+    0x4d, 0x80, 0x12, 0x98, 0x47, 0xcc, 0x2a, 0x46, 0xfb, 0xb8, 0xa4, 0x86, 0x47, 0x53, 0xa7,
+    0x31, 0x9a, 0x80, 0x02, 0x2a, 0x7b, 0x7f, 0xbd, 0x8a, 0x71, 0xdc, 0x4c, 0x8f, 0xbd, 0x2f,
+    0x41, 0x53, 0xbc, 0x60, 0x72, 0x2a, 0x13, 0x4e, 0xd6, 0x04, 0xee, 0x00, 0xd5, 0xab, 0x62,
+    0x0a, 0x91, 0x54, 0xea, 0x68, 0x5f, 0x6b, 0x8f, 0x7a, 0x71, 0xdc, 0x52, 0x57, 0x46, 0x85,
+    0xb2, 0x62, 0x42, 0x6a, 0x2b, 0xd9, 0x89, 0x6d, 0xb9, 0xab, 0x31, 0x9d, 0xb1, 0x16, 0x35,
+    0x99, 0x33, 0xee, 0x90, 0xd5, 0xb3, 0x08, 0x2e, 0x69, 0x5c, 0x74, 0x24, 0x6f, 0x15, 0x62,
+    0x61, 0xd2, 0xa9, 0xa1, 0xc3, 0x0a, 0xbc, 0xeb, 0xba, 0x30, 0x68, 0x45, 0xcf, 0x46, 0x59,
+    0xb1, 0x51, 0x8c, 0xd4, 0x77, 0xb2, 0x65, 0xf0, 0x2a, 0x6b, 0x50, 0x56, 0x32, 0x7d, 0xab,
+    0x32, 0xf6, 0xea, 0x18, 0xe5, 0x21, 0xe5, 0x55, 0x3e, 0xe6, 0x86, 0xed, 0xb9, 0x94, 0x55,
+    0xe4, 0x58, 0x49, 0x76, 0xa1, 0x15, 0x11, 0x39, 0x39, 0xa8, 0x62, 0xb8, 0x8e, 0x51, 0xf2,
+    0x3a, 0xb7, 0xd0, 0xd4, 0x84, 0xe0, 0x52, 0xbd, 0xcd, 0x39, 0x6c, 0xc5, 0xa7, 0x2d, 0x46,
+    0x0d, 0x38, 0x1a, 0x01, 0xa2, 0xcc, 0x52, 0x98, 0xe4, 0x57, 0x1c, 0xe0, 0xe6, 0xb6, 0x26,
+    0xd6, 0xe2, 0x93, 0x4d, 0x36, 0xe9, 0x09, 0x0e, 0xdd, 0x49, 0xed, 0x58, 0x01, 0xa8, 0x67,
+    0x20, 0x53, 0x12, 0xbf, 0x40, 0x63, 0xcf, 0x14, 0xf5, 0x39, 0x5a, 0xac, 0xce, 0x7d, 0x69,
+    0xf1, 0x39, 0xe9, 0x40, 0xdc, 0x74, 0x1e, 0x32, 0x5a, 0x9c, 0xd4, 0xa8, 0x3e, 0x6a, 0x96,
+    0x0b, 0x7f, 0xb4, 0x48, 0x41, 0x6c, 0x00, 0x32, 0x68, 0x22, 0xe5, 0x52, 0x29, 0xb5, 0x62,
+    0xe6, 0x13, 0x04, 0x9b, 0x3a, 0x8c, 0x64, 0x1a, 0xad, 0x9a, 0x0a, 0x5a, 0x92, 0xc2, 0x15,
+    0xe6, 0x45, 0x63, 0x85, 0x27, 0x93, 0x56, 0x6f, 0x61, 0x8e, 0x34, 0x52, 0xa0, 0x2b, 0x67,
+    0x18, 0x1d, 0xea, 0x8e, 0x69, 0x0b, 0xe4, 0xf2, 0xc4, 0x9f, 0x73, 0x4a, 0xe1, 0xca, 0xee,
+    0x23, 0x53, 0x58, 0xe4, 0x50, 0xc7, 0x3d, 0xe9, 0xa0, 0xd2, 0x2d, 0x21, 0xca, 0x69, 0x09,
+    0xc5, 0x20, 0x38, 0x6a, 0x57, 0x19, 0xc7, 0x34, 0x0f, 0xa8, 0xdc, 0xd2, 0x83, 0x4d, 0xe4,
+    0x36, 0x29, 0xc2, 0x90, 0x31, 0x73, 0x45, 0x19, 0xa4, 0xcd, 0x32, 0x47, 0x76, 0xa6, 0x1e,
+    0xb4, 0xb4, 0x94, 0x00, 0x51, 0x45, 0x25, 0x20, 0x0a, 0x4a, 0x53, 0x4d, 0x3c, 0x52, 0x00,
+    0x24, 0x53, 0x09, 0xa0, 0xd2, 0x13, 0x48, 0xab, 0x01, 0xa4, 0xa0, 0xd2, 0x52, 0x18, 0xb4,
+    0x86, 0x8a, 0x0d, 0x00, 0x14, 0xda, 0x75, 0x36, 0x90, 0x0d, 0x3c, 0x53, 0x73, 0x4e, 0x6a,
+    0x61, 0xa9, 0x63, 0x42, 0xe6, 0x9b, 0x49, 0x9a, 0x33, 0x52, 0xd8, 0xc0, 0x9a, 0x4a, 0x4a,
+    0x29, 0x00, 0xb4, 0xaa, 0xb9, 0xa0, 0x0a, 0x9e, 0x14, 0xc9, 0xa1, 0x20, 0x1a, 0xb1, 0x13,
+    0x4a, 0x63, 0x23, 0xb5, 0x69, 0xc3, 0x6d, 0xb8, 0x74, 0xa5, 0x9a, 0xdb, 0x68, 0xe9, 0x57,
+    0xc9, 0xa0, 0x19, 0x0c, 0xb8, 0xa6, 0x55, 0x89, 0x97, 0x06, 0xab, 0x9a, 0x87, 0xa0, 0x09,
+    0x4b, 0x45, 0x14, 0x80, 0x28, 0xa2, 0x96, 0x90, 0x05, 0x14, 0x51, 0x4c, 0x02, 0x8a, 0x28,
+    0xa0, 0x02, 0x8a, 0x4a, 0x4c, 0xd2, 0x01, 0x4d, 0x25, 0x26, 0x69, 0x09, 0xa5, 0x70, 0x17,
+    0x34, 0x99, 0xa4, 0x26, 0x9a, 0x4d, 0x2b, 0x80, 0xec, 0xd2, 0x66, 0x9b, 0x9a, 0x33, 0x40,
+    0xc5, 0xcd, 0x26, 0x69, 0x33, 0x48, 0x4d, 0x20, 0x17, 0x34, 0x99, 0xa4, 0xcd, 0x26, 0x68,
+    0x18, 0xb9, 0xa2, 0x93, 0x34, 0x94, 0x80, 0x5c, 0xd2, 0x51, 0x49, 0x40, 0x05, 0x25, 0x2d,
+    0x25, 0x00, 0x14, 0x52, 0x66, 0x8a, 0x43, 0x16, 0x92, 0x8a, 0x4c, 0xd0, 0x02, 0xd1, 0x9a,
+    0x4a, 0x28, 0x00, 0xa2, 0x8c, 0xd2, 0x52, 0x00, 0xcd, 0x14, 0x52, 0x50, 0x31, 0x73, 0x49,
+    0x45, 0x14, 0x80, 0x29, 0x28, 0xa2, 0x80, 0x0a, 0x29, 0x28, 0xa0, 0x02, 0x8a, 0x29, 0x29,
+    0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x49, 0x45, 0x03, 0x0a, 0x28, 0xa2, 0x90, 0x05, 0x14,
+    0x52, 0x50, 0x20, 0xcd, 0x14, 0x51, 0x40, 0xc7, 0x51, 0x45, 0x14, 0xc0, 0x29, 0x69, 0x28,
+    0xa6, 0x80, 0x5a, 0x28, 0xa2, 0xa8, 0x41, 0x45, 0x14, 0x50, 0x03, 0xc1, 0xc8, 0xa2, 0x91,
+    0x69, 0x68, 0x00, 0xa5, 0x53, 0xce, 0x29, 0x28, 0xe9, 0x40, 0x12, 0x51, 0x40, 0xe9, 0x45,
+    0x00, 0x14, 0x51, 0x45, 0x00, 0x38, 0x74, 0xa2, 0x81, 0xf7, 0x68, 0x2a, 0xf2, 0x3a, 0x45,
+    0x12, 0x97, 0x96, 0x46, 0x0a, 0xaa, 0x06, 0x49, 0x27, 0x8e, 0x29, 0x81, 0xb1, 0xe1, 0x5f,
+    0x0c, 0xdf, 0xf8, 0xc7, 0xc4, 0x10, 0x68, 0xf6, 0x03, 0x68, 0x63, 0xba, 0x69, 0x88, 0xf9,
+    0x62, 0x41, 0xd5, 0x8f, 0xf8, 0x77, 0x35, 0xf5, 0xbf, 0x86, 0xfc, 0x39, 0xa7, 0x78, 0x53,
+    0x44, 0x83, 0x4b, 0xd3, 0x62, 0x09, 0x0c, 0x63, 0xe6, 0x63, 0xf7, 0xa4, 0x6e, 0xec, 0xc7,
+    0xb9, 0x35, 0xcd, 0xfc, 0x2d, 0xf0, 0x2a, 0x78, 0x2b, 0xc3, 0x4b, 0xf6, 0x84, 0x53, 0xaa,
+    0x5d, 0x81, 0x25, 0xd3, 0x7f, 0x77, 0xd1, 0x07, 0xb0, 0xfe, 0x79, 0xae, 0xbe, 0xf6, 0xf1,
+    0x6d, 0xa2, 0x24, 0x9e, 0x7b, 0x0a, 0xcd, 0xbb, 0x9b, 0xc2, 0x36, 0x57, 0x63, 0xae, 0x6e,
+    0xd2, 0x05, 0xc9, 0x3c, 0xfa, 0x56, 0x2d, 0xc6, 0xaa, 0xf2, 0x64, 0x03, 0xc7, 0xa0, 0xac,
+    0xcb, 0xbb, 0xf9, 0x2e, 0x24, 0x3c, 0xe4, 0x66, 0xa0, 0xde, 0x71, 0x8c, 0xd3, 0x48, 0xa7,
+    0x2e, 0xc6, 0x9c, 0x5a, 0x83, 0x24, 0xaa, 0xc4, 0xf0, 0x0d, 0x5f, 0x9b, 0x5a, 0x5d, 0x9f,
+    0x29, 0x39, 0xae, 0x74, 0x1c, 0x52, 0x82, 0x58, 0xe0, 0x53, 0xb0, 0xae, 0xcd, 0x17, 0xd4,
+    0x66, 0x76, 0xe1, 0xb1, 0xf4, 0xaa, 0x5a, 0xff, 0x00, 0x8d, 0xec, 0x3c, 0x11, 0xa3, 0x1b,
+    0xdd, 0x56, 0x7f, 0x36, 0xe6, 0x50, 0x7e, 0xcd, 0x66, 0xad, 0xfb, 0xc9, 0x3d, 0xfd, 0x87,
+    0xbd, 0x71, 0xbe, 0x37, 0xf8, 0x81, 0x69, 0xe1, 0x38, 0x4d, 0xa5, 0x9e, 0xcb, 0x9d, 0x59,
+    0xc7, 0x08, 0x4e, 0x56, 0x2f, 0x76, 0xff, 0x00, 0x0a, 0xf0, 0xfb, 0xfb, 0xdb, 0xed, 0x6f,
+    0x50, 0x93, 0x50, 0xd5, 0x2e, 0x1e, 0x7b, 0x89, 0x0f, 0x25, 0xcf, 0x41, 0xd8, 0x0f, 0x41,
+    0xed, 0x45, 0xae, 0x44, 0xa7, 0x62, 0xe7, 0x88, 0x35, 0xfb, 0xcf, 0x16, 0x78, 0x8e, 0xe3,
+    0x5b, 0xbe, 0x00, 0x49, 0x29, 0x01, 0x50, 0x74, 0x45, 0x1d, 0x00, 0xf6, 0x15, 0x4f, 0x39,
+    0x61, 0x4c, 0x02, 0xa4, 0x44, 0x27, 0x9a, 0xda, 0x2a, 0xc6, 0x2d, 0xdc, 0xb3, 0x1a, 0xe5,
+    0x2a, 0x26, 0x4f, 0x98, 0x8a, 0x9e, 0x20, 0x76, 0xd4, 0x60, 0xe6, 0x42, 0x2b, 0x66, 0xb4,
+    0x11, 0x11, 0x18, 0x38, 0xab, 0x96, 0x63, 0x2c, 0x05, 0x45, 0xe5, 0x8d, 0xfc, 0xf4, 0xab,
+    0x76, 0xab, 0xfb, 0xce, 0x29, 0xc2, 0x3a, 0x93, 0x27, 0xa1, 0x15, 0xe6, 0x03, 0x62, 0x99,
+    0x6e, 0x32, 0x29, 0x6f, 0x7f, 0xd6, 0x52, 0xd9, 0xb0, 0xdd, 0x8a, 0x7f, 0x6c, 0x17, 0xc2,
+    0x3b, 0x6f, 0xcd, 0x46, 0x33, 0x9c, 0xd4, 0xcf, 0x85, 0x62, 0x7b, 0xd4, 0x58, 0x3c, 0x9a,
+    0xbb, 0x02, 0x64, 0x64, 0x53, 0xa3, 0x38, 0x60, 0x69, 0x84, 0xd3, 0xa3, 0xe4, 0x66, 0xa1,
+    0x6e, 0x32, 0xf6, 0x03, 0xad, 0x54, 0x90, 0x10, 0x71, 0x56, 0xa1, 0x39, 0x5a, 0x82, 0xe3,
+    0xef, 0x56, 0x8f, 0x63, 0x38, 0xe8, 0xec, 0x43, 0x4e, 0x43, 0x87, 0x14, 0xca, 0x5a, 0x84,
+    0xcb, 0x34, 0xe4, 0x98, 0x0b, 0x70, 0x01, 0xae, 0x7e, 0xfe, 0xee, 0x55, 0x95, 0x60, 0x80,
+    0x13, 0x23, 0xfa, 0x0c, 0x9e, 0x7a, 0x01, 0x57, 0xcb, 0x92, 0x31, 0x5d, 0x37, 0xc2, 0x76,
+    0xb6, 0x4f, 0x8b, 0x56, 0x22, 0xe9, 0x63, 0x21, 0xe2, 0x71, 0x17, 0x98, 0x07, 0x0f, 0xb7,
+    0x23, 0x1e, 0xfc, 0x1a, 0x9a, 0xf3, 0x7c, 0xba, 0x05, 0x38, 0x24, 0xec, 0x6d, 0xf8, 0x7f,
+    0xe0, 0x26, 0xb7, 0xa8, 0x69, 0x89, 0x79, 0xaa, 0xeb, 0x5f, 0xd9, 0xb3, 0xca, 0xbb, 0x96,
+    0xdc, 0x44, 0x64, 0x65, 0xcf, 0xf7, 0xce, 0xe0, 0x01, 0xf6, 0x19, 0xa8, 0x35, 0x3f, 0x83,
+    0xfe, 0x39, 0xd1, 0xd4, 0xb5, 0x8c, 0x96, 0x9a, 0xb4, 0x23, 0x27, 0x6a, 0x3e, 0xd7, 0xc7,
+    0xd1, 0xb1, 0xfa, 0x13, 0x5f, 0x48, 0x1e, 0x29, 0xbb, 0xf9, 0xae, 0x25, 0x52, 0x4b, 0x66,
+    0x74, 0xba, 0x51, 0x6b, 0x53, 0xe5, 0x0b, 0x7d, 0x07, 0xc7, 0x1a, 0x85, 0xc9, 0xd3, 0x6d,
+    0x7c, 0x33, 0x7d, 0x04, 0xed, 0xc3, 0x3c, 0xb0, 0xb2, 0x2a, 0xfb, 0x96, 0x6c, 0x01, 0x5e,
+    0x8f, 0xe1, 0xbf, 0xd9, 0xff, 0x00, 0x4e, 0x16, 0x42, 0x6f, 0x13, 0x5e, 0xdc, 0x5c, 0x5f,
+    0x49, 0xcb, 0x47, 0x6d, 0x26, 0xd4, 0x8f, 0xdb, 0x24, 0x65, 0x8f, 0xbf, 0x15, 0xed, 0x20,
+    0xd2, 0x33, 0x81, 0x44, 0xaa, 0x4a, 0x5b, 0x8a, 0x34, 0xa3, 0x1d, 0x8f, 0x06, 0xf1, 0x4f,
+    0xec, 0xff, 0x00, 0x2d, 0xba, 0x9b, 0xbf, 0x09, 0xdf, 0xbc, 0x8c, 0xbc, 0x9b, 0x5b, 0xb6,
+    0x01, 0x8f, 0xfb, 0xae, 0x00, 0x1f, 0x81, 0x03, 0xeb, 0x5e, 0x59, 0x23, 0xde, 0xe9, 0x7a,
+    0x84, 0x9a, 0x66, 0xb1, 0x6d, 0x25, 0xb5, 0xdc, 0x47, 0x6b, 0x2c, 0x8b, 0xb4, 0x83, 0xef,
+    0xfe, 0x35, 0xf6, 0x60, 0x90, 0x77, 0xae, 0x23, 0xe2, 0x67, 0xc3, 0xeb, 0x5f, 0x1b, 0xe8,
+    0x6c, 0xf0, 0xc6, 0x89, 0xac, 0x5b, 0xa9, 0x36, 0xb3, 0xf4, 0xdd, 0xdf, 0xcb, 0x63, 0xfd,
+    0xd3, 0xfa, 0x1e, 0x7d, 0x72, 0xe1, 0x51, 0xc1, 0xe8, 0x13, 0xa7, 0x73, 0xe7, 0x4c, 0xd3,
+    0x83, 0x7a, 0x8a, 0xa1, 0x6b, 0x2c, 0xd1, 0x4d, 0x2d, 0x8d, 0xe2, 0x34, 0x77, 0x50, 0x31,
+    0x47, 0x47, 0x18, 0x20, 0x8e, 0x08, 0x3e, 0xe2, 0xae, 0x66, 0xbd, 0x08, 0x49, 0x49, 0x5d,
+    0x1c, 0xad, 0x12, 0x6e, 0xf4, 0xa6, 0xb1, 0xcd, 0x37, 0x3f, 0x85, 0x21, 0x38, 0xaa, 0x12,
+    0x42, 0x13, 0x4e, 0x46, 0xc3, 0x54, 0x64, 0xd0, 0x0d, 0x05, 0x58, 0xd0, 0x87, 0xa9, 0xa5,
+    0x4b, 0x86, 0x82, 0x52, 0xc8, 0x01, 0xcf, 0x04, 0x1e, 0xf5, 0x0c, 0x52, 0x00, 0x87, 0x9a,
+    0x81, 0xa4, 0x25, 0xb3, 0x9a, 0x66, 0x2a, 0x17, 0x6c, 0xb3, 0x71, 0x3b, 0x5c, 0x49, 0xb9,
+    0x80, 0x1c, 0x63, 0x02, 0xab, 0xb1, 0xf4, 0xa6, 0x99, 0x0d, 0x33, 0x7d, 0x22, 0xd4, 0x6c,
+    0x3b, 0x71, 0xa4, 0xcd, 0x26, 0x69, 0x28, 0x2c, 0x5c, 0xd0, 0xa7, 0x9a, 0x6e, 0x68, 0xe7,
+    0x39, 0xa4, 0x02, 0xb6, 0x43, 0x53, 0xc1, 0xc8, 0xa6, 0x37, 0x4a, 0x10, 0xd0, 0x2e, 0x82,
+    0xd3, 0xa9, 0x3b, 0xd2, 0x9a, 0x09, 0x62, 0x1e, 0xb4, 0x51, 0x47, 0x5a, 0x40, 0x14, 0x94,
+    0xb4, 0x94, 0x08, 0x29, 0x31, 0x4e, 0x14, 0x86, 0x80, 0x12, 0x90, 0xf3, 0x45, 0x06, 0x90,
+    0x0d, 0x22, 0x9a, 0x56, 0x9f, 0x49, 0x48, 0x64, 0x64, 0x52, 0x1a, 0x7b, 0x0a, 0x69, 0xa4,
+    0x31, 0x29, 0x28, 0x34, 0x1a, 0x06, 0x06, 0x90, 0xd3, 0x49, 0xa4, 0x2d, 0x48, 0x76, 0x02,
+    0x69, 0x86, 0x94, 0x9a, 0x6d, 0x4b, 0x63, 0x03, 0x4d, 0xa5, 0xa3, 0x15, 0x0c, 0x62, 0x52,
+    0xd1, 0x45, 0x00, 0x38, 0x55, 0x98, 0x0e, 0x0d, 0x55, 0x15, 0x2a, 0x36, 0x0d, 0x52, 0xd0,
+    0x46, 0xed, 0xbc, 0x8a, 0x16, 0x8b, 0x89, 0x14, 0xa9, 0xac, 0xc8, 0xee, 0x08, 0x1d, 0x69,
+    0xcd, 0x31, 0x71, 0x5a, 0x73, 0xe8, 0x22, 0x19, 0xce, 0x49, 0xaa, 0xa4, 0x54, 0xf2, 0x03,
+    0xde, 0xa1, 0x35, 0x93, 0x18, 0x98, 0xa5, 0xc5, 0x14, 0x52, 0xb0, 0x06, 0x29, 0x69, 0x33,
+    0x46, 0x68, 0x00, 0xa3, 0x34, 0x84, 0xd2, 0x66, 0x90, 0x0b, 0x49, 0x49, 0x9a, 0x69, 0x34,
+    0xae, 0x02, 0xe6, 0x90, 0x9a, 0x69, 0x34, 0x84, 0xd4, 0x8c, 0x52, 0x69, 0x09, 0xa6, 0x93,
+    0x49, 0x9a, 0x00, 0x71, 0x34, 0xdc, 0xd2, 0x51, 0x9a, 0x43, 0x0c, 0xd2, 0x66, 0x8a, 0x28,
+    0x00, 0xa2, 0x8a, 0x29, 0x00, 0x52, 0x52, 0xd1, 0x40, 0x0d, 0xa2, 0x96, 0x8a, 0x00, 0x4a,
+    0x4a, 0x5a, 0x4a, 0x43, 0x0a, 0x4c, 0xd1, 0x45, 0x00, 0x19, 0xa4, 0xa2, 0x8a, 0x40, 0x14,
+    0x52, 0x66, 0x8a, 0x00, 0x33, 0x45, 0x14, 0x94, 0x0c, 0x5a, 0x4a, 0x28, 0xa0, 0x02, 0x8a,
+    0x4a, 0x29, 0x00, 0x51, 0x45, 0x25, 0x00, 0x2d, 0x25, 0x14, 0x50, 0x01, 0x46, 0x69, 0x28,
+    0xa4, 0x01, 0x45, 0x14, 0x99, 0xa0, 0x05, 0xa4, 0xa2, 0x8a, 0x43, 0x0a, 0x28, 0xa2, 0x80,
+    0x0a, 0x28, 0xa4, 0xa0, 0x41, 0x45, 0x14, 0x50, 0x30, 0xa2, 0x8a, 0x28, 0x01, 0xd4, 0x51,
+    0x45, 0x30, 0x0a, 0x28, 0xa2, 0x80, 0x16, 0x8a, 0x4a, 0x5a, 0xa4, 0x20, 0xa2, 0x8a, 0x29,
+    0x80, 0x0e, 0xb4, 0xfa, 0x65, 0x38, 0x1e, 0xd4, 0x00, 0xb4, 0x52, 0x85, 0xcf, 0x5a, 0x78,
+    0x5f, 0x41, 0x40, 0x0d, 0x53, 0xda, 0x9d, 0x4b, 0xb7, 0xda, 0x92, 0x80, 0x0a, 0x28, 0xa5,
+    0x14, 0x00, 0xe1, 0xf7, 0x4d, 0x7a, 0x8f, 0xc0, 0xcf, 0x08, 0x8d, 0x6b, 0xc4, 0x72, 0x6b,
+    0xf7, 0x71, 0xe6, 0xd3, 0x4e, 0x20, 0x44, 0x08, 0xe1, 0xa6, 0x3d, 0x3f, 0x21, 0xcf, 0xd7,
+    0x15, 0xe5, 0xf1, 0xc1, 0x2d, 0xd4, 0xd1, 0x5a, 0xc0, 0xa5, 0xa6, 0x99, 0xc2, 0x22, 0x8e,
+    0xe4, 0x9c, 0x01, 0x5f, 0x62, 0xf8, 0x37, 0xc3, 0x70, 0x78, 0x4f, 0xc2, 0x96, 0x5a, 0x4c,
+    0x20, 0x6e, 0x8d, 0x37, 0x4a, 0xc3, 0xf8, 0xe4, 0x3c, 0xb1, 0xfc, 0xe9, 0x49, 0x97, 0x08,
+    0xdd, 0x9b, 0x17, 0x13, 0xac, 0x31, 0x17, 0x6e, 0xd5, 0xc8, 0x6a, 0x37, 0xaf, 0x71, 0x29,
+    0x19, 0xab, 0xfa, 0xc5, 0xfe, 0xe7, 0x2a, 0xa7, 0xe5, 0x1c, 0x0f, 0xf1, 0xac, 0x20, 0x72,
+    0x4b, 0x1e, 0xb4, 0x92, 0x35, 0x93, 0xe8, 0x39, 0x57, 0x1f, 0x5a, 0x7d, 0x20, 0xa7, 0x0a,
+    0xa1, 0x09, 0x5c, 0x3f, 0x8f, 0xfc, 0x76, 0x9e, 0x1d, 0xb6, 0x36, 0x16, 0x0e, 0x1b, 0x54,
+    0x95, 0x78, 0xc7, 0x3e, 0x50, 0x3d, 0xcf, 0xbf, 0xa5, 0x74, 0xbe, 0x23, 0xd6, 0xad, 0xfc,
+    0x3b, 0xe1, 0xfb, 0xad, 0x52, 0xe5, 0xbf, 0xd5, 0xae, 0xd8, 0x63, 0x1d, 0x64, 0x90, 0xf4,
+    0x1f, 0x4e, 0xe7, 0xe9, 0x5f, 0x3b, 0x4a, 0xf3, 0xde, 0xcd, 0x36, 0xa5, 0x7a, 0xe6, 0x4b,
+    0x89, 0xd8, 0xb1, 0x26, 0x9a, 0x4d, 0xec, 0x44, 0xe5, 0x6d, 0x0a, 0xdf, 0xbc, 0x96, 0x67,
+    0xb8, 0xb8, 0x76, 0x92, 0x67, 0x3b, 0x99, 0x98, 0xe4, 0x93, 0x53, 0xa0, 0xc8, 0xa8, 0xea,
+    0x58, 0x8f, 0x06, 0xae, 0x2a, 0xc6, 0x4c, 0x50, 0xbc, 0x73, 0x57, 0xad, 0xe3, 0xcc, 0x75,
+    0x51, 0x79, 0x35, 0xa5, 0x6d, 0x8d, 0x95, 0xbd, 0x35, 0xa9, 0x32, 0x76, 0x40, 0x63, 0xd9,
+    0x11, 0x35, 0x9a, 0x5f, 0x12, 0x66, 0xb4, 0xef, 0x5f, 0x6c, 0x40, 0x56, 0x41, 0x3c, 0xe6,
+    0x9d, 0x57, 0x67, 0x61, 0x47, 0x55, 0x72, 0xdb, 0x12, 0xca, 0x0d, 0x5b, 0xb0, 0x1c, 0xd5,
+    0x08, 0x98, 0x91, 0x8a, 0xb9, 0x09, 0x68, 0xd4, 0x91, 0x4e, 0x1a, 0xbb, 0x84, 0x96, 0x96,
+    0x22, 0xbe, 0xff, 0x00, 0x58, 0x6a, 0x3b, 0x63, 0xfb, 0xc1, 0x4c, 0x9a, 0x42, 0xee, 0x49,
+    0xa4, 0x89, 0xb6, 0xb8, 0x35, 0x37, 0xf7, 0xae, 0x34, 0xb4, 0xb1, 0xa3, 0x3e, 0x32, 0x2a,
+    0x61, 0x16, 0x60, 0xcd, 0x50, 0x96, 0x60, 0x71, 0x83, 0x5a, 0x76, 0x4c, 0x24, 0x80, 0xad,
+    0x6d, 0x16, 0x9b, 0x33, 0x9d, 0xe3, 0x13, 0x2a, 0x4e, 0x1f, 0x15, 0x28, 0xc2, 0xc7, 0x45,
+    0xca, 0x6d, 0x98, 0x8f, 0x7a, 0x47, 0xe2, 0x3a, 0x8d, 0x9b, 0x2e, 0xf7, 0x2d, 0xd9, 0x48,
+    0x09, 0x2a, 0x7b, 0xd3, 0x2e, 0xd7, 0x6b, 0xe6, 0xaa, 0xc1, 0x26, 0xc9, 0x01, 0xab, 0xd7,
+    0x27, 0x7a, 0x06, 0x15, 0x49, 0xde, 0x24, 0x35, 0x69, 0x5c, 0xa9, 0x8f, 0x97, 0x34, 0xda,
+    0x91, 0x86, 0x12, 0xa2, 0x19, 0xa8, 0x96, 0x85, 0x8e, 0xa8, 0x5d, 0xee, 0x6d, 0x6e, 0xad,
+    0xf5, 0x0b, 0x29, 0x1a, 0x3b, 0xbb, 0x59, 0x04, 0x91, 0xba, 0x9e, 0x41, 0x07, 0x22, 0xa5,
+    0xa3, 0xad, 0x26, 0x94, 0x95, 0x98, 0xd1, 0xf5, 0x57, 0x81, 0xbc, 0x59, 0x6d, 0xe3, 0x3f,
+    0x0b, 0x5a, 0xea, 0x71, 0x32, 0x0b, 0x8d, 0xbb, 0x2e, 0x61, 0x53, 0xcc, 0x52, 0x8e, 0xa3,
+    0x1e, 0x9d, 0xc7, 0xb1, 0x15, 0xaf, 0x74, 0x4c, 0x38, 0x90, 0x03, 0x8e, 0x84, 0x8a, 0xf9,
+    0x4f, 0xc2, 0x9e, 0x2b, 0xbe, 0xf0, 0x36, 0xbe, 0xba, 0xa5, 0x9e, 0x64, 0xb4, 0x90, 0x85,
+    0xbc, 0xb6, 0xce, 0x04, 0x89, 0xea, 0x3d, 0x08, 0xec, 0x6b, 0xea, 0x7d, 0x23, 0x57, 0xd3,
+    0xfc, 0x49, 0xa3, 0x43, 0xa8, 0xe9, 0xf3, 0x2c, 0xf6, 0x97, 0x0b, 0x95, 0x23, 0xa8, 0xf5,
+    0x04, 0x76, 0x22, 0xb8, 0xa7, 0x17, 0x17, 0x66, 0x74, 0xc2, 0x77, 0x44, 0x91, 0xdd, 0x23,
+    0x8e, 0xbc, 0xd4, 0x37, 0x37, 0xa1, 0x72, 0x10, 0x64, 0xfa, 0xd5, 0x2b, 0xa8, 0x5e, 0xde,
+    0x52, 0xb9, 0x38, 0xec, 0x6a, 0xb9, 0x91, 0x98, 0x72, 0x69, 0x58, 0xd2, 0xe6, 0x84, 0x5a,
+    0x80, 0x24, 0x06, 0xad, 0x18, 0xa5, 0x04, 0x02, 0x0e, 0x54, 0xd7, 0x3a, 0x3a, 0xd5, 0xb8,
+    0x27, 0x31, 0x0c, 0x67, 0x2a, 0x68, 0x68, 0x57, 0x3c, 0x9f, 0xe3, 0x87, 0x81, 0xbc, 0x89,
+    0x57, 0xc6, 0x3a, 0x5c, 0x38, 0x20, 0x85, 0xbf, 0x45, 0x1f, 0x80, 0x93, 0xfa, 0x1f, 0xc3,
+    0xde, 0xbc, 0xaa, 0x19, 0x84, 0xd1, 0x2c, 0x88, 0x78, 0x35, 0xf5, 0xe0, 0x48, 0x35, 0x4d,
+    0x3e, 0x6b, 0x4b, 0xa8, 0xd6, 0x58, 0x65, 0x43, 0x1c, 0x88, 0xdd, 0x19, 0x48, 0xc1, 0x15,
+    0xf2, 0x97, 0x8a, 0x7c, 0x39, 0x3f, 0x82, 0x7c, 0x5f, 0x75, 0xa3, 0x4b, 0xb9, 0xad, 0x5c,
+    0xf9, 0x96, 0xb2, 0x1f, 0xe2, 0x43, 0xd3, 0xf1, 0xec, 0x7d, 0xc5, 0x6d, 0x42, 0xa7, 0x2b,
+    0xb3, 0x30, 0xab, 0x0e, 0xa5, 0x4c, 0x86, 0xfa, 0xd2, 0x1a, 0x40, 0x79, 0xcd, 0x23, 0x1a,
+    0xee, 0x30, 0x0c, 0xd2, 0x51, 0x45, 0x4d, 0xc6, 0x28, 0x62, 0x29, 0x33, 0x49, 0x4a, 0x0e,
+    0x0f, 0x23, 0x34, 0xee, 0x01, 0x9a, 0x4c, 0xd1, 0x45, 0x2b, 0x80, 0x66, 0x97, 0x93, 0x4d,
+    0xea, 0x69, 0xc1, 0xbe, 0x5d, 0xb8, 0xfc, 0x68, 0xb8, 0x07, 0x6a, 0x29, 0x28, 0xef, 0x4c,
+    0x40, 0x4d, 0x39, 0x29, 0xb4, 0xf5, 0xe2, 0x81, 0x31, 0xf4, 0x1a, 0x5e, 0xa6, 0x90, 0xd0,
+    0x40, 0xda, 0x5c, 0x51, 0x45, 0x00, 0x14, 0x86, 0x8a, 0x69, 0x6a, 0x40, 0x2d, 0x21, 0xa6,
+    0xef, 0xa3, 0x75, 0x21, 0xd8, 0x5a, 0x29, 0x32, 0x28, 0xa0, 0x02, 0x92, 0x83, 0x9e, 0xd4,
+    0xde, 0x69, 0x00, 0xa6, 0x98, 0x7a, 0xd2, 0xe6, 0x90, 0xf5, 0xa0, 0x62, 0x1a, 0x31, 0x46,
+    0x69, 0x73, 0x48, 0x64, 0x4c, 0x31, 0x51, 0x9a, 0xb6, 0xb0, 0x34, 0x8b, 0xb8, 0x10, 0x07,
+    0x6c, 0xf7, 0xaa, 0xce, 0xa5, 0x58, 0x82, 0x30, 0x45, 0x4c, 0x90, 0xd3, 0xb9, 0x1e, 0x69,
+    0x69, 0x0d, 0x02, 0xb3, 0x28, 0x5a, 0x31, 0x40, 0xa7, 0x55, 0x08, 0x6e, 0x28, 0xc5, 0x3b,
+    0x14, 0x11, 0x45, 0x80, 0x4a, 0x28, 0xa5, 0xa4, 0x02, 0x86, 0xab, 0xf6, 0x48, 0xae, 0xdf,
+    0x35, 0x67, 0xe2, 0xa6, 0x8a, 0x56, 0x8c, 0xf1, 0x55, 0x1d, 0xc0, 0xd1, 0xbe, 0x81, 0x11,
+    0x7e, 0x5c, 0x56, 0x4b, 0x0e, 0x6a, 0xc4, 0x97, 0x0d, 0x20, 0xc1, 0x35, 0x05, 0x39, 0x6a,
+    0xc4, 0x36, 0x8a, 0x0d, 0x21, 0xa9, 0x00, 0xa2, 0x93, 0x34, 0xd2, 0x6a, 0x5b, 0x18, 0xa4,
+    0xd2, 0x66, 0x9a, 0x4d, 0x37, 0x35, 0x0d, 0x8c, 0x71, 0x34, 0xd2, 0x69, 0x33, 0x93, 0x8e,
+    0xf4, 0xae, 0x8c, 0x98, 0xdd, 0xde, 0x90, 0x0d, 0x26, 0x93, 0x34, 0x99, 0xa4, 0xcd, 0x21,
+    0x8b, 0x9a, 0x4c, 0xd2, 0x66, 0x8c, 0xd2, 0x01, 0x73, 0x45, 0x20, 0xa5, 0xa0, 0x05, 0xa4,
+    0xa3, 0x34, 0x50, 0x01, 0x45, 0x25, 0x14, 0x00, 0x66, 0x8c, 0xd1, 0x49, 0x9a, 0x00, 0x29,
+    0x39, 0xa5, 0xcd, 0x25, 0x21, 0x89, 0x9a, 0x29, 0x69, 0x38, 0xa0, 0x03, 0x34, 0x94, 0x66,
+    0x8c, 0xd0, 0x02, 0x1a, 0x28, 0x34, 0x11, 0x48, 0x61, 0x9a, 0x4a, 0x29, 0x33, 0x48, 0x05,
+    0xa3, 0x34, 0x94, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x8a, 0x4a,
+    0x28, 0xa4, 0x02, 0x51, 0x4b, 0x49, 0x40, 0x05, 0x14, 0x52, 0x50, 0x01, 0x45, 0x14, 0x52,
+    0x18, 0x51, 0x46, 0x0d, 0x14, 0x08, 0x28, 0xa2, 0x8a, 0x00, 0x4a, 0x29, 0x68, 0xcd, 0x03,
+    0x12, 0x8a, 0x33, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x3a, 0x8a, 0x28, 0xa6, 0x01, 0x45,
+    0x4c, 0x88, 0x1a, 0x3c, 0xf7, 0xa8, 0x4f, 0x06, 0x9b, 0x40, 0x14, 0xb4, 0x94, 0xb4, 0x20,
+    0x0a, 0x28, 0xa2, 0xa8, 0x41, 0x4a, 0x3a, 0x8a, 0x4a, 0x07, 0x5a, 0x00, 0xb0, 0xa3, 0x75,
+    0x5d, 0xb4, 0xb2, 0x9a, 0xee, 0x51, 0x14, 0x11, 0x97, 0x73, 0xce, 0x07, 0x6a, 0xa5, 0x11,
+    0xae, 0xb3, 0xc2, 0x73, 0xc2, 0x93, 0xcb, 0x14, 0x8c, 0x15, 0x9f, 0x05, 0x73, 0xdc, 0x7a,
+    0x56, 0xb4, 0xe2, 0x9b, 0x26, 0x4e, 0xc8, 0xc8, 0xbc, 0xd1, 0xef, 0x2c, 0xa3, 0x12, 0x4f,
+    0x0e, 0x10, 0xff, 0x00, 0x10, 0x39, 0x15, 0x9a, 0xcb, 0xcd, 0x7a, 0xbf, 0x88, 0xe6, 0xb0,
+    0x8f, 0x40, 0x95, 0x58, 0xa6, 0xe7, 0x5c, 0x2a, 0xf7, 0x26, 0xbc, 0xa6, 0x42, 0x32, 0x71,
+    0x4e, 0x71, 0x48, 0x11, 0x19, 0x18, 0x34, 0xf4, 0x8a, 0x47, 0x04, 0xa2, 0x33, 0x01, 0xd7,
+    0x03, 0xa5, 0x31, 0x8f, 0x35, 0xa3, 0x67, 0xa9, 0x7d, 0x96, 0xd4, 0xc5, 0xe5, 0x6e, 0x39,
+    0x24, 0x1c, 0xff, 0x00, 0x3a, 0x88, 0xa4, 0xde, 0xac, 0x6d, 0xbb, 0x68, 0x75, 0xdf, 0x06,
+    0xf4, 0x3f, 0xed, 0x9f, 0x88, 0x96, 0xb3, 0x3a, 0x6e, 0x83, 0x4f, 0x43, 0x70, 0xfe, 0x9b,
+    0xba, 0x2f, 0xea, 0x7f, 0x4a, 0xfa, 0x76, 0xfe, 0x6f, 0x26, 0xd5, 0xdb, 0x3c, 0xe3, 0x02,
+    0xbc, 0x93, 0xf6, 0x7c, 0xd3, 0x3c, 0xbd, 0x13, 0x55, 0xd5, 0x9d, 0x3e, 0x7b, 0x9b, 0x81,
+    0x12, 0x31, 0x1d, 0x55, 0x46, 0x4e, 0x3f, 0x16, 0xfd, 0x2b, 0xd2, 0x7c, 0x43, 0x3e, 0xc8,
+    0x55, 0x01, 0xeb, 0x59, 0x3d, 0x59, 0xd1, 0x4d, 0x5a, 0x37, 0x39, 0xbb, 0x99, 0x4c, 0x92,
+    0x93, 0xf9, 0x54, 0x60, 0xd3, 0x18, 0xd3, 0x96, 0xa8, 0x44, 0xc8, 0x38, 0xa7, 0x52, 0x02,
+    0x00, 0x14, 0xd9, 0x24, 0x11, 0x44, 0xf2, 0xb7, 0xdd, 0x45, 0x2c, 0x7e, 0x82, 0x81, 0x9e,
+    0x3f, 0xf1, 0x5b, 0x57, 0x3a, 0x8f, 0x88, 0x2c, 0xf4, 0x58, 0x98, 0x98, 0xad, 0x46, 0xf9,
+    0x40, 0xe8, 0x58, 0xff, 0x00, 0xf5, 0xab, 0x8d, 0xbd, 0x61, 0xb4, 0x28, 0x18, 0x03, 0xa0,
+    0xab, 0x0b, 0x73, 0x26, 0xb5, 0xe2, 0x4d, 0x43, 0x53, 0x97, 0xfe, 0x5a, 0x48, 0xc7, 0x1e,
+    0x99, 0x3c, 0x0f, 0xca, 0xab, 0xea, 0x40, 0x2b, 0x62, 0xba, 0x20, 0xad, 0x4d, 0xb3, 0x99,
+    0xca, 0xf2, 0xb1, 0x40, 0x1a, 0x96, 0x2e, 0xf5, 0x0d, 0x4b, 0x09, 0xf9, 0xb1, 0x59, 0xad,
+    0xc6, 0x58, 0x89, 0x72, 0xd5, 0xa1, 0x08, 0xc0, 0xaa, 0xa9, 0x1e, 0xd3, 0x9a, 0xb2, 0xa4,
+    0xaa, 0xd7, 0x55, 0x35, 0x62, 0x1e, 0xa5, 0x6b, 0xe9, 0x72, 0x71, 0x54, 0x6a, 0x7b, 0xa6,
+    0xf9, 0xea, 0x0a, 0xc6, 0x6e, 0xf2, 0x29, 0x2d, 0x09, 0xed, 0xcf, 0xcd, 0x5a, 0x59, 0x54,
+    0x80, 0xe7, 0xbd, 0x64, 0xc6, 0xdb, 0x5c, 0x1a, 0xb3, 0x34, 0xd9, 0x40, 0x01, 0xab, 0x84,
+    0x92, 0x42, 0x6a, 0xe4, 0x2e, 0x72, 0xe4, 0xd2, 0x52, 0x52, 0xd6, 0x77, 0x18, 0x66, 0xb5,
+    0x34, 0xe9, 0x3b, 0x56, 0x5d, 0x5c, 0xb0, 0x62, 0x24, 0x15, 0xa5, 0x37, 0xef, 0x13, 0x35,
+    0x74, 0x4f, 0x72, 0x84, 0xcf, 0x50, 0x4f, 0xc0, 0x02, 0xad, 0xdc, 0x71, 0x26, 0x6a, 0x8c,
+    0xef, 0xb9, 0xab, 0x49, 0xe8, 0x85, 0x1d, 0x90, 0xc0, 0x70, 0x73, 0x5a, 0x31, 0x10, 0xf0,
+    0xfd, 0x2b, 0x2f, 0x35, 0x72, 0xd6, 0x50, 0xa0, 0x83, 0x53, 0x4d, 0xea, 0x39, 0xab, 0xa1,
+    0x25, 0x6e, 0x71, 0x4c, 0x06, 0x89, 0x8e, 0x5e, 0xac, 0x59, 0xdb, 0x24, 0xca, 0xc5, 0xd8,
+    0xf1, 0xd8, 0x76, 0xa1, 0xae, 0x66, 0x26, 0xd2, 0x57, 0x64, 0x14, 0x86, 0x95, 0x86, 0xc7,
+    0x65, 0xce, 0x40, 0x3d, 0x69, 0x09, 0xe3, 0x8a, 0x45, 0x08, 0x40, 0x60, 0x55, 0x86, 0x41,
+    0xae, 0xa7, 0xe1, 0xa7, 0x8e, 0xa6, 0xf0, 0x27, 0x88, 0x56, 0xd2, 0xee, 0x42, 0xda, 0x1d,
+    0xeb, 0x81, 0x28, 0x27, 0x88, 0x5b, 0xa0, 0x90, 0x7d, 0x3b, 0xfa, 0x8f, 0xa5, 0x72, 0xd5,
+    0x15, 0xc4, 0x22, 0x78, 0x4a, 0x1e, 0xbd, 0x8f, 0xa1, 0xa8, 0xa9, 0x1e, 0x64, 0x34, 0xec,
+    0xcf, 0xb2, 0x6e, 0xe1, 0x5b, 0xab, 0x60, 0xf1, 0x90, 0xdc, 0x6e, 0x56, 0x1c, 0x82, 0x2b,
+    0x0c, 0xa6, 0xda, 0xe6, 0x3e, 0x08, 0x78, 0xa5, 0xf5, 0xdf, 0x07, 0x1d, 0x32, 0xe9, 0xcb,
+    0x5e, 0x69, 0x4c, 0x21, 0x25, 0x8f, 0x2d, 0x11, 0xfb, 0x87, 0xf0, 0xc1, 0x5f, 0xc0, 0x57,
+    0x67, 0x7f, 0x0f, 0x95, 0x39, 0xc0, 0xe0, 0xf2, 0x2b, 0x91, 0x76, 0x3a, 0x93, 0xba, 0x29,
+    0x62, 0x9c, 0xa6, 0x82, 0x3d, 0x29, 0x45, 0x31, 0x96, 0x2c, 0xa7, 0x31, 0x4e, 0x33, 0xf7,
+    0x5b, 0x8a, 0xe3, 0x7e, 0x37, 0x78, 0x58, 0x6b, 0x9e, 0x0f, 0x3a, 0xad, 0xbc, 0x79, 0xbd,
+    0xd2, 0xcf, 0x9a, 0x08, 0x1c, 0xb4, 0x5f, 0xc4, 0x3f, 0x0e, 0x0f, 0xe0, 0x6b, 0xac, 0xc7,
+    0x71, 0xd6, 0xb6, 0x21, 0x11, 0xde, 0xd8, 0x34, 0x53, 0xa8, 0x74, 0x91, 0x4a, 0x3a, 0x9e,
+    0x84, 0x1e, 0x08, 0x34, 0x9f, 0x71, 0x35, 0x74, 0x7c, 0x75, 0x6b, 0x37, 0x9f, 0x02, 0xbf,
+    0x7e, 0x87, 0xeb, 0x52, 0xd4, 0xba, 0xc6, 0x90, 0xfe, 0x1a, 0xf1, 0x6e, 0xa9, 0xa2, 0x49,
+    0x9d, 0xb6, 0xf3, 0x37, 0x96, 0x4f, 0x74, 0xea, 0xa7, 0xf1, 0x52, 0x0d, 0x45, 0x5d, 0xf4,
+    0xe5, 0xcd, 0x1b, 0x9c, 0x8d, 0x59, 0x86, 0x69, 0x29, 0x09, 0xa5, 0xaa, 0x00, 0x34, 0x50,
+    0x69, 0x0f, 0x4a, 0x00, 0x5a, 0x29, 0x01, 0xa5, 0x3d, 0x28, 0x42, 0x10, 0x75, 0xa2, 0x81,
+    0x45, 0x00, 0x2d, 0x14, 0x83, 0xad, 0x38, 0x0e, 0x6a, 0x84, 0xc5, 0x14, 0xb4, 0x51, 0x40,
+    0x89, 0x17, 0xee, 0xd2, 0x50, 0x0f, 0x14, 0xaa, 0xa5, 0xa9, 0x90, 0x36, 0x82, 0x2a, 0x61,
+    0x10, 0x1d, 0x68, 0x2a, 0x3d, 0x28, 0xb1, 0x3c, 0xc5, 0x72, 0x0d, 0x33, 0x69, 0xab, 0x45,
+    0x45, 0x34, 0xa8, 0xa5, 0x62, 0x94, 0x8a, 0xc4, 0x11, 0xda, 0x9a, 0x6a, 0xc9, 0x51, 0x4d,
+    0x28, 0x29, 0x58, 0x7c, 0xc4, 0x14, 0x02, 0x45, 0x4a, 0x63, 0x14, 0xc3, 0x1f, 0xa5, 0x21,
+    0xdd, 0x0d, 0xdd, 0x46, 0x45, 0x21, 0x04, 0x52, 0x1a, 0x43, 0xb0, 0x52, 0x1a, 0x42, 0xd4,
+    0x9b, 0xc5, 0x2b, 0x8e, 0xc2, 0x93, 0x8a, 0x42, 0x69, 0x0b, 0x03, 0x4d, 0xc8, 0xa4, 0xd8,
+    0x58, 0xb1, 0x1d, 0xc1, 0x44, 0xda, 0x57, 0x20, 0x74, 0xaa, 0xee, 0xc5, 0xdc, 0xb1, 0xea,
+    0x4d, 0x00, 0xd1, 0x45, 0xee, 0x09, 0x25, 0xa8, 0xc2, 0x29, 0x31, 0x52, 0x05, 0xcd, 0x1b,
+    0x6a, 0x6c, 0x3b, 0x8c, 0xc5, 0x38, 0x51, 0x8a, 0x5a, 0x00, 0x4c, 0x53, 0x88, 0xa5, 0x02,
+    0x9d, 0x8a, 0x76, 0x15, 0xc8, 0xb1, 0x4b, 0x8a, 0x93, 0x68, 0xa3, 0x18, 0xa2, 0xc2, 0xb8,
+    0xcc, 0x51, 0x8a, 0x71, 0xa6, 0x9a, 0x00, 0x43, 0x4d, 0x34, 0xa4, 0xd3, 0x49, 0xa4, 0xca,
+    0x0a, 0x69, 0x34, 0x13, 0x4c, 0x66, 0xe6, 0xa1, 0xb1, 0x8a, 0x5a, 0x98, 0x5a, 0x90, 0x9a,
+    0x61, 0x35, 0x9b, 0x63, 0x1c, 0x4d, 0x26, 0x69, 0xa4, 0xd2, 0x66, 0xa4, 0x07, 0x6e, 0xc1,
+    0xc8, 0xa7, 0x34, 0xac, 0xfd, 0x7b, 0x54, 0x64, 0xd2, 0x66, 0x8b, 0x85, 0x87, 0x13, 0x4d,
+    0xa4, 0xcd, 0x14, 0x0c, 0x5c, 0xd0, 0x3a, 0xd2, 0x66, 0x94, 0x50, 0x03, 0xa8, 0xcd, 0x37,
+    0x34, 0x85, 0xa8, 0x01, 0xd9, 0xa4, 0xdd, 0x4d, 0xcd, 0x25, 0x00, 0x3b, 0x75, 0x26, 0xea,
+    0x4a, 0x29, 0x00, 0xb9, 0xa3, 0x34, 0x94, 0x94, 0x5c, 0x05, 0xcd, 0x19, 0xa4, 0xa3, 0x34,
+    0xae, 0x30, 0xcd, 0x14, 0x99, 0xa2, 0x95, 0xc0, 0x5a, 0x33, 0x49, 0x45, 0x00, 0x04, 0xd2,
+    0xb7, 0x6a, 0x69, 0xa5, 0x6e, 0xd4, 0x00, 0x94, 0x52, 0x66, 0x96, 0x80, 0x0a, 0x29, 0x68,
+    0xa0, 0x03, 0x14, 0x94, 0x51, 0x40, 0x05, 0x25, 0x2d, 0x14, 0x80, 0x4a, 0x28, 0x34, 0x94,
+    0x00, 0xb4, 0x94, 0x51, 0x40, 0xc4, 0x34, 0x51, 0x4a, 0xa3, 0x26, 0x80, 0x00, 0x09, 0xa7,
+    0x60, 0x0a, 0x09, 0x03, 0x8a, 0x61, 0x39, 0xa3, 0x61, 0x0a, 0x4d, 0x26, 0x69, 0x28, 0xa4,
+    0x30, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a,
+    0x28, 0x02, 0xc4, 0x71, 0x86, 0x42, 0x4d, 0x44, 0x46, 0x09, 0x15, 0x6d, 0x17, 0x6c, 0x55,
+    0x51, 0x87, 0xcc, 0x6b, 0x49, 0x2d, 0x04, 0x59, 0xb6, 0xe5, 0x48, 0xa8, 0x25, 0x5d, 0xb2,
+    0x1a, 0x92, 0xd8, 0xe2, 0x4c, 0x55, 0x99, 0x60, 0x0c, 0x73, 0x4d, 0x2b, 0xc4, 0x0a, 0x00,
+    0x13, 0x49, 0x56, 0x9d, 0x40, 0xe2, 0xaa, 0x9e, 0xb5, 0x2d, 0x58, 0x05, 0xa2, 0x8a, 0x28,
+    0x00, 0xa2, 0x8a, 0x29, 0x81, 0x22, 0xb6, 0x0e, 0x6a, 0xca, 0x4b, 0x8c, 0x10, 0x79, 0x1d,
+    0x08, 0x35, 0x4c, 0x1c, 0x53, 0xd5, 0x87, 0xbd, 0x34, 0xec, 0x05, 0xc7, 0xb9, 0x92, 0x4f,
+    0xbd, 0x23, 0x37, 0xd4, 0xe6, 0xa0, 0x66, 0xcd, 0x33, 0x70, 0xa4, 0x2d, 0x9a, 0x6e, 0x4d,
+    0x85, 0x87, 0x03, 0x9a, 0x42, 0x70, 0x09, 0xa6, 0x03, 0x8a, 0x56, 0x6f, 0x90, 0xd4, 0x81,
+    0xf5, 0x8f, 0xc1, 0xfb, 0x15, 0xb1, 0xf8, 0x63, 0xa4, 0x80, 0x39, 0x99, 0x5e, 0x66, 0xff,
+    0x00, 0x81, 0x31, 0x3f, 0xcb, 0x15, 0x7f, 0xc4, 0x52, 0x66, 0xec, 0x26, 0x78, 0x02, 0xac,
+    0x78, 0x12, 0x1f, 0xb3, 0xf8, 0x07, 0x41, 0x8f, 0x18, 0xc5, 0x8c, 0x47, 0xf3, 0x50, 0x7f,
+    0xad, 0x67, 0xeb, 0x8d, 0xbb, 0x50, 0x6a, 0x85, 0xb9, 0xd1, 0xb4, 0x4c, 0x93, 0xc9, 0xa7,
+    0xa5, 0x46, 0x7e, 0xf5, 0x48, 0x95, 0x64, 0x0f, 0x24, 0x9e, 0x2a, 0xa6, 0xb5, 0x23, 0x27,
+    0x87, 0xef, 0xdd, 0x4e, 0x19, 0x60, 0x7c, 0x1f, 0xc2, 0xae, 0x1e, 0xb5, 0x43, 0x5b, 0x56,
+    0x7d, 0x07, 0x50, 0x45, 0x19, 0x66, 0xb7, 0x70, 0x3f, 0x23, 0x42, 0x07, 0xb1, 0xe0, 0x3a,
+    0x01, 0x0b, 0x6f, 0x2b, 0x9e, 0xa5, 0xaa, 0xbe, 0xa1, 0x26, 0xf9, 0x4f, 0xd6, 0x8d, 0x32,
+    0x61, 0x1d, 0x8c, 0x83, 0xbe, 0xe3, 0x55, 0x65, 0x7d, 0xf2, 0x13, 0x5d, 0x0e, 0x56, 0xa6,
+    0x91, 0xce, 0x97, 0xbc, 0xd8, 0xc1, 0x4f, 0x8c, 0xe1, 0xc5, 0x32, 0x94, 0x1a, 0xc9, 0x14,
+    0x6b, 0xc6, 0x43, 0x2a, 0xd5, 0xe9, 0x21, 0x02, 0xdf, 0x70, 0xf4, 0xac, 0x6b, 0x59, 0x09,
+    0x60, 0x2b, 0x72, 0xe5, 0xc2, 0xd9, 0xe3, 0xda, 0xbb, 0x20, 0xee, 0xae, 0x65, 0x3b, 0xa6,
+    0x8e, 0x7a, 0xe0, 0xfe, 0xf0, 0xd4, 0x60, 0xf6, 0xa5, 0x90, 0xe5, 0xcd, 0x37, 0xa5, 0x72,
+    0xbd, 0xcd, 0x47, 0xd2, 0xe4, 0x9a, 0x87, 0xce, 0x8d, 0x7a, 0xb8, 0xa7, 0xc4, 0x5e, 0x76,
+    0xdb, 0x6f, 0x0c, 0xb3, 0x37, 0xa4, 0x68, 0x4d, 0x2b, 0xa0, 0x24, 0x06, 0x9d, 0x53, 0xc7,
+    0xa4, 0xeb, 0x32, 0x9f, 0xdd, 0x68, 0x9a, 0x8b, 0xff, 0x00, 0xbb, 0x6c, 0xe7, 0xfa, 0x55,
+    0xe8, 0xfc, 0x25, 0xe2, 0xc9, 0x13, 0x7a, 0xf8, 0x5f, 0x56, 0xdb, 0xea, 0x6d, 0x1c, 0x7f,
+    0x4a, 0x39, 0x90, 0x59, 0x99, 0x75, 0x62, 0xd1, 0xb1, 0x2d, 0x4d, 0x2f, 0x87, 0xfc, 0x43,
+    0x6e, 0x33, 0x36, 0x81, 0xa9, 0x20, 0xff, 0x00, 0x6a, 0xdd, 0x87, 0xf4, 0xaa, 0xbb, 0x6e,
+    0xad, 0x5f, 0x33, 0x58, 0xdd, 0x47, 0x8e, 0xbb, 0xa3, 0x22, 0xae, 0x13, 0x49, 0xdc, 0x4d,
+    0x1a, 0x17, 0x0e, 0x3b, 0x9a, 0xce, 0x27, 0x2c, 0x4d, 0x2c, 0xd7, 0xf1, 0x3f, 0x5d, 0xea,
+    0x7d, 0xd4, 0x8a, 0xae, 0x2e, 0x22, 0x27, 0x89, 0x05, 0x5c, 0xe6, 0x9b, 0xd1, 0x8a, 0x2a,
+    0xc8, 0x9e, 0x94, 0x12, 0x0f, 0x14, 0xc5, 0x65, 0x6e, 0x8c, 0x0f, 0xd0, 0xd3, 0x80, 0xa4,
+    0x86, 0x3f, 0x39, 0xa7, 0x2b, 0x11, 0x9c, 0x12, 0x33, 0xe9, 0x4c, 0x03, 0x14, 0xee, 0x29,
+    0xa6, 0x26, 0x87, 0x66, 0x90, 0x9a, 0x32, 0x28, 0xa6, 0x02, 0x83, 0x4b, 0x48, 0x29, 0x68,
+    0x03, 0xab, 0xf8, 0x53, 0xae, 0x7f, 0xc2, 0x3f, 0xf1, 0x2a, 0xd1, 0x5d, 0xb6, 0xdb, 0x6a,
+    0x4a, 0x6d, 0x64, 0xff, 0x00, 0x78, 0xfd, 0xdf, 0xfc, 0x78, 0x01, 0xf8, 0xd7, 0xd3, 0x1a,
+    0x94, 0x41, 0xa1, 0x0f, 0x8f, 0xba, 0x6b, 0xe3, 0x5b, 0x89, 0x64, 0xb5, 0x78, 0x2e, 0xe2,
+    0x3b, 0x65, 0x82, 0x55, 0x91, 0x0f, 0xa1, 0x07, 0x22, 0xbe, 0xc9, 0xb5, 0xb9, 0x5d, 0x4f,
+    0x44, 0xb7, 0xbb, 0x40, 0x36, 0xdc, 0x40, 0xb2, 0xaf, 0xfc, 0x09, 0x41, 0x1f, 0xce, 0xb9,
+    0x6a, 0xab, 0x48, 0xde, 0x9b, 0xe8, 0x64, 0xe2, 0x8c, 0x77, 0xa7, 0x91, 0xcd, 0x18, 0xa9,
+    0x35, 0x10, 0x0a, 0xbf, 0xa7, 0x3e, 0x19, 0x93, 0xb7, 0x51, 0x54, 0x40, 0xa9, 0xed, 0x5b,
+    0x65, 0xc2, 0x9e, 0xc7, 0x8a, 0x1e, 0xc0, 0x78, 0x97, 0xc7, 0xcd, 0x20, 0x58, 0xf8, 0xaf,
+    0x4c, 0xd6, 0xe3, 0x50, 0x12, 0xf2, 0x2f, 0x2a, 0x42, 0x3a, 0x97, 0x4e, 0xe7, 0xfe, 0x02,
+    0xc3, 0xf2, 0xaf, 0x39, 0xaf, 0x78, 0xf8, 0xf9, 0xa7, 0xad, 0xd7, 0xc3, 0xf8, 0xef, 0x02,
+    0xe6, 0x4b, 0x4b, 0xb4, 0x60, 0xde, 0x8a, 0xd9, 0x53, 0xfa, 0x91, 0x5e, 0x08, 0x8d, 0xbe,
+    0x18, 0xdb, 0xd5, 0x45, 0x74, 0x61, 0xde, 0xe8, 0xe6, 0xa8, 0xac, 0xc5, 0xa2, 0x80, 0x33,
+    0x45, 0x74, 0x10, 0x48, 0x30, 0x56, 0x9a, 0xe3, 0x8a, 0x58, 0xc6, 0x4e, 0x29, 0x5d, 0x71,
+    0x55, 0xd0, 0x5d, 0x48, 0xc7, 0x5a, 0x75, 0x22, 0xaf, 0x7a, 0x53, 0x53, 0x61, 0x89, 0x45,
+    0x14, 0xa2, 0x98, 0x80, 0x75, 0xa7, 0x81, 0x8a, 0x15, 0x78, 0xf7, 0xa7, 0x85, 0xa6, 0x4b,
+    0x63, 0x29, 0xc1, 0x69, 0x71, 0xce, 0x69, 0x47, 0x4a, 0x04, 0xd8, 0x80, 0x73, 0x56, 0x11,
+    0x42, 0x8a, 0x89, 0x31, 0xbb, 0x9a, 0x9b, 0x23, 0xd6, 0xa9, 0x19, 0xc8, 0x5a, 0x61, 0x14,
+    0xa6, 0x45, 0x1d, 0xea, 0x36, 0x98, 0x7a, 0xd1, 0x72, 0x52, 0x62, 0xd3, 0x4d, 0x37, 0xce,
+    0x5a, 0x4f, 0x35, 0x69, 0x5d, 0x15, 0x66, 0x3a, 0x9a, 0x69, 0x0b, 0xd1, 0x9c, 0xd2, 0x1d,
+    0x83, 0xb5, 0x36, 0x97, 0x34, 0x99, 0xa4, 0x02, 0x11, 0x51, 0xb2, 0xfa, 0x54, 0x84, 0xe2,
+    0x98, 0x69, 0x31, 0xa2, 0x07, 0x4a, 0x88, 0xd5, 0x96, 0x3d, 0xaa, 0x17, 0x5a, 0x86, 0x8d,
+    0x53, 0x23, 0xcd, 0x14, 0xa4, 0x51, 0x8a, 0x8d, 0x46, 0x28, 0xa7, 0xaa, 0xe6, 0x9a, 0x05,
+    0x4a, 0xa3, 0x02, 0xa9, 0x22, 0x58, 0x05, 0xa7, 0x6d, 0xa7, 0x01, 0x9a, 0x76, 0xda, 0xbb,
+    0x10, 0xd9, 0x0b, 0x2d, 0x37, 0x6d, 0x58, 0xd9, 0x4d, 0xd9, 0x4a, 0xc0, 0xa4, 0x44, 0x05,
+    0x3b, 0x14, 0xed, 0xb8, 0xa4, 0xa2, 0xc1, 0x7b, 0x89, 0x48, 0x7a, 0x52, 0xf6, 0xa6, 0x93,
+    0x4d, 0x82, 0x1a, 0x4d, 0x33, 0x34, 0xa4, 0xd4, 0x65, 0xaa, 0x1b, 0x2d, 0x20, 0x26, 0x9a,
+    0x4d, 0x21, 0x34, 0xc6, 0x6a, 0xca, 0x52, 0x2a, 0xc2, 0x96, 0xa8, 0xc9, 0xa4, 0x26, 0x9a,
+    0x4d, 0x66, 0xd8, 0xc5, 0x26, 0x93, 0x34, 0x94, 0x94, 0x80, 0x5c, 0xd1, 0x9a, 0x4c, 0xd2,
+    0x13, 0x48, 0x62, 0xe6, 0x92, 0x93, 0x34, 0x50, 0x02, 0xd1, 0x49, 0x45, 0x00, 0x2d, 0x19,
+    0xa4, 0xa2, 0x80, 0x02, 0x68, 0x03, 0x34, 0xa0, 0x66, 0x9d, 0x40, 0x09, 0xb6, 0x8c, 0x0a,
+    0x5a, 0x28, 0xb0, 0x09, 0x8a, 0x7a, 0x43, 0x24, 0x81, 0x8a, 0x23, 0x30, 0x51, 0x93, 0x81,
+    0xd2, 0x9a, 0x2a, 0xd5, 0xb5, 0xfc, 0xf6, 0x91, 0xc8, 0x91, 0x10, 0x04, 0x83, 0x07, 0x22,
+    0xaa, 0x36, 0xbe, 0xa0, 0x54, 0xc5, 0x26, 0x29, 0x49, 0xa4, 0xa9, 0x01, 0x31, 0x49, 0x8a,
+    0x5a, 0x4e, 0x69, 0x0c, 0x4a, 0x28, 0xa4, 0xa4, 0x02, 0xd2, 0x52, 0xd1, 0x8a, 0x00, 0x69,
+    0xa7, 0x37, 0x41, 0x48, 0x69, 0x5b, 0xee, 0x8a, 0x00, 0x6d, 0x38, 0x74, 0xa6, 0x53, 0xd7,
+    0xa5, 0x24, 0x01, 0x45, 0x2d, 0x25, 0x30, 0x0a, 0x4a, 0x5a, 0x4a, 0x00, 0x33, 0x49, 0x45,
+    0x14, 0x86, 0x14, 0x94, 0x66, 0x8c, 0xd0, 0x01, 0x49, 0x4f, 0x54, 0x27, 0x93, 0xd2, 0x83,
+    0x81, 0xf4, 0xa2, 0xc2, 0x1a, 0x06, 0x69, 0x49, 0xc7, 0x4a, 0x42, 0xd4, 0xda, 0x00, 0x5c,
+    0xd2, 0x51, 0x45, 0x21, 0x85, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51,
+    0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x1a, 0x25, 0x4f, 0xdd, 0xa8, 0x1d,
+    0x39, 0xc5, 0x5c, 0x7e, 0x5f, 0x8a, 0x82, 0x5e, 0x09, 0x15, 0xd1, 0x24, 0x49, 0x0c, 0x63,
+    0x6b, 0x66, 0xb4, 0x97, 0x0e, 0x82, 0xb3, 0x90, 0x6e, 0x72, 0x2a, 0xfc, 0x07, 0x8c, 0x51,
+    0x4c, 0x19, 0x5a, 0x65, 0x2a, 0x6a, 0x93, 0x75, 0xad, 0x4b, 0xb5, 0x1b, 0x6b, 0x31, 0xc7,
+    0xcd, 0x53, 0x51, 0x59, 0x8d, 0x0d, 0xa5, 0xa4, 0xa5, 0xac, 0xd3, 0x18, 0x51, 0x45, 0x15,
+    0x42, 0x0a, 0x3a, 0x51, 0x40, 0x19, 0xa0, 0x07, 0x8e, 0x94, 0x52, 0xa0, 0x03, 0x8a, 0x71,
+    0x00, 0xd0, 0x03, 0x29, 0x1c, 0x10, 0x95, 0x20, 0x00, 0x52, 0x4a, 0x3e, 0x43, 0x43, 0xd8,
+    0x0f, 0xb4, 0xbc, 0x2e, 0xa2, 0x3f, 0x08, 0xe8, 0xc8, 0x0e, 0x42, 0xd8, 0x40, 0x3f, 0xf2,
+    0x18, 0xac, 0x2d, 0x68, 0x7f, 0xa7, 0xbf, 0xd2, 0xb6, 0x3c, 0x1f, 0x3a, 0xdd, 0x78, 0x2f,
+    0x45, 0x95, 0x0e, 0x41, 0xb1, 0x84, 0x7e, 0x48, 0x01, 0xfe, 0x55, 0x93, 0xae, 0x0c, 0x5f,
+    0xb1, 0xf6, 0xa9, 0x5b, 0x9d, 0x0f, 0xe1, 0x32, 0x4f, 0x5a, 0x91, 0x3a, 0xd4, 0x74, 0xf4,
+    0xeb, 0x54, 0x41, 0x21, 0xeb, 0x4c, 0x96, 0x3f, 0x32, 0x17, 0x8c, 0xff, 0x00, 0x12, 0x91,
+    0xf9, 0xd3, 0xcf, 0x5a, 0x5a, 0x00, 0xf9, 0x92, 0x78, 0x9b, 0x4f, 0xbe, 0xbe, 0xb1, 0x90,
+    0x61, 0xe2, 0x99, 0x97, 0x1f, 0x43, 0x8a, 0xab, 0x9e, 0x6b, 0xb6, 0xf8, 0xad, 0xa5, 0x7f,
+    0x67, 0xf8, 0xb1, 0x2f, 0x91, 0x71, 0x15, 0xec, 0x61, 0x89, 0x1d, 0x37, 0x0e, 0x0f, 0xf4,
+    0xae, 0x2f, 0x8a, 0xab, 0xdf, 0x43, 0x26, 0xac, 0x1d, 0xa8, 0xa0, 0x90, 0x06, 0x4f, 0x02,
+    0xae, 0x69, 0x1a, 0x46, 0xab, 0xe2, 0x0b, 0xd5, 0xb3, 0xd1, 0xf4, 0xf9, 0xae, 0xe6, 0x63,
+    0x8f, 0x91, 0x78, 0x1e, 0xe4, 0xf4, 0x03, 0xdc, 0xd1, 0x7b, 0x00, 0xb6, 0xcc, 0x91, 0x90,
+    0xee, 0xc1, 0x40, 0xea, 0x4d, 0x59, 0x9b, 0x50, 0x6b, 0xf7, 0x5b, 0x5d, 0x3e, 0xda, 0x5b,
+    0x89, 0x58, 0xe0, 0x04, 0x52, 0x49, 0x3e, 0xc0, 0x57, 0xab, 0xf8, 0x5f, 0xf6, 0x7d, 0x79,
+    0x36, 0x5c, 0xf8, 0xab, 0x51, 0xc7, 0x7f, 0xb2, 0x5a, 0x1e, 0x9e, 0xcc, 0xe7, 0xf9, 0x01,
+    0xf8, 0xd7, 0xb0, 0xe8, 0x9e, 0x18, 0xd0, 0xbc, 0x35, 0x00, 0x8b, 0x49, 0xd3, 0x6d, 0xed,
+    0x46, 0x30, 0x5d, 0x57, 0x2e, 0xdf, 0x56, 0x3c, 0x9f, 0xce, 0x9f, 0xb7, 0x69, 0x59, 0x0d,
+    0x52, 0xbb, 0xbb, 0x3e, 0x74, 0xd0, 0x7e, 0x0b, 0x78, 0xc3, 0x5b, 0xdb, 0x2d, 0xe4, 0x51,
+    0xe9, 0x70, 0x37, 0x39, 0xb8, 0x38, 0x6c, 0x7f, 0xba, 0x32, 0x73, 0xf5, 0xc5, 0x7a, 0x3e,
+    0x93, 0xfb, 0x3e, 0x78, 0x72, 0xd4, 0x23, 0x6a, 0x97, 0xd7, 0xb7, 0xf2, 0x03, 0x92, 0xaa,
+    0xc2, 0x24, 0x3e, 0xd8, 0x19, 0x3f, 0xa8, 0xaf, 0x59, 0x69, 0x82, 0xff, 0x00, 0xf5, 0xea,
+    0x26, 0xbb, 0x41, 0xd5, 0xd4, 0x56, 0x2d, 0xb6, 0x6a, 0xa9, 0x98, 0x7a, 0x6f, 0xc3, 0xef,
+    0x08, 0xe9, 0x28, 0x16, 0xcf, 0xc3, 0xba, 0x78, 0x23, 0xa3, 0xc9, 0x08, 0x95, 0xbf, 0xef,
+    0xa7, 0xc9, 0xfd, 0x6b, 0xa1, 0x8a, 0x28, 0xe0, 0x8c, 0x47, 0x14, 0x69, 0x1a, 0x0e, 0x8a,
+    0xab, 0x80, 0x3f, 0x0a, 0xaa, 0xd7, 0xf1, 0x0e, 0xb2, 0x7e, 0x55, 0x19, 0xd4, 0x22, 0xf5,
+    0x27, 0xf0, 0xa3, 0x52, 0xd4, 0x6c, 0x68, 0xe4, 0x51, 0xb8, 0x7a, 0xd6, 0x67, 0xf6, 0x82,
+    0x76, 0x53, 0x49, 0xfd, 0xa2, 0x33, 0xc2, 0x7e, 0xb4, 0xac, 0x16, 0x46, 0xa6, 0xe1, 0xeb,
+    0x48, 0x76, 0x1e, 0xa0, 0x1a, 0xcc, 0xfb, 0x7f, 0xfb, 0x1f, 0xad, 0x1f, 0x6f, 0xff, 0x00,
+    0x63, 0xf5, 0xa2, 0xc1, 0x64, 0x49, 0x73, 0xa1, 0xe8, 0xd7, 0xa7, 0xfd, 0x2b, 0x4b, 0xb1,
+    0x9c, 0xff, 0x00, 0xd3, 0x4b, 0x74, 0x6f, 0xe6, 0x2b, 0x1a, 0xef, 0xe1, 0xbf, 0x83, 0x2f,
+    0xb3, 0xe7, 0x78, 0x76, 0xc4, 0x67, 0xfe, 0x79, 0xa7, 0x97, 0xff, 0x00, 0xa0, 0xe2, 0xb5,
+    0xc5, 0xf0, 0xee, 0x9f, 0xad, 0x3c, 0x5e, 0xa7, 0xa1, 0x14, 0xf5, 0x0e, 0x54, 0x79, 0xf6,
+    0xa7, 0xf0, 0x1b, 0xc2, 0x17, 0xa5, 0x9a, 0xcc, 0xde, 0x58, 0x3f, 0x61, 0x14, 0xbb, 0x94,
+    0x7e, 0x0d, 0x93, 0xfa, 0xd7, 0x1d, 0xa9, 0xfe, 0xcf, 0xba, 0xc5, 0xbe, 0x5b, 0x48, 0xd7,
+    0x6d, 0xee, 0x00, 0xe4, 0x25, 0xca, 0x18, 0xcf, 0xe6, 0x37, 0x7f, 0x4a, 0xf7, 0x55, 0xbb,
+    0x43, 0xdc, 0xd4, 0xcb, 0x30, 0x3d, 0x08, 0x34, 0x26, 0xd1, 0x2e, 0x9a, 0x67, 0xca, 0x3a,
+    0xaf, 0xc3, 0xaf, 0x1b, 0x68, 0x80, 0xb5, 0xd6, 0x85, 0x35, 0xc4, 0x43, 0x3f, 0xbc, 0xb4,
+    0xc4, 0xa3, 0x1e, 0xb8, 0x5c, 0x91, 0xf8, 0x8a, 0xe6, 0x45, 0xc2, 0x07, 0x29, 0x26, 0x63,
+    0x71, 0xc1, 0x57, 0x18, 0x22, 0xbe, 0xd7, 0x12, 0x0e, 0xf5, 0x93, 0xad, 0x78, 0x5b, 0x40,
+    0xf1, 0x24, 0x46, 0x3d, 0x5f, 0x4a, 0xb5, 0xbb, 0xc8, 0xc0, 0x77, 0x4c, 0x38, 0xfa, 0x38,
+    0xf9, 0x87, 0xe0, 0x6a, 0xd5, 0x56, 0xb7, 0x21, 0xd2, 0x3e, 0x43, 0xeb, 0x46, 0x6b, 0xd9,
+    0xfc, 0x49, 0xf0, 0x09, 0x06, 0xfb, 0x8f, 0x0b, 0x6a, 0x4d, 0x09, 0xeb, 0xf6, 0x3b, 0xc3,
+    0xb9, 0x0f, 0xb2, 0xb8, 0xe4, 0x7e, 0x20, 0xfd, 0x6b, 0xc8, 0xb5, 0x7d, 0x23, 0x55, 0xf0,
+    0xed, 0xf7, 0xd8, 0xb5, 0xbd, 0x3e, 0x6b, 0x29, 0xff, 0x00, 0x84, 0xb8, 0xca, 0x38, 0xf5,
+    0x56, 0x1c, 0x11, 0xf4, 0x35, 0xb4, 0x6a, 0x26, 0x64, 0xe0, 0xd1, 0x5e, 0x94, 0x1c, 0xd3,
+    0x01, 0xa3, 0xe9, 0x5a, 0x92, 0x47, 0x7a, 0x33, 0x69, 0x27, 0xd2, 0xbe, 0xad, 0xf8, 0x6d,
+    0x72, 0x6e, 0xfe, 0x1a, 0xe8, 0x52, 0xb1, 0xc9, 0x16, 0x8a, 0x9c, 0xff, 0x00, 0xb3, 0x95,
+    0xfe, 0x95, 0xf2, 0x95, 0xd1, 0xcd, 0xac, 0x99, 0xf4, 0xaf, 0xa8, 0xbe, 0x12, 0xff, 0x00,
+    0xc9, 0x2b, 0xd0, 0xf3, 0xff, 0x00, 0x3c, 0x5f, 0xff, 0x00, 0x43, 0x6a, 0xe7, 0xaf, 0xb9,
+    0xad, 0x2d, 0xcd, 0x77, 0x1f, 0x39, 0xc5, 0x25, 0x49, 0x27, 0xfa, 0xc6, 0xfa, 0xd3, 0x71,
+    0x59, 0x9b, 0x89, 0x8a, 0x51, 0xc1, 0x06, 0x8c, 0x50, 0x05, 0x00, 0x64, 0xfc, 0x52, 0xb7,
+    0x17, 0x9f, 0x0b, 0xb5, 0xc5, 0xc0, 0x3b, 0x6d, 0xfc, 0xc1, 0xff, 0x00, 0x01, 0x60, 0xdf,
+    0xd2, 0xbe, 0x5e, 0xb4, 0x6d, 0xd6, 0x51, 0x7d, 0x2b, 0xea, 0xaf, 0x1b, 0x27, 0x9d, 0xf0,
+    0xdf, 0x5f, 0x42, 0x7f, 0xe6, 0x1d, 0x31, 0xfc, 0x90, 0xff, 0x00, 0x85, 0x7c, 0xa7, 0x62,
+    0x73, 0x65, 0x1f, 0xe3, 0x5a, 0xe1, 0xdf, 0xbc, 0xcc, 0x2b, 0x2d, 0x4b, 0x02, 0x8a, 0x5e,
+    0xc6, 0x9b, 0xde, 0xba, 0xcc, 0x89, 0x62, 0xfb, 0xc2, 0xa5, 0x98, 0x71, 0x9a, 0x85, 0x3e,
+    0xf0, 0xad, 0xb5, 0x16, 0xbf, 0xd9, 0xff, 0x00, 0x36, 0xdc, 0xe3, 0x9f, 0x5c, 0xd5, 0xc7,
+    0x63, 0x29, 0xca, 0xcd, 0x33, 0x19, 0x7a, 0x66, 0x98, 0x7a, 0xd4, 0x83, 0xbd, 0x30, 0x8a,
+    0x19, 0x68, 0x4e, 0xf4, 0xf5, 0x5c, 0x9a, 0x45, 0x15, 0x22, 0xaf, 0x34, 0x03, 0x62, 0x85,
+    0xa7, 0x62, 0x9c, 0x05, 0x2e, 0xdf, 0x7a, 0x0c, 0x9b, 0x23, 0x22, 0x92, 0x9e, 0x54, 0xf1,
+    0x40, 0x8c, 0x9a, 0x02, 0xe4, 0x4c, 0x71, 0x4c, 0x2e, 0xd5, 0x67, 0xc8, 0x27, 0xad, 0x38,
+    0x5a, 0x8e, 0xf4, 0x58, 0x39, 0xe2, 0x8a, 0x24, 0xb1, 0xa6, 0x9c, 0xfb, 0xd6, 0x8f, 0xd9,
+    0x97, 0xd2, 0x83, 0x6c, 0xbe, 0x94, 0xac, 0x3f, 0x6b, 0x13, 0x3a, 0x96, 0xae, 0x9b, 0x71,
+    0x8e, 0x95, 0x1b, 0x40, 0x29, 0x58, 0x6a, 0xa2, 0x65, 0x6a, 0x37, 0x91, 0xde, 0xa5, 0x30,
+    0xfa, 0x1a, 0x63, 0x44, 0x69, 0x58, 0x77, 0x4c, 0x68, 0x92, 0x83, 0x20, 0xa8, 0xd8, 0x11,
+    0x4c, 0x24, 0xd2, 0x6e, 0xc5, 0x72, 0xa2, 0x6f, 0x30, 0x52, 0x17, 0x1d, 0xaa, 0x0c, 0x9a,
+    0x4c, 0xd2, 0xe6, 0x0e, 0x54, 0x4d, 0x9a, 0x42, 0x33, 0x4c, 0x0c, 0x6a, 0x64, 0x20, 0xd0,
+    0x81, 0xe8, 0x20, 0x40, 0x7b, 0x50, 0xd1, 0x0e, 0xd5, 0x28, 0x14, 0xe0, 0xb4, 0xec, 0x47,
+    0x31, 0x5c, 0x47, 0x83, 0x52, 0x05, 0xa7, 0xed, 0xa5, 0x0b, 0x4e, 0xc2, 0x72, 0x1a, 0x17,
+    0x14, 0xf0, 0x29, 0x71, 0x4b, 0x8a, 0x64, 0x36, 0x26, 0x29, 0xa4, 0x53, 0xe9, 0xa6, 0x90,
+    0x86, 0xb7, 0x4a, 0x8a, 0xa4, 0x63, 0x51, 0x93, 0x41, 0x48, 0x6b, 0x1a, 0x8d, 0x8e, 0x29,
+    0x59, 0xb1, 0x50, 0xb3, 0x54, 0x36, 0x6b, 0x14, 0x0c, 0xd5, 0x19, 0x34, 0x33, 0x54, 0x6c,
+    0xd5, 0x8c, 0xa4, 0x5a, 0x40, 0x5a, 0x98, 0x4d, 0x04, 0xd3, 0x73, 0x59, 0xb6, 0x50, 0xa4,
+    0xd3, 0x73, 0x45, 0x26, 0x6a, 0x40, 0x5a, 0x4a, 0x4a, 0x28, 0x01, 0x69, 0x28, 0xa0, 0x75,
+    0xa4, 0x05, 0xbb, 0x4b, 0x19, 0x2e, 0x9b, 0x08, 0xa4, 0xd4, 0xf7, 0x7a, 0x4c, 0xf6, 0xab,
+    0x97, 0x42, 0x3f, 0x0a, 0xe8, 0xbc, 0x1d, 0x3d, 0xac, 0x77, 0x0b, 0xe7, 0xe3, 0x1e, 0xf5,
+    0xb9, 0xe3, 0x0b, 0xab, 0x09, 0x2d, 0xf1, 0x06, 0xdc, 0xe3, 0xb5, 0x06, 0x8a, 0x2a, 0xd7,
+    0x3c, 0xbc, 0xf0, 0x71, 0x49, 0x4f, 0x94, 0x82, 0xe7, 0x1e, 0xb4, 0xca, 0x08, 0x0a, 0x70,
+    0x5a, 0x14, 0x77, 0xa7, 0x53, 0x48, 0x41, 0x8a, 0x28, 0xa3, 0x34, 0xc0, 0x28, 0xa4, 0x2c,
+    0x29, 0xa5, 0xe8, 0x01, 0xd4, 0x53, 0x37, 0x51, 0xba, 0x95, 0xc0, 0x7d, 0x25, 0x33, 0x34,
+    0x66, 0x95, 0xc6, 0x3a, 0x8a, 0x6d, 0x02, 0x80, 0x16, 0x92, 0x8c, 0x52, 0xe2, 0x80, 0x12,
+    0x96, 0x97, 0x14, 0x50, 0x03, 0x1b, 0xad, 0x07, 0xee, 0x0a, 0x56, 0x19, 0x6a, 0x0f, 0xdd,
+    0xa4, 0x03, 0x29, 0xeb, 0xd2, 0x99, 0x4e, 0x5e, 0x94, 0x80, 0x75, 0x25, 0x14, 0x94, 0xc0,
+    0x28, 0xa2, 0x92, 0x90, 0xc2, 0x92, 0x96, 0x90, 0xf1, 0x40, 0x82, 0xa4, 0x48, 0xfb, 0x9a,
+    0x23, 0x4c, 0xf2, 0x69, 0xec, 0xd8, 0x1c, 0x53, 0x4b, 0xab, 0x01, 0x92, 0x3e, 0x38, 0xa8,
+    0x89, 0xcd, 0x04, 0xe4, 0xd2, 0x52, 0x6e, 0xe3, 0x0a, 0x28, 0xa2, 0x90, 0x05, 0x14, 0x51,
+    0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14,
+    0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x1b, 0x30, 0x47, 0xbd, 0x33, 0x55, 0x6e, 0x46, 0xd7,
+    0x35, 0x77, 0x4e, 0x70, 0xeb, 0x8a, 0x8b, 0x51, 0x8f, 0x6b, 0x66, 0xba, 0xe4, 0xaf, 0x0b,
+    0x91, 0xd4, 0xab, 0x00, 0xce, 0x4d, 0x5a, 0xb5, 0x71, 0xe6, 0xe0, 0xd5, 0x78, 0x81, 0x11,
+    0x93, 0x50, 0xc5, 0x21, 0x59, 0xf3, 0x9e, 0xf5, 0x9a, 0x7c, 0xb6, 0x19, 0xa5, 0x7a, 0x98,
+    0x4c, 0x8a, 0xcc, 0x28, 0x1a, 0xb5, 0xe4, 0x61, 0x2d, 0xbf, 0xbd, 0x50, 0x09, 0x80, 0x4d,
+    0x5d, 0x45, 0x77, 0x74, 0x08, 0xa2, 0x46, 0x0e, 0x28, 0xa7, 0x37, 0xde, 0x34, 0x95, 0xcf,
+    0x61, 0x8e, 0x03, 0x8a, 0x5c, 0x0a, 0x68, 0x3d, 0xa9, 0xd5, 0x40, 0x26, 0x05, 0x2d, 0x14,
+    0x50, 0x01, 0x52, 0x01, 0x4d, 0x5e, 0xb5, 0x26, 0xd2, 0x1b, 0x04, 0x60, 0xd0, 0x00, 0x05,
+    0x23, 0x8c, 0x82, 0x3b, 0xd5, 0xfd, 0x3a, 0xde, 0x19, 0xae, 0xd5, 0x2e, 0x1b, 0x6a, 0x1f,
+    0x7c, 0x66, 0xa3, 0xd4, 0x21, 0x86, 0x0b, 0xd7, 0x8e, 0xdd, 0xb7, 0x46, 0x3b, 0xd5, 0xb8,
+    0x3e, 0x5b, 0x8b, 0x9b, 0x5b, 0x1f, 0x51, 0x7c, 0x22, 0xbe, 0x4b, 0xef, 0x86, 0x7a, 0x46,
+    0xd6, 0xcb, 0x40, 0x8d, 0x0b, 0x7d, 0x55, 0x8f, 0xf4, 0xc5, 0x5f, 0xf1, 0x14, 0x7b, 0x2e,
+    0x55, 0xbd, 0x45, 0x79, 0xef, 0xec, 0xf9, 0xad, 0x89, 0x34, 0xcd, 0x4f, 0x43, 0x77, 0xf9,
+    0xe0, 0x90, 0x5c, 0x46, 0xbf, 0xec, 0xb7, 0x0d, 0xfa, 0x81, 0xf9, 0xd7, 0xa8, 0x78, 0x8a,
+    0x0d, 0xf6, 0xa9, 0x28, 0x1f, 0x70, 0xe0, 0xd6, 0x5b, 0x48, 0xe9, 0x5a, 0xc4, 0xe4, 0xcf,
+    0x0d, 0x4f, 0x1d, 0x45, 0x35, 0x87, 0x34, 0xa2, 0xa8, 0x82, 0x66, 0x1d, 0x68, 0x5a, 0x14,
+    0xe5, 0x47, 0xe5, 0x48, 0x38, 0x34, 0x0c, 0xe6, 0x7e, 0x21, 0x78, 0x70, 0xf8, 0x87, 0xc2,
+    0xb3, 0x08, 0x53, 0x75, 0xdd, 0xa7, 0xef, 0xa1, 0xc0, 0xe4, 0xe3, 0xa8, 0xfc, 0x45, 0x7c,
+    0xfc, 0xb2, 0x10, 0xa1, 0x4a, 0x92, 0xf9, 0xc6, 0xdc, 0x73, 0x9a, 0xfa, 0xb1, 0x58, 0xaf,
+    0x23, 0x04, 0xe3, 0xa1, 0xae, 0x2b, 0xc2, 0xbf, 0x0e, 0xec, 0xf4, 0xcd, 0x66, 0x7d, 0x6f,
+    0x5a, 0x8e, 0x0b, 0xcb, 0xd6, 0x99, 0xa4, 0x86, 0x1c, 0x7e, 0xe6, 0x3c, 0x9c, 0x83, 0x8e,
+    0xe7, 0xf4, 0xa0, 0x97, 0x1b, 0xb3, 0x1f, 0xc0, 0x7f, 0x04, 0x6e, 0xf5, 0x5f, 0x2b, 0x54,
+    0xf1, 0x59, 0x6b, 0x4b, 0x23, 0xf3, 0x25, 0x92, 0x9c, 0x4b, 0x20, 0xed, 0xb8, 0xff, 0x00,
+    0x00, 0xf6, 0xeb, 0xf4, 0xaf, 0x78, 0xb2, 0x87, 0x4b, 0xd0, 0xac, 0x63, 0xb2, 0xd3, 0xed,
+    0xa1, 0xb6, 0xb6, 0x88, 0x61, 0x62, 0x89, 0x40, 0x03, 0xfc, 0x4f, 0xbd, 0x63, 0x49, 0xa9,
+    0x4d, 0x31, 0xcb, 0x3f, 0xe0, 0x2a, 0x06, 0x99, 0x9a, 0xa6, 0xd7, 0x2d, 0x24, 0xb6, 0x37,
+    0x65, 0xd6, 0x07, 0x44, 0x5c, 0xfd, 0x4d, 0x52, 0x93, 0x52, 0x99, 0xff, 0x00, 0x8f, 0x68,
+    0xf4, 0x15, 0x9b, 0xb8, 0x9e, 0xf4, 0x06, 0x39, 0xa7, 0x64, 0x3b, 0x96, 0xda, 0xe1, 0x9b,
+    0xab, 0x31, 0xfc, 0x69, 0xbe, 0x75, 0x41, 0x40, 0xa0, 0x2e, 0x4d, 0xe7, 0x53, 0xbc, 0xef,
+    0x6a, 0x82, 0x9d, 0x4c, 0x09, 0x44, 0xc7, 0xd0, 0x53, 0xbc, 0xd6, 0xf4, 0x15, 0x12, 0xf5,
+    0xa7, 0x62, 0x80, 0x24, 0xf3, 0x5b, 0x1d, 0xa9, 0x44, 0xad, 0xed, 0x4c, 0x14, 0x52, 0x02,
+    0x5f, 0x35, 0xa9, 0x7c, 0xd6, 0xa6, 0x51, 0x40, 0x12, 0x09, 0xc8, 0xec, 0x29, 0xeb, 0x72,
+    0x46, 0x38, 0x22, 0xa0, 0xc5, 0x2e, 0x0d, 0x03, 0xb9, 0x75, 0x2f, 0x48, 0xfe, 0x23, 0xf8,
+    0xd5, 0x98, 0xef, 0x41, 0xfb, 0xd8, 0xac, 0xac, 0x7b, 0x51, 0x4a, 0xc3, 0xb9, 0xbc, 0x93,
+    0x83, 0xd1, 0xb3, 0x55, 0xf5, 0x6d, 0x27, 0x4c, 0xd7, 0xf4, 0xf7, 0xb0, 0xd5, 0x6c, 0xe2,
+    0xba, 0xb6, 0x7e, 0xb1, 0xc8, 0x33, 0x83, 0xea, 0x0f, 0x50, 0x7d, 0xc7, 0x35, 0x9c, 0x8e,
+    0xeb, 0xd0, 0xd5, 0xa8, 0xaf, 0x58, 0x70, 0xfd, 0x29, 0x5b, 0xb0, 0x68, 0xcf, 0x9f, 0xbe,
+    0x21, 0x7c, 0x2a, 0xbe, 0xf0, 0x72, 0xbe, 0xa9, 0xa4, 0x19, 0x6f, 0xb4, 0x51, 0xcc, 0x8a,
+    0x46, 0x64, 0xb6, 0x1e, 0xfe, 0xab, 0xef, 0xdb, 0xbf, 0xa9, 0xf3, 0xf8, 0xe4, 0x59, 0x54,
+    0x32, 0x1c, 0x83, 0x5f, 0x68, 0x24, 0x89, 0x2c, 0x78, 0x38, 0x64, 0x23, 0x04, 0x1e, 0x6b,
+    0xe7, 0x8f, 0x8b, 0x3f, 0x0d, 0xd3, 0xc2, 0xd3, 0xb7, 0x88, 0xf4, 0x38, 0x71, 0xa4, 0x4c,
+    0xe0, 0x5c, 0xdb, 0x28, 0xe2, 0xd9, 0xc9, 0xc0, 0x23, 0xd1, 0x09, 0x38, 0xc7, 0x63, 0xc7,
+    0x42, 0x00, 0xd6, 0x15, 0x1a, 0x76, 0x66, 0x13, 0xa7, 0x6d, 0x51, 0xe6, 0x37, 0xad, 0x8b,
+    0x66, 0xf5, 0x3c, 0x57, 0xd7, 0x5e, 0x0e, 0xb1, 0xfe, 0xc6, 0xf0, 0x06, 0x8d, 0x68, 0x54,
+    0xab, 0xc7, 0x67, 0x1e, 0xe0, 0x7b, 0x31, 0x19, 0x3f, 0xa9, 0x35, 0xf2, 0xef, 0x84, 0x34,
+    0x7f, 0xf8, 0x4b, 0x3c, 0x6b, 0xa4, 0x69, 0x51, 0x82, 0xd0, 0xbc, 0xa2, 0x49, 0xfd, 0xa3,
+    0x5e, 0x5b, 0xf4, 0x04, 0x7e, 0x35, 0xf5, 0xbd, 0xec, 0x80, 0x46, 0xa8, 0xbc, 0x0e, 0xc2,
+    0x95, 0x57, 0x79, 0x0e, 0x92, 0xea, 0x67, 0x9e, 0x58, 0x9a, 0x31, 0x4b, 0x45, 0x23, 0x51,
+    0x31, 0x4b, 0x8a, 0x5a, 0x28, 0x03, 0x17, 0xe2, 0x25, 0xc7, 0xd9, 0x7e, 0x17, 0xeb, 0xb2,
+    0x03, 0x8c, 0xda, 0x14, 0xff, 0x00, 0xbe, 0x88, 0x5f, 0xeb, 0x5f, 0x30, 0x58, 0xc6, 0x45,
+    0x8c, 0x47, 0xd7, 0x9a, 0xfa, 0x0b, 0xe3, 0x55, 0xf1, 0xb4, 0xf8, 0x5f, 0x34, 0x2a, 0xfb,
+    0x4d, 0xd4, 0xf1, 0x43, 0x8f, 0x51, 0x9d, 0xc7, 0xff, 0x00, 0x41, 0xaf, 0x0a, 0x8e, 0x31,
+    0x1d, 0x8c, 0x23, 0xd1, 0x45, 0x6d, 0x86, 0x8d, 0xdb, 0x39, 0xeb, 0xbb, 0x34, 0x45, 0x27,
+    0xca, 0xa0, 0x54, 0x5d, 0xea, 0x46, 0x3b, 0xa9, 0x98, 0xae, 0x89, 0x6a, 0x64, 0x3d, 0x3e,
+    0xf5, 0x5d, 0x71, 0x98, 0xea, 0x92, 0x8c, 0x55, 0xc8, 0xdb, 0x74, 0x75, 0x71, 0x22, 0x7d,
+    0xc8, 0x36, 0xe1, 0x69, 0xb8, 0xc9, 0xa9, 0x64, 0xe4, 0xe2, 0x9a, 0xab, 0x4c, 0x69, 0xe8,
+    0x0a, 0xb8, 0xa9, 0x15, 0x79, 0xc0, 0xa4, 0x03, 0x9a, 0x95, 0x71, 0xf8, 0xd3, 0x22, 0x4c,
+    0x30, 0x05, 0x14, 0xa4, 0x71, 0x4f, 0x48, 0xc9, 0xa2, 0xc6, 0x77, 0xb0, 0x88, 0x9b, 0x8d,
+    0x4c, 0x10, 0x0e, 0xb4, 0xe5, 0x5d, 0xb4, 0xd6, 0xeb, 0x4c, 0xcd, 0xbb, 0xb0, 0xc8, 0x14,
+    0xd6, 0x90, 0x0a, 0x08, 0xe2, 0xa1, 0x61, 0x40, 0xd2, 0x4c, 0x73, 0x4b, 0x51, 0x99, 0x4d,
+    0x26, 0xd3, 0x4c, 0x3c, 0x54, 0x9a, 0x28, 0xa1, 0x4c, 0xad, 0x49, 0xe6, 0x7a, 0xd3, 0x09,
+    0xcd, 0x14, 0x5c, 0xab, 0x21, 0xdb, 0x85, 0x21, 0x20, 0xd3, 0x4d, 0x31, 0x8e, 0x07, 0x14,
+    0xae, 0x16, 0x15, 0x94, 0x35, 0x40, 0xf1, 0x7a, 0x52, 0xf9, 0x8c, 0x0f, 0x34, 0xe0, 0xe0,
+    0xd4, 0xbb, 0x32, 0xd2, 0x68, 0xac, 0x54, 0x8a, 0x6e, 0x2a, 0xe6, 0xd0, 0xd4, 0x79, 0x00,
+    0xd4, 0xf2, 0x8f, 0x99, 0x75, 0x2a, 0x81, 0x53, 0x46, 0xbd, 0xe9, 0xde, 0x41, 0x06, 0xa5,
+    0x55, 0xc5, 0x35, 0x11, 0x39, 0x08, 0x05, 0x3c, 0x2d, 0x28, 0x5a, 0x78, 0x15, 0x66, 0x4d,
+    0x8d, 0xdb, 0x46, 0x2a, 0x4d, 0xb4, 0x98, 0xe6, 0x8b, 0x12, 0x30, 0x0a, 0x31, 0x4f, 0xc5,
+    0x21, 0x14, 0x01, 0x19, 0xa6, 0x13, 0x4f, 0x3c, 0x54, 0x4c, 0x70, 0x29, 0x0d, 0x0d, 0x26,
+    0xa2, 0x66, 0xa1, 0x9b, 0x8a, 0x81, 0x9f, 0x35, 0x12, 0x66, 0xd1, 0x88, 0x33, 0x66, 0xa2,
+    0x66, 0xa1, 0x9a, 0xa3, 0x26, 0xb0, 0x94, 0x8d, 0x52, 0x02, 0x6a, 0x32, 0x68, 0x26, 0x9b,
+    0x9a, 0xc9, 0xb1, 0x85, 0x14, 0x66, 0x92, 0x90, 0x0b, 0x9a, 0x43, 0x41, 0xa4, 0xa4, 0x30,
+    0xcd, 0x26, 0x69, 0x0d, 0x14, 0x00, 0xb4, 0x99, 0xa2, 0x8a, 0x00, 0x9e, 0x0b, 0xa9, 0x20,
+    0x39, 0x52, 0x45, 0x49, 0x35, 0xfc, 0xb3, 0x0c, 0x33, 0x13, 0x55, 0x28, 0xa0, 0x00, 0x9c,
+    0xd1, 0xde, 0x92, 0x8a, 0x00, 0x98, 0x74, 0xa4, 0x2c, 0x05, 0x47, 0xb8, 0xd2, 0x67, 0x34,
+    0xee, 0x03, 0xcb, 0xd3, 0x49, 0x34, 0x94, 0xa1, 0x49, 0xa5, 0xa8, 0x09, 0x45, 0x3b, 0x61,
+    0xa5, 0xf2, 0xe8, 0xb0, 0x0c, 0xa3, 0x9a, 0x93, 0x65, 0x1b, 0x68, 0xb0, 0x11, 0xe0, 0xd2,
+    0x85, 0xa7, 0xed, 0xa5, 0xc5, 0x16, 0x01, 0x81, 0x69, 0x71, 0x4f, 0xc5, 0x14, 0xec, 0x03,
+    0x71, 0x49, 0x8a, 0x75, 0x14, 0x00, 0x98, 0xa4, 0xc5, 0x2d, 0x14, 0x00, 0xdf, 0xe3, 0x14,
+    0x8f, 0xd0, 0xd2, 0xff, 0x00, 0xcb, 0x41, 0x43, 0xfd, 0xd3, 0x4b, 0xa0, 0x11, 0x53, 0x97,
+    0xa5, 0x36, 0x95, 0x6a, 0x50, 0xc7, 0x66, 0x8a, 0x4a, 0x4c, 0xd3, 0x10, 0xb4, 0xb4, 0xd1,
+    0xd6, 0x96, 0x90, 0x01, 0x38, 0xa5, 0x45, 0x2e, 0xd9, 0x3d, 0x29, 0x00, 0x2c, 0xd8, 0x15,
+    0x61, 0x14, 0x28, 0xa6, 0x95, 0xc0, 0x38, 0x51, 0x8a, 0x82, 0x46, 0xc9, 0xc5, 0x49, 0x2b,
+    0xe2, 0xab, 0xd3, 0x93, 0xe8, 0x08, 0x28, 0xa2, 0x96, 0xa0, 0x62, 0x51, 0x45, 0x3e, 0x35,
+    0xdc, 0xc0, 0x50, 0x02, 0x04, 0x27, 0xb5, 0x05, 0x08, 0xad, 0xdb, 0x2d, 0x3c, 0x4a, 0xb9,
+    0xc5, 0x45, 0x7f, 0x62, 0x21, 0x07, 0x8a, 0xd3, 0xd9, 0xbb, 0x5c, 0x57, 0x31, 0x68, 0xa7,
+    0x38, 0xc1, 0xa6, 0xd6, 0x63, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28,
+    0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x34, 0xb4, 0xd9, 0x36, 0xb8, 0x15, 0x6e, 0xfc, 0x6e,
+    0x00, 0xd6, 0x65, 0x99, 0xdb, 0x2d, 0x6b, 0xce, 0x37, 0x46, 0x0d, 0x75, 0xd3, 0x77, 0x83,
+    0x44, 0x3d, 0xca, 0x04, 0x14, 0x86, 0xa8, 0xe7, 0xe6, 0xcd, 0x5f, 0xb8, 0x60, 0x23, 0xc5,
+    0x67, 0xd6, 0x53, 0xdc, 0xa4, 0x6a, 0xda, 0x3e, 0xf8, 0xf6, 0xd3, 0x27, 0x21, 0x14, 0x8a,
+    0x86, 0xca, 0x4d, 0xad, 0x8a, 0x75, 0xe9, 0x07, 0xa5, 0x5d, 0xfd, 0xc1, 0x75, 0x29, 0x13,
+    0x93, 0x9a, 0x4a, 0x28, 0xac, 0x86, 0x14, 0xf1, 0x4c, 0xa5, 0x07, 0x06, 0x80, 0x1d, 0x45,
+    0x14, 0x50, 0x02, 0xa9, 0xc1, 0xa9, 0x50, 0xe5, 0xc1, 0x62, 0x49, 0xf5, 0x35, 0x0d, 0x3e,
+    0x3c, 0xee, 0x1e, 0x94, 0xd0, 0x17, 0xc8, 0x18, 0xcd, 0x56, 0x72, 0x37, 0x71, 0x56, 0xdc,
+    0x7e, 0xe6, 0xa8, 0x1e, 0xb5, 0xa4, 0xf4, 0x12, 0x3a, 0x3f, 0x01, 0x78, 0x98, 0xf8, 0x4f,
+    0xc6, 0x96, 0x3a, 0x93, 0x31, 0x16, 0xcc, 0xde, 0x55, 0xc0, 0xff, 0x00, 0xa6, 0x6d, 0xc1,
+    0x3f, 0x87, 0x5f, 0xc2, 0xbe, 0xba, 0x99, 0x23, 0xbd, 0xb3, 0x2a, 0xac, 0x19, 0x24, 0x5c,
+    0xab, 0x0e, 0x41, 0xcf, 0x43, 0x5f, 0x10, 0xb4, 0x7b, 0x97, 0x1d, 0xfb, 0x57, 0xd2, 0xdf,
+    0x05, 0x3c, 0x61, 0xfd, 0xbd, 0xe1, 0x61, 0xa4, 0xdd, 0x49, 0x9b, 0xfd, 0x30, 0x08, 0xce,
+    0xe3, 0xcb, 0xc5, 0xfc, 0x27, 0xf0, 0xe9, 0xf8, 0x0a, 0xc2, 0x48, 0xda, 0x9c, 0xba, 0x17,
+    0xe7, 0x85, 0xa3, 0x91, 0xd1, 0x86, 0x19, 0x4e, 0x08, 0xa8, 0xc7, 0x4a, 0xe8, 0xb5, 0xfb,
+    0x1d, 0xb2, 0x0b, 0xa4, 0x1c, 0x37, 0x0f, 0xf5, 0xf5, 0xae, 0x78, 0x8c, 0x31, 0x15, 0x49,
+    0xdc, 0x6d, 0x59, 0x8e, 0x43, 0x83, 0xf5, 0xa9, 0x08, 0xef, 0x50, 0x8a, 0x99, 0x4e, 0x45,
+    0x02, 0x14, 0x1a, 0x78, 0xa6, 0x11, 0x83, 0x4a, 0x0d, 0x03, 0x2c, 0x63, 0xe5, 0xce, 0x45,
+    0x26, 0x71, 0x4c, 0x1d, 0x29, 0x68, 0x19, 0x25, 0x28, 0xeb, 0x5c, 0xf6, 0xbb, 0xe3, 0x4d,
+    0x0f, 0xc3, 0x8a, 0x52, 0xf6, 0xed, 0x4c, 0xe3, 0xa5, 0xbc, 0x5f, 0x33, 0x9f, 0xc3, 0xb7,
+    0xe3, 0x5c, 0x06, 0xa3, 0xf1, 0x57, 0x5c, 0xbc, 0x76, 0x5d, 0x1f, 0x4d, 0x8a, 0xd6, 0x1e,
+    0xd2, 0x5c, 0x7c, 0xee, 0x7d, 0xf1, 0xc0, 0x1f, 0xad, 0x16, 0x13, 0x92, 0x47, 0xb1, 0x52,
+    0x8a, 0xf9, 0xf6, 0x6f, 0x16, 0xf8, 0xda, 0xe0, 0xe5, 0xb5, 0x89, 0x10, 0x7f, 0x76, 0x38,
+    0xd4, 0x0f, 0xe5, 0x56, 0xb4, 0xff, 0x00, 0x1e, 0x78, 0xca, 0xc2, 0x40, 0xcf, 0x74, 0x97,
+    0xc8, 0x0e, 0x0c, 0x73, 0xa0, 0x04, 0xfe, 0x23, 0x14, 0xec, 0xc9, 0xe7, 0x47, 0xbc, 0x8a,
+    0x5a, 0xe3, 0xfc, 0x31, 0xf1, 0x07, 0x4f, 0xd7, 0xdd, 0x6d, 0xa7, 0x43, 0x65, 0x7b, 0xd0,
+    0xc4, 0xed, 0xc1, 0x3e, 0xc6, 0xbb, 0x11, 0x4b, 0x62, 0x93, 0x4c, 0x51, 0x4f, 0xa6, 0x8a,
+    0x75, 0x05, 0x0a, 0x29, 0xc0, 0xfb, 0x52, 0x0e, 0x94, 0xb4, 0x80, 0x78, 0xc6, 0x29, 0x70,
+    0x29, 0xa3, 0x8a, 0x78, 0xa0, 0x07, 0x6d, 0x14, 0xbb, 0x45, 0x0b, 0x4e, 0xa0, 0x63, 0x71,
+    0x40, 0x14, 0xb4, 0x1e, 0x94, 0x00, 0x86, 0x96, 0x92, 0x97, 0x14, 0x01, 0x24, 0x52, 0x34,
+    0x4d, 0x90, 0x7f, 0x0f, 0x5a, 0xb3, 0x7b, 0x69, 0x6b, 0xac, 0x69, 0x97, 0x1a, 0x7d, 0xdc,
+    0x62, 0x4b, 0x6b, 0x98, 0x9a, 0x39, 0x10, 0xf7, 0x52, 0x30, 0x6a, 0xa0, 0xa9, 0xa0, 0x90,
+    0xc6, 0xde, 0xd4, 0x34, 0x34, 0x78, 0xaf, 0xc2, 0x9b, 0x2b, 0x5f, 0x05, 0xfc, 0x50, 0xd6,
+    0x7c, 0x3d, 0xa9, 0xc6, 0x3f, 0xb4, 0x0a, 0x6c, 0xb3, 0xb9, 0x6e, 0x37, 0xa0, 0xf9, 0xb0,
+    0x07, 0xfb, 0x4b, 0xb4, 0xfe, 0x18, 0xaf, 0x6a, 0x9a, 0x4f, 0x32, 0x42, 0xdf, 0x95, 0x79,
+    0xa7, 0xc6, 0x9d, 0x02, 0x68, 0xed, 0xec, 0x3c, 0x69, 0xa5, 0x02, 0x97, 0xda, 0x5c, 0x8b,
+    0xe6, 0xb2, 0x0e, 0x4c, 0x79, 0xf9, 0x49, 0xfa, 0x1e, 0x3e, 0x8d, 0x5d, 0xaf, 0x87, 0xf5,
+    0x88, 0x75, 0xfd, 0x06, 0xcb, 0x54, 0x83, 0xee, 0x5c, 0x44, 0x1c, 0x8f, 0xee, 0x9e, 0xe3,
+    0xf0, 0x39, 0xa1, 0x11, 0x1d, 0x1f, 0x29, 0xa5, 0x4b, 0x8e, 0x28, 0x14, 0xb4, 0x14, 0x20,
+    0xa2, 0x94, 0xf0, 0x28, 0x45, 0xdc, 0xe0, 0x50, 0x07, 0x8f, 0xfc, 0x7d, 0xbf, 0x06, 0x1f,
+    0x0f, 0xe8, 0xeb, 0xf7, 0xd9, 0xde, 0xe1, 0x87, 0xa0, 0x18, 0x51, 0xfc, 0xcd, 0x79, 0xbb,
+    0x8c, 0xc0, 0x3d, 0x85, 0x68, 0xfc, 0x45, 0xd7, 0x07, 0x89, 0x3e, 0x24, 0x5f, 0x5c, 0x44,
+    0xdb, 0xad, 0xac, 0x80, 0xb5, 0x88, 0x83, 0x90, 0x42, 0xf5, 0x3f, 0xf7, 0xd1, 0x6a, 0xcc,
+    0x56, 0x26, 0x2a, 0xec, 0xc3, 0x2d, 0x1b, 0x38, 0xeb, 0x3b, 0xca, 0xe5, 0x46, 0x18, 0x34,
+    0x0a, 0x53, 0xd6, 0x95, 0x45, 0x6b, 0x61, 0x00, 0x15, 0x62, 0x11, 0xf2, 0xd3, 0x02, 0x54,
+    0xa8, 0xb8, 0x15, 0x69, 0x11, 0x37, 0xa0, 0x8c, 0xbd, 0xf3, 0x40, 0x5e, 0x2a, 0x4d, 0xb9,
+    0xeb, 0x4a, 0x17, 0x06, 0x82, 0x39, 0x86, 0x01, 0x4f, 0x03, 0xd6, 0x8a, 0x52, 0x68, 0x13,
+    0x14, 0x60, 0xd5, 0xb8, 0xd3, 0x6a, 0xd5, 0x35, 0x3c, 0xd5, 0x96, 0x9c, 0x04, 0xa6, 0x67,
+    0x2b, 0x8a, 0x4d, 0x46, 0xc4, 0x0a, 0x81, 0xe7, 0xe6, 0xa2, 0x33, 0xd1, 0x70, 0x54, 0xd9,
+    0x61, 0x9b, 0x3f, 0x4a, 0x61, 0x61, 0x50, 0x79, 0xcc, 0x7b, 0x52, 0x7c, 0xed, 0xda, 0x95,
+    0xcb, 0x50, 0xb1, 0x21, 0x71, 0x51, 0x33, 0x73, 0x4b, 0xe4, 0xb9, 0xf5, 0xa0, 0xdb, 0xb9,
+    0x39, 0xc1, 0xa5, 0xa9, 0x4b, 0x95, 0x0d, 0xc8, 0xce, 0x33, 0x4e, 0x04, 0x52, 0x8b, 0x76,
+    0xdd, 0x9c, 0x1e, 0x95, 0xa9, 0xa0, 0x5a, 0xc1, 0x26, 0xb7, 0x6c, 0xb7, 0x78, 0x10, 0x96,
+    0xe7, 0x3d, 0x33, 0x48, 0x2e, 0x9b, 0xb1, 0x98, 0xe8, 0xca, 0x01, 0x65, 0x65, 0x07, 0xd4,
+    0x75, 0xa8, 0x58, 0x0a, 0xf5, 0xaf, 0x1b, 0xe9, 0xba, 0x44, 0x1a, 0x01, 0x92, 0x16, 0x4d,
+    0xf8, 0x18, 0xfa, 0xfb, 0x57, 0x90, 0x39, 0x6e, 0xf4, 0xaf, 0x75, 0x73, 0x59, 0x53, 0x70,
+    0x97, 0x2b, 0x63, 0x58, 0x73, 0x49, 0x8a, 0x29, 0xe8, 0xb9, 0x35, 0x23, 0xd8, 0x74, 0x60,
+    0xe2, 0xac, 0xc7, 0xc8, 0xa8, 0x94, 0x55, 0x84, 0x5c, 0x55, 0xa3, 0x09, 0xb1, 0x76, 0x03,
+    0xc5, 0x34, 0xc5, 0x8a, 0x99, 0x47, 0x14, 0xfd, 0xb9, 0xa6, 0x66, 0x99, 0x58, 0x2d, 0x28,
+    0x18, 0xa9, 0x8a, 0x62, 0x98, 0x45, 0x00, 0x36, 0x93, 0x14, 0xec, 0x52, 0x50, 0x01, 0x56,
+    0x6f, 0x74, 0xbb, 0xeb, 0x08, 0x21, 0x9a, 0xee, 0xd6, 0x48, 0x63, 0x9c, 0x6e, 0x8d, 0x98,
+    0x70, 0xc2, 0xab, 0x13, 0xc5, 0x5f, 0xd5, 0xbc, 0x47, 0xa9, 0x6a, 0xf6, 0x96, 0xd6, 0xd7,
+    0xb3, 0xf9, 0x91, 0x5b, 0x0c, 0x46, 0x36, 0x81, 0xdb, 0x19, 0x3e, 0xa6, 0x91, 0x6b, 0x96,
+    0xce, 0xfb, 0xf4, 0x31, 0xdc, 0xe0, 0x55, 0x67, 0x6a, 0x92, 0x47, 0xaa, 0x8e, 0xf5, 0x12,
+    0x65, 0xc2, 0x22, 0x3b, 0xe6, 0xa1, 0x66, 0xa5, 0x66, 0xa8, 0x89, 0xac, 0x25, 0x23, 0x74,
+    0x80, 0x9a, 0x61, 0x34, 0x13, 0x4d, 0xcd, 0x64, 0xd8, 0xc0, 0xd3, 0x68, 0xa4, 0xa9, 0x01,
+    0x68, 0xa4, 0xa2, 0x80, 0x0a, 0x29, 0x28, 0xa4, 0x30, 0xa4, 0xa5, 0xa4, 0xa0, 0x02, 0x8c,
+    0xd1, 0x49, 0x40, 0x06, 0x68, 0xa2, 0x8a, 0x00, 0x28, 0xc5, 0x14, 0xa0, 0x64, 0xd0, 0x02,
+    0x05, 0x26, 0xa4, 0x11, 0xfa, 0xd3, 0xd5, 0x70, 0x29, 0xd8, 0xaa, 0x48, 0x06, 0x05, 0x02,
+    0x97, 0x14, 0xec, 0x51, 0x4c, 0x06, 0xd2, 0xe2, 0x83, 0x49, 0x9a, 0x04, 0x2d, 0x14, 0x99,
+    0xa3, 0x34, 0x0c, 0x28, 0xa4, 0xa2, 0x90, 0x05, 0x25, 0x2d, 0x14, 0x00, 0x94, 0x52, 0xd3,
+    0x4d, 0x20, 0x0a, 0x4c, 0xd0, 0x4d, 0x26, 0x69, 0x00, 0x0f, 0xbe, 0x29, 0x48, 0xf9, 0x5a,
+    0x99, 0xfc, 0x42, 0xa5, 0x3f, 0x70, 0xd0, 0x80, 0xaf, 0x4a, 0x29, 0x28, 0xa8, 0x01, 0x73,
+    0x46, 0x28, 0xa2, 0x9d, 0xc0, 0x05, 0x29, 0xa0, 0x0e, 0xf4, 0xe8, 0xd7, 0x73, 0x64, 0xf4,
+    0x14, 0xc0, 0x7c, 0x69, 0x81, 0x52, 0x31, 0xc0, 0xa5, 0x03, 0x02, 0xab, 0xca, 0xfc, 0xe2,
+    0xad, 0xe8, 0x80, 0x63, 0x36, 0xe3, 0x4d, 0xa2, 0x8a, 0xc8, 0x62, 0xd1, 0x47, 0x34, 0x50,
+    0x02, 0x53, 0xe2, 0x6d, 0xac, 0x29, 0xb4, 0x50, 0x07, 0x43, 0x61, 0x7e, 0xb1, 0x2e, 0x0d,
+    0x47, 0xa8, 0x5e, 0xac, 0xc0, 0xe2, 0xb1, 0x56, 0x42, 0xbd, 0xe8, 0x69, 0x0b, 0x56, 0xbe,
+    0xd5, 0xda, 0xc2, 0xb0, 0xd7, 0x39, 0x6a, 0x6d, 0x2d, 0x25, 0x64, 0x30, 0xa2, 0x8a, 0x28,
+    0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x02, 0xcd, 0xb9,
+    0xc4, 0xa2, 0xb5, 0xe4, 0x39, 0x84, 0x56, 0x2c, 0x47, 0x12, 0x0a, 0xd3, 0x77, 0xcc, 0x3c,
+    0x1e, 0xd5, 0xd3, 0x4d, 0xd9, 0x32, 0x59, 0x46, 0xe5, 0xb9, 0xc5, 0x57, 0xa7, 0xc8, 0x72,
+    0xe6, 0x99, 0x59, 0x3d, 0xc6, 0x39, 0x1c, 0xa1, 0xc8, 0xa5, 0x79, 0x0b, 0xf5, 0xa6, 0x51,
+    0x40, 0x05, 0x14, 0x52, 0xed, 0xa0, 0x04, 0xa2, 0x9d, 0x81, 0x4b, 0x40, 0x02, 0x29, 0x34,
+    0xe0, 0xb4, 0xda, 0x78, 0x20, 0xd0, 0x02, 0xe0, 0x7a, 0x52, 0xaf, 0xde, 0x14, 0x94, 0xab,
+    0xf7, 0x85, 0x00, 0x68, 0x91, 0x98, 0x05, 0x54, 0x68, 0xc6, 0x6a, 0xea, 0xff, 0x00, 0xc7,
+    0xb5, 0x53, 0x19, 0xdd, 0x5b, 0xcb, 0xa1, 0x28, 0x42, 0x30, 0x40, 0xad, 0x6f, 0x0d, 0xf8,
+    0x86, 0xeb, 0xc1, 0xfe, 0x26, 0xb4, 0xd6, 0xad, 0x72, 0x55, 0x0e, 0xd9, 0xa3, 0x07, 0xfd,
+    0x62, 0x1e, 0xab, 0xfe, 0x7b, 0x81, 0x58, 0xce, 0xe4, 0xbd, 0x5b, 0x64, 0x12, 0x41, 0x82,
+    0x38, 0x35, 0x16, 0xe6, 0xba, 0x1d, 0xec, 0x7d, 0x8b, 0xa6, 0xea, 0x56, 0x1e, 0x24, 0xd1,
+    0x21, 0xbe, 0xb3, 0x94, 0x4d, 0x6b, 0x73, 0x1e, 0xe5, 0x23, 0xb7, 0xb1, 0xf7, 0x15, 0xcc,
+    0xea, 0x36, 0x4f, 0x69, 0x39, 0x52, 0x3a, 0x74, 0x3e, 0xa2, 0xbc, 0x43, 0xe1, 0x97, 0xc4,
+    0x49, 0xbc, 0x0d, 0xaa, 0x1b, 0x0b, 0xf2, 0xd2, 0x68, 0xd7, 0x2d, 0x97, 0x1d, 0x4c, 0x4d,
+    0xfd, 0xf5, 0xfe, 0xa2, 0xbe, 0x94, 0x9d, 0x2d, 0x75, 0x9d, 0x3a, 0x3b, 0x9b, 0x69, 0x52,
+    0x68, 0xe4, 0x50, 0xf1, 0xc8, 0x87, 0x21, 0x81, 0xac, 0x76, 0x67, 0x42, 0x7c, 0xc8, 0xe3,
+    0x85, 0x3d, 0x4e, 0x0d, 0x3a, 0x78, 0x1a, 0x09, 0x59, 0x18, 0x63, 0x14, 0xca, 0xa2, 0x4b,
+    0x2a, 0x03, 0x0a, 0x66, 0x30, 0x69, 0xb1, 0x3e, 0xc3, 0xed, 0x40, 0x6e, 0x79, 0xa0, 0x64,
+    0xaa, 0x6b, 0xcf, 0x7c, 0x79, 0xe3, 0xa9, 0xb4, 0xe9, 0xdb, 0x45, 0xd1, 0x88, 0xfb, 0x71,
+    0x1f, 0xbe, 0x9b, 0x19, 0xf2, 0x41, 0xec, 0x3f, 0xda, 0xfe, 0x55, 0xd3, 0x78, 0xa7, 0x5c,
+    0x5f, 0x0f, 0xe8, 0x17, 0x17, 0xb9, 0x1e, 0x76, 0x36, 0x42, 0xbf, 0xde, 0x73, 0xd3, 0xfc,
+    0x7f, 0x0a, 0xf1, 0x5b, 0x14, 0x62, 0x64, 0xbc, 0xba, 0x90, 0xbc, 0xb2, 0x12, 0xf2, 0x48,
+    0xe7, 0x9f, 0x73, 0x55, 0x15, 0x72, 0x27, 0x2b, 0x21, 0xfa, 0x7e, 0x8a, 0x64, 0x91, 0xae,
+    0x6e, 0x58, 0xc9, 0x21, 0x62, 0x5e, 0x59, 0x0e, 0x49, 0x3f, 0xd4, 0xd5, 0xbb, 0xbb, 0xab,
+    0x3b, 0x34, 0x23, 0x72, 0x64, 0x77, 0x73, 0xfc, 0x80, 0xac, 0x0d, 0x5b, 0xc4, 0x72, 0xce,
+    0xc6, 0x0b, 0x3c, 0xc5, 0x02, 0xf0, 0x0f, 0x73, 0x58, 0x2e, 0xec, 0xed, 0xb9, 0xd8, 0xb1,
+    0xf5, 0x26, 0x87, 0x51, 0x47, 0x44, 0x65, 0xca, 0xde, 0xac, 0xe8, 0xa6, 0xd6, 0x20, 0x66,
+    0xce, 0xe0, 0x7f, 0xdd, 0x18, 0xff, 0x00, 0x1a, 0x8d, 0x75, 0x6b, 0x72, 0xd9, 0xdf, 0x2a,
+    0x37, 0xae, 0x72, 0x3f, 0x2c, 0x57, 0x3f, 0x45, 0x47, 0xb4, 0x65, 0x59, 0x1b, 0x69, 0xaa,
+    0xc7, 0x3c, 0x98, 0x93, 0xf7, 0x72, 0x29, 0xca, 0x4a, 0xbc, 0x7f, 0xfa, 0xab, 0xdb, 0xbe,
+    0x1c, 0xf8, 0xc7, 0xfb, 0x6e, 0xd4, 0xe9, 0x97, 0xf2, 0x86, 0xd4, 0x20, 0x5c, 0xab, 0x7f,
+    0xcf, 0x54, 0xf5, 0xfa, 0x8e, 0xf5, 0xf3, 0xb5, 0x68, 0x68, 0xfa, 0x9d, 0xde, 0x91, 0xaa,
+    0xdb, 0x6a, 0x16, 0x8c, 0xc2, 0x5b, 0x76, 0xde, 0x30, 0x7a, 0x8e, 0xe3, 0xe8, 0x68, 0xe6,
+    0xbe, 0xe3, 0x5a, 0x33, 0xeb, 0x70, 0x29, 0xd5, 0x9f, 0xa1, 0xea, 0xb0, 0x6b, 0x9a, 0x35,
+    0xae, 0xa5, 0x6c, 0x7f, 0x77, 0x71, 0x18, 0x6c, 0x7a, 0x1e, 0xe3, 0xf0, 0xad, 0x1a, 0x66,
+    0xe8, 0x51, 0x4b, 0x49, 0x4e, 0xa0, 0x00, 0x53, 0xd6, 0x9a, 0x29, 0xe8, 0x29, 0x00, 0xf1,
+    0xc5, 0x2d, 0x20, 0x14, 0xa4, 0xe0, 0x73, 0x40, 0xc2, 0xbc, 0xdf, 0xc5, 0xdf, 0x14, 0xa2,
+    0xd3, 0xee, 0x65, 0xd2, 0xfc, 0x3f, 0x02, 0xdf, 0x5f, 0xa1, 0xdb, 0x24, 0xcd, 0xfe, 0xaa,
+    0x23, 0xe9, 0xfe, 0xd1, 0xa8, 0xbe, 0x26, 0xf8, 0xc2, 0xe2, 0xd0, 0xaf, 0x87, 0x74, 0xa9,
+    0x4a, 0x5d, 0xdc, 0x26, 0xeb, 0x89, 0x94, 0xf3, 0x14, 0x67, 0xb0, 0xf7, 0x35, 0xe4, 0x8f,
+    0xab, 0x59, 0x69, 0x0a, 0x6d, 0xe0, 0x50, 0xf2, 0x2f, 0x53, 0xd7, 0x9f, 0xf1, 0xaa, 0x49,
+    0x6e, 0xcc, 0x67, 0x51, 0xed, 0x13, 0x76, 0xfb, 0x57, 0xf1, 0x76, 0xac, 0x0c, 0x97, 0xba,
+    0xfd, 0xc4, 0x40, 0xf3, 0xb2, 0x03, 0xe5, 0xa8, 0xfc, 0x17, 0x15, 0x98, 0x3f, 0xb6, 0xe1,
+    0xf9, 0xa0, 0xd7, 0xf5, 0x10, 0xd9, 0xef, 0x3b, 0x73, 0xfa, 0xd6, 0x43, 0x78, 0xa6, 0x60,
+    0xd9, 0x48, 0x15, 0x8f, 0xac, 0x87, 0x34, 0x27, 0x8a, 0xae, 0x0b, 0x7e, 0xf6, 0x14, 0x2b,
+    0xfe, 0xc8, 0xc5, 0x55, 0xe0, 0x65, 0xef, 0x9d, 0xc6, 0x8b, 0xf1, 0x37, 0xc4, 0xda, 0x0c,
+    0xe9, 0x1e, 0xa3, 0x27, 0xf6, 0x95, 0xaf, 0x42, 0x93, 0x60, 0x3e, 0x3d, 0x9c, 0x7f, 0x5c,
+    0xd7, 0xb1, 0xf8, 0x6f, 0xc5, 0xda, 0x4f, 0x8a, 0xad, 0x3c, 0xed, 0x3e, 0x73, 0xe6, 0x2f,
+    0x12, 0x41, 0x20, 0xc3, 0xa1, 0xf7, 0x15, 0xf3, 0x9c, 0x57, 0xd0, 0x5f, 0xa1, 0xc1, 0x0c,
+    0x3d, 0x0f, 0x51, 0x52, 0x58, 0x5f, 0x5f, 0x78, 0x6b, 0x55, 0x8b, 0x57, 0xd3, 0x5c, 0xef,
+    0x88, 0xfc, 0xd1, 0x93, 0xc3, 0xaf, 0x75, 0x34, 0x38, 0xad, 0xd1, 0x71, 0x9b, 0x5b, 0x9f,
+    0x54, 0x4b, 0x6b, 0x06, 0xa9, 0xa6, 0xdc, 0xe9, 0xb7, 0x6b, 0xbe, 0x09, 0xe2, 0x68, 0xdc,
+    0x1e, 0xea, 0x46, 0x0d, 0x79, 0x6f, 0xc2, 0x69, 0xe7, 0xd1, 0xef, 0x75, 0xcf, 0x07, 0x5e,
+    0x37, 0xef, 0xb4, 0xeb, 0x82, 0xf1, 0x67, 0x8c, 0xa1, 0x38, 0x38, 0xfc, 0x70, 0x7f, 0x1a,
+    0xf4, 0x0f, 0x0e, 0xeb, 0x96, 0xda, 0xf6, 0x8f, 0x69, 0xab, 0x59, 0xb6, 0x62, 0x9d, 0x77,
+    0x63, 0xba, 0x9e, 0xea, 0x7d, 0xc1, 0xc8, 0xae, 0x03, 0xc5, 0x7f, 0xf1, 0x4e, 0xfc, 0x73,
+    0xd1, 0x35, 0x55, 0xc2, 0xdb, 0xea, 0xd0, 0x7d, 0x9e, 0x56, 0xe8, 0x0b, 0x7d, 0xdf, 0xfe,
+    0x22, 0xb3, 0x46, 0xd2, 0xe9, 0x23, 0xd4, 0x47, 0x14, 0x99, 0xa2, 0x8a, 0x0a, 0x0a, 0xe6,
+    0x3c, 0x7f, 0xe2, 0x45, 0xf0, 0xb7, 0x83, 0xef, 0x6f, 0x55, 0xc0, 0xba, 0x91, 0x7c, 0x9b,
+    0x71, 0xdf, 0x7b, 0x71, 0x9f, 0xc3, 0xad, 0x75, 0x18, 0xaf, 0x9d, 0xfe, 0x2b, 0xf8, 0x8c,
+    0x78, 0x8f, 0xc5, 0xcb, 0xa6, 0x5b, 0xc9, 0xba, 0xc7, 0x4d, 0xc8, 0x6c, 0x74, 0x69, 0x3b,
+    0x9f, 0xe9, 0x4e, 0x2a, 0xee, 0xc8, 0x89, 0xbb, 0x23, 0x89, 0xb1, 0x89, 0xa3, 0x83, 0x73,
+    0xe4, 0xbb, 0x9d, 0xcc, 0x4f, 0x5a, 0xd2, 0x87, 0x98, 0xcd, 0x40, 0x05, 0x4f, 0x17, 0x1c,
+    0x1e, 0xf5, 0xe8, 0xd3, 0x8f, 0x2a, 0xb1, 0xc9, 0x3d, 0x51, 0x09, 0x5f, 0x9b, 0x15, 0x22,
+    0xa6, 0x2a, 0x4d, 0x80, 0xb1, 0x34, 0xb8, 0xaa, 0xb1, 0x2e, 0x42, 0x2a, 0xd4, 0xaa, 0x9c,
+    0x50, 0x89, 0x9e, 0x4d, 0x4b, 0x8a, 0x76, 0x32, 0x93, 0x19, 0x8a, 0x5c, 0x53, 0x88, 0xc8,
+    0xa6, 0xd3, 0x12, 0x62, 0x1a, 0x6e, 0x33, 0x4a, 0x69, 0x73, 0xb4, 0x52, 0x02, 0x16, 0xc8,
+    0x34, 0x99, 0x66, 0xe2, 0xa4, 0x54, 0x32, 0xbf, 0x02, 0xb4, 0xad, 0xec, 0x54, 0x00, 0x48,
+    0xc9, 0xa0, 0x6e, 0x56, 0x32, 0xc5, 0xab, 0xb8, 0xce, 0x29, 0x8f, 0x6e, 0xc9, 0xd4, 0x1a,
+    0xe8, 0xfc, 0xa4, 0x51, 0x8c, 0x0a, 0x86, 0x58, 0x15, 0xfb, 0x51, 0x61, 0x73, 0xc9, 0x18,
+    0x08, 0x06, 0xf0, 0x0d, 0x6b, 0x43, 0x02, 0x32, 0xe7, 0x15, 0x52, 0xe6, 0xdf, 0xca, 0x39,
+    0x15, 0x3d, 0x9c, 0xbb, 0x97, 0x06, 0x92, 0x14, 0x9d, 0xf5, 0x2c, 0xf9, 0x51, 0x8e, 0xd4,
+    0xd6, 0x54, 0x03, 0x8a, 0x49, 0x64, 0x0b, 0x55, 0x5e, 0x62, 0x4f, 0x14, 0xc8, 0xf4, 0x2c,
+    0x12, 0x83, 0xd2, 0x93, 0x72, 0xfa, 0x8a, 0xa4, 0x64, 0x24, 0xd0, 0x18, 0x9e, 0xf4, 0x0e,
+    0xcc, 0xb9, 0x34, 0xad, 0x32, 0x05, 0x92, 0x56, 0x70, 0x3a, 0x06, 0x6c, 0x81, 0x54, 0x64,
+    0xb7, 0x56, 0xed, 0x52, 0x0c, 0xfa, 0xd2, 0x8a, 0x41, 0x76, 0x8a, 0x6d, 0x69, 0xe9, 0x40,
+    0x84, 0xaf, 0x6a, 0xbe, 0xab, 0xdc, 0xd3, 0xf6, 0x03, 0x4a, 0xc8, 0xae, 0x76, 0x50, 0x54,
+    0xa9, 0x55, 0x48, 0xab, 0x26, 0x2a, 0x4d, 0x98, 0xed, 0x4c, 0x4d, 0xb6, 0x30, 0x53, 0xbb,
+    0xd1, 0x8a, 0x4a, 0x00, 0x53, 0x8c, 0x54, 0x44, 0x53, 0xcd, 0x21, 0xa0, 0x08, 0xcf, 0x14,
+    0xc6, 0x38, 0xa7, 0x31, 0xa8, 0x24, 0x6e, 0xb5, 0x2c, 0x60, 0xcf, 0x55, 0xe4, 0x92, 0x91,
+    0xde, 0xab, 0xbb, 0xd4, 0xb6, 0x6b, 0x18, 0x04, 0x8f, 0x50, 0x33, 0x50, 0xcd, 0x51, 0x13,
+    0x9a, 0xc2, 0x52, 0x37, 0x4a, 0xc0, 0xc6, 0x98, 0x4d, 0x04, 0xd3, 0x49, 0xac, 0x5b, 0x18,
+    0x86, 0x92, 0x96, 0x92, 0xa4, 0x62, 0x52, 0x52, 0xd2, 0x1e, 0x94, 0x80, 0x28, 0xa4, 0xa3,
+    0x34, 0x00, 0xb4, 0x94, 0xb4, 0x50, 0x02, 0x52, 0x52, 0xd1, 0x40, 0x09, 0x45, 0x2d, 0x25,
+    0x00, 0x14, 0x98, 0xa5, 0xa2, 0x80, 0x13, 0x15, 0x32, 0x2e, 0x05, 0x31, 0x06, 0x4d, 0x4e,
+    0x16, 0xaa, 0x2a, 0xe0, 0x25, 0x14, 0xec, 0x01, 0x4d, 0x2d, 0x57, 0x64, 0x80, 0x29, 0x09,
+    0xa6, 0xe4, 0x9a, 0x5c, 0x52, 0xb8, 0x06, 0x69, 0x31, 0x4e, 0xc5, 0x2e, 0xda, 0x56, 0x01,
+    0xb4, 0x53, 0xf6, 0x51, 0xb6, 0xab, 0x94, 0x43, 0x28, 0xa7, 0x62, 0x92, 0x95, 0x80, 0x4a,
+    0x4a, 0x53, 0x45, 0x21, 0x8d, 0xa4, 0x34, 0xb4, 0xd3, 0x52, 0xc0, 0x4a, 0x42, 0x68, 0x34,
+    0x95, 0x20, 0x21, 0xa9, 0xdb, 0xee, 0x54, 0x06, 0xa7, 0x3f, 0x72, 0x9c, 0x40, 0xae, 0x7a,
+    0xd2, 0x52, 0xb7, 0xde, 0x34, 0x83, 0x93, 0x50, 0x01, 0x8a, 0x50, 0x29, 0xfb, 0x68, 0xc0,
+    0x15, 0x43, 0x1a, 0x4e, 0x70, 0x05, 0x58, 0x45, 0xda, 0xb8, 0xa8, 0xa2, 0x5c, 0x9d, 0xc7,
+    0xf0, 0xab, 0x03, 0x81, 0x55, 0x15, 0xd4, 0x43, 0x24, 0x6d, 0xab, 0x55, 0x09, 0xc9, 0xc9,
+    0xa9, 0x25, 0x6d, 0xcd, 0x8a, 0x60, 0x19, 0x35, 0x32, 0x77, 0x63, 0x40, 0x06, 0x69, 0x69,
+    0xdb, 0x71, 0x46, 0x29, 0x58, 0x06, 0xd1, 0x8a, 0x5c, 0x51, 0x40, 0x09, 0x8a, 0x28, 0xa2,
+    0x90, 0x09, 0x45, 0x2d, 0x26, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x01, 0x31, 0x45, 0x2d, 0x14,
+    0x00, 0x94, 0x52, 0xd2, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x04, 0x83,
+    0xa8, 0xab, 0xc8, 0x49, 0x84, 0xd5, 0x0a, 0xb6, 0x92, 0xfe, 0xeb, 0x15, 0xb4, 0x58, 0x8a,
+    0xce, 0x72, 0xc6, 0x9b, 0x8a, 0x79, 0x03, 0x71, 0x34, 0x54, 0x80, 0xd0, 0x29, 0x70, 0x29,
+    0x68, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x5d, 0xa6, 0x9d, 0xb4, 0x50, 0x03, 0x29,
+    0x40, 0x39, 0xe9, 0x4f, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x2f, 0x42, 0xec, 0xd1, 0x63,
+    0xb5, 0x44, 0xe0, 0xa8, 0x34, 0xfb, 0x57, 0x18, 0xda, 0x68, 0xb9, 0xc0, 0x15, 0xb3, 0xf8,
+    0x6e, 0x22, 0x9e, 0x79, 0xcd, 0x5f, 0xb7, 0x3b, 0xa2, 0xc5, 0x52, 0xc0, 0xab, 0x36, 0xad,
+    0xf3, 0x62, 0xa6, 0x0e, 0xcc, 0x18, 0x5d, 0x46, 0xb2, 0x45, 0x83, 0xd4, 0x74, 0x35, 0xdb,
+    0xfc, 0x32, 0xf8, 0xa1, 0x71, 0xe0, 0xdb, 0xa5, 0xd3, 0x35, 0x32, 0xf3, 0x68, 0xd2, 0x37,
+    0x4e, 0xad, 0x01, 0x3f, 0xc4, 0xbe, 0xde, 0xa2, 0xb8, 0xc9, 0xc0, 0x0a, 0x6a, 0xa1, 0x88,
+    0x4a, 0x30, 0x7a, 0xf6, 0x34, 0xaa, 0x46, 0xec, 0x71, 0x76, 0xd4, 0xfb, 0x12, 0x78, 0xec,
+    0xf5, 0xdd, 0x3a, 0x3d, 0x47, 0x4c, 0x9e, 0x39, 0xe3, 0x91, 0x77, 0x23, 0xc6, 0x72, 0x1c,
+    0x57, 0x3c, 0xf1, 0x95, 0x62, 0x31, 0x83, 0x5e, 0x4f, 0xf0, 0x43, 0xc5, 0x17, 0xba, 0x57,
+    0x8c, 0x63, 0xf0, 0xfc, 0x92, 0x3b, 0xd8, 0xdf, 0x86, 0x02, 0x3e, 0xa1, 0x24, 0x0a, 0x58,
+    0x30, 0xf4, 0xc8, 0x04, 0x1a, 0xf7, 0x8d, 0x76, 0xc9, 0x41, 0x5b, 0x84, 0x18, 0xdc, 0x70,
+    0xde, 0xe6, 0xb2, 0x5a, 0x68, 0x6f, 0xf1, 0x2b, 0x9c, 0xe8, 0xa7, 0x0a, 0x69, 0xe0, 0xd3,
+    0x65, 0x90, 0x43, 0x04, 0x92, 0xb7, 0x44, 0x52, 0xc7, 0xf0, 0x15, 0x44, 0x9e, 0x4f, 0xf1,
+    0x23, 0x55, 0x3a, 0x97, 0x88, 0xe1, 0xd3, 0x23, 0x7c, 0xc3, 0x66, 0x3e, 0x60, 0x0f, 0x1e,
+    0x63, 0x72, 0x7f, 0x21, 0xfc, 0xeb, 0x84, 0xd6, 0x35, 0x1c, 0xe6, 0xd2, 0x13, 0x84, 0x1f,
+    0x78, 0x8e, 0xfe, 0xd5, 0x7a, 0xe2, 0xe9, 0xee, 0x2f, 0x2e, 0xef, 0xe4, 0x24, 0xc9, 0x29,
+    0x79, 0x32, 0x7d, 0x58, 0xf1, 0xfa, 0x57, 0x33, 0x23, 0x6f, 0x91, 0x9b, 0xd4, 0xd3, 0x93,
+    0xb2, 0xb1, 0x96, 0xee, 0xe3, 0x68, 0xa2, 0x8a, 0xc8, 0x61, 0x45, 0x14, 0x50, 0x01, 0x53,
+    0xdb, 0x48, 0xb1, 0xbb, 0x6e, 0xe8, 0x54, 0x8a, 0x82, 0x8a, 0x00, 0xf6, 0xcf, 0x82, 0x1a,
+    0xe9, 0x96, 0xd6, 0xf7, 0x44, 0x95, 0xc9, 0xf2, 0x8f, 0x9d, 0x08, 0x3e, 0x87, 0x82, 0x3f,
+    0x3a, 0xf5, 0xea, 0xf9, 0xa7, 0xe1, 0x55, 0xeb, 0x5a, 0x78, 0xfe, 0xc5, 0x41, 0x20, 0x4e,
+    0x1e, 0x23, 0xf4, 0x23, 0x3f, 0xd2, 0xbe, 0x95, 0x06, 0xad, 0x6c, 0x69, 0x07, 0xa0, 0xfa,
+    0x51, 0x4d, 0x04, 0x53, 0xb8, 0xa6, 0x58, 0xa2, 0x9e, 0x9d, 0x69, 0xa2, 0x9c, 0xb4, 0x0c,
+    0x90, 0xf0, 0x2a, 0xb5, 0xed, 0xd4, 0x76, 0x56, 0x73, 0xdd, 0xce, 0xdb, 0x62, 0x86, 0x32,
+    0xec, 0x7d, 0x00, 0x19, 0xa9, 0xb3, 0x9a, 0xe0, 0xfe, 0x2f, 0x6b, 0x03, 0x4b, 0xf0, 0x2d,
+    0xc4, 0x2a, 0xd8, 0x96, 0xf1, 0x84, 0x0b, 0xeb, 0x8e, 0xa7, 0xf4, 0x1f, 0xad, 0x02, 0x6e,
+    0xc8, 0xf0, 0x8d, 0x53, 0xc4, 0xd3, 0xea, 0x3a, 0xbe, 0xa5, 0xa8, 0xb6, 0x7c, 0xeb, 0xa9,
+    0x0b, 0x2b, 0x7f, 0x75, 0x7b, 0x0f, 0xc0, 0x56, 0x01, 0x39, 0x39, 0x3d, 0x68, 0xa2, 0xa1,
+    0xb6, 0xcc, 0x02, 0x8a, 0x28, 0xa4, 0x04, 0x90, 0xc8, 0xd1, 0x4a, 0x19, 0x58, 0xa9, 0xf5,
+    0x15, 0xd3, 0x58, 0x5c, 0x1b, 0xbb, 0x66, 0x49, 0x39, 0x70, 0x30, 0x6b, 0x95, 0xad, 0x9d,
+    0x2a, 0xe0, 0x2b, 0xa3, 0x7a, 0xfc, 0xad, 0xf5, 0xed, 0x5a, 0x53, 0x76, 0x62, 0x67, 0xac,
+    0xfc, 0x17, 0xd6, 0xcd, 0xb6, 0xa1, 0x7d, 0xe1, 0xe9, 0x5f, 0xe4, 0x94, 0x7d, 0xa6, 0xdc,
+    0x1e, 0xc4, 0x70, 0xe0, 0x7e, 0x87, 0xf0, 0xae, 0x83, 0xe3, 0x84, 0x0e, 0x3c, 0x2d, 0xa5,
+    0x6b, 0x11, 0x7f, 0xae, 0xd3, 0xaf, 0x55, 0x94, 0xe3, 0xd7, 0xff, 0x00, 0xae, 0xa2, 0xbc,
+    0x8f, 0x4a, 0xd4, 0xce, 0x87, 0xe2, 0xad, 0x2f, 0x54, 0x53, 0x85, 0x86, 0xe1, 0x43, 0xff,
+    0x00, 0xb8, 0xdc, 0x1f, 0xd2, 0xbd, 0xfb, 0xc7, 0xf6, 0x47, 0x57, 0xf8, 0x7d, 0xab, 0x5b,
+    0xa6, 0x18, 0x9b, 0x73, 0x2a, 0x1f, 0xf7, 0x7e, 0x6c, 0xfe, 0x42, 0x9b, 0x5a, 0x9a, 0x45,
+    0xde, 0x2d, 0x1b, 0x7a, 0x65, 0xe2, 0x6a, 0x5a, 0x5d, 0xa5, 0xec, 0x6c, 0x19, 0x27, 0x85,
+    0x64, 0x04, 0x74, 0xe4, 0x66, 0xae, 0x57, 0x05, 0xf0, 0x83, 0x58, 0x5d, 0x57, 0xc0, 0x16,
+    0x91, 0x6e, 0xcc, 0xb6, 0x4c, 0x6d, 0x9c, 0x63, 0x18, 0xc7, 0x2b, 0xf5, 0xf9, 0x48, 0xae,
+    0x93, 0xc4, 0xfe, 0x27, 0xd3, 0xbc, 0x27, 0xa3, 0xc9, 0xa8, 0x6a, 0x12, 0x01, 0x81, 0x88,
+    0xa2, 0x07, 0xe6, 0x91, 0xbb, 0x00, 0x2a, 0x4d, 0x13, 0xd2, 0xe6, 0x17, 0xc4, 0xcf, 0x1a,
+    0x27, 0x84, 0xfc, 0x3e, 0xd1, 0xc0, 0xe0, 0xea, 0x57, 0x60, 0xc7, 0x6e, 0x9d, 0xd4, 0x77,
+    0x6f, 0xc3, 0xf9, 0xd7, 0xcf, 0xb6, 0x90, 0x34, 0x71, 0x96, 0x90, 0x96, 0x96, 0x43, 0xb9,
+    0xd8, 0xf5, 0x24, 0xd5, 0xcb, 0xfd, 0x52, 0xfb, 0xc5, 0x7a, 0xe4, 0xda, 0xde, 0xa6, 0xd9,
+    0x67, 0x38, 0x8a, 0x3f, 0xe1, 0x45, 0xec, 0x07, 0xb5, 0x3c, 0x25, 0x76, 0x50, 0xa7, 0xf6,
+    0x99, 0xcb, 0x52, 0xa5, 0xd9, 0x1a, 0xa7, 0x42, 0x6a, 0xdc, 0x12, 0xa4, 0x50, 0x4d, 0x1b,
+    0x42, 0x1c, 0xc8, 0x30, 0xac, 0x4f, 0xdd, 0xa8, 0xc2, 0xf6, 0xa9, 0x56, 0x3f, 0x5a, 0xe9,
+    0x48, 0xe7, 0x94, 0x88, 0xd5, 0x72, 0x40, 0xa7, 0x2c, 0x79, 0x3e, 0xd5, 0x30, 0x18, 0x14,
+    0x62, 0x9d, 0x8c, 0xf9, 0x86, 0x81, 0x46, 0x29, 0xf8, 0xe6, 0x97, 0x68, 0xa7, 0xb1, 0x2d,
+    0x91, 0xe2, 0x90, 0x8c, 0xd3, 0xc8, 0xc5, 0x21, 0xa0, 0x13, 0x23, 0x5e, 0xa4, 0xd3, 0x70,
+    0x5d, 0xa9, 0xcd, 0xde, 0xac, 0xdb, 0x44, 0x0f, 0x26, 0x91, 0x4d, 0xdb, 0x51, 0xf6, 0xf0,
+    0x04, 0x19, 0x3d, 0x6b, 0x46, 0x33, 0x85, 0xaa, 0x99, 0xe4, 0x28, 0xab, 0x48, 0xbf, 0x2d,
+    0x04, 0x45, 0xea, 0x07, 0x9a, 0x69, 0x15, 0x21, 0x15, 0x13, 0x9c, 0x50, 0x53, 0x33, 0xef,
+    0xc7, 0xee, 0xea, 0xa5, 0x93, 0x85, 0x7c, 0x13, 0x52, 0x5f, 0xcd, 0x93, 0xb4, 0x56, 0x7a,
+    0x33, 0x2b, 0x64, 0x54, 0xb7, 0xa9, 0x51, 0x8d, 0xe2, 0x6c, 0x5c, 0x2e, 0x57, 0x22, 0xa8,
+    0xb0, 0x35, 0x6a, 0x19, 0xd5, 0xd3, 0x6b, 0x1e, 0x69, 0x24, 0x8c, 0x03, 0x91, 0x4c, 0xcd,
+    0x3e, 0x57, 0xa9, 0x50, 0x29, 0x3d, 0xe9, 0xea, 0xb5, 0x26, 0xce, 0x69, 0xc1, 0x68, 0x1b,
+    0x90, 0xc0, 0x29, 0xc1, 0x4e, 0x6a, 0x45, 0x5a, 0x78, 0x5a, 0x05, 0xb9, 0x18, 0x5a, 0x78,
+    0xe3, 0x14, 0xf0, 0xb4, 0xb8, 0xa0, 0x68, 0x41, 0x4b, 0x81, 0x4b, 0x8c, 0x0a, 0x4a, 0x63,
+    0x23, 0x65, 0xa8, 0xc8, 0x22, 0xa6, 0x39, 0xa6, 0x37, 0x02, 0x90, 0x10, 0x9e, 0x06, 0x6a,
+    0x36, 0x6a, 0x7b, 0x9a, 0xad, 0x23, 0xd2, 0x01, 0x24, 0x7c, 0x74, 0xaa, 0xb2, 0x3d, 0x2c,
+    0x8f, 0x55, 0x9d, 0xeb, 0x39, 0x33, 0x68, 0x40, 0x47, 0x7a, 0x85, 0x9a, 0x86, 0x6a, 0x89,
+    0x8e, 0x6b, 0x09, 0x48, 0xdd, 0x21, 0x0b, 0x66, 0x9a, 0x4d, 0x14, 0xd3, 0x59, 0x36, 0x31,
+    0x09, 0xa4, 0xa7, 0x62, 0x93, 0x15, 0x23, 0x12, 0x8c, 0x53, 0xb1, 0x4b, 0xb6, 0x8b, 0x00,
+    0xcc, 0x52, 0x11, 0x52, 0x6d, 0xa4, 0xc5, 0x16, 0x02, 0x22, 0x31, 0x49, 0x52, 0x95, 0xa6,
+    0x11, 0x8a, 0x4d, 0x00, 0xca, 0x5a, 0x29, 0x71, 0x48, 0x02, 0x8a, 0x28, 0xa6, 0x02, 0x51,
+    0x45, 0x18, 0xa4, 0x02, 0x62, 0x97, 0x14, 0xb8, 0xa5, 0xc5, 0x00, 0x2a, 0x70, 0x6a, 0x6c,
+    0x8c, 0x54, 0x21, 0x69, 0xc0, 0x55, 0xc5, 0xd8, 0x05, 0x27, 0x34, 0x98, 0xa7, 0x05, 0xa9,
+    0x52, 0x2c, 0xf5, 0xaa, 0x51, 0x6c, 0x57, 0x22, 0x0b, 0x9a, 0x90, 0x47, 0x53, 0x04, 0x03,
+    0xb5, 0x2e, 0x2b, 0x55, 0x4d, 0x22, 0x5c, 0x88, 0xf6, 0x0a, 0x4d, 0xb8, 0xa9, 0x31, 0x4d,
+    0x6a, 0x76, 0x04, 0xc8, 0xcd, 0x21, 0xa5, 0x6e, 0xb4, 0xda, 0x86, 0x50, 0x53, 0x7a, 0x52,
+    0x9a, 0x69, 0x35, 0x0c, 0x04, 0x34, 0x86, 0x96, 0x93, 0x15, 0x20, 0x34, 0x9a, 0x4a, 0x76,
+    0xda, 0x36, 0xd4, 0xd8, 0x06, 0x62, 0x8c, 0x53, 0xf6, 0xd2, 0xe2, 0x95, 0x86, 0x44, 0xc3,
+    0x8a, 0x90, 0x73, 0x1f, 0xe1, 0x4d, 0x90, 0x7c, 0xb4, 0xa9, 0xf7, 0x0f, 0xd2, 0x9a, 0xd1,
+    0x81, 0x03, 0x7d, 0xea, 0x13, 0xef, 0x0a, 0x57, 0xeb, 0x48, 0xbf, 0x7c, 0x7d, 0x6a, 0x3a,
+    0x8c, 0x9f, 0x14, 0xc7, 0xe4, 0x85, 0x1d, 0xea, 0x5a, 0x8e, 0x3f, 0x99, 0xcb, 0x55, 0x34,
+    0x22, 0x55, 0x18, 0xc0, 0x14, 0xb2, 0xb6, 0xd4, 0xa7, 0x28, 0xef, 0x55, 0xe6, 0x7d, 0xcd,
+    0x8a, 0xa7, 0xa2, 0x02, 0x2e, 0xb4, 0xf8, 0xc7, 0x7a, 0x68, 0x19, 0x38, 0xa9, 0xf6, 0xe0,
+    0x62, 0xa2, 0x28, 0x62, 0x52, 0x52, 0xe2, 0x92, 0xa8, 0x43, 0x69, 0x0d, 0x38, 0xd3, 0x6a,
+    0x58, 0xc4, 0xa2, 0x8a, 0x29, 0x00, 0x94, 0x52, 0xd2, 0x52, 0x00, 0xa4, 0xa5, 0xa2, 0x80,
+    0x12, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x04, 0xa2, 0x96, 0x92, 0x80, 0x0a, 0x28,
+    0xa2, 0x80, 0x26, 0xa2, 0x8a, 0x2b, 0x41, 0x05, 0x14, 0xa1, 0x49, 0xa5, 0x0b, 0xeb, 0x40,
+    0x0d, 0xa5, 0x0a, 0x69, 0xf8, 0xa2, 0x80, 0x10, 0x28, 0x14, 0xb4, 0x52, 0xe3, 0x11, 0xc6,
+    0x7d, 0x57, 0x3f, 0xad, 0x00, 0x25, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x05, 0x28,
+    0x34, 0x62, 0x8c, 0x53, 0x01, 0xe8, 0xc5, 0x5b, 0x34, 0xe9, 0x1c, 0xb9, 0xa6, 0x0a, 0x5a,
+    0x7d, 0x04, 0x26, 0x2a, 0x58, 0x0e, 0xd9, 0x2a, 0x3a, 0x7c, 0x7c, 0x38, 0xa6, 0xb7, 0x02,
+    0xd4, 0xc8, 0x59, 0x73, 0x51, 0xa4, 0x7b, 0x50, 0x93, 0x5a, 0x1e, 0x58, 0x68, 0x33, 0x54,
+    0x64, 0x70, 0x17, 0x15, 0xb4, 0xa3, 0x6d, 0x44, 0x99, 0xbf, 0xf0, 0xd6, 0x47, 0x4f, 0x8a,
+    0x3a, 0x01, 0x8c, 0x65, 0xbc, 0xf2, 0x3f, 0x02, 0xac, 0x0f, 0xe9, 0x9a, 0xfa, 0xa3, 0x58,
+    0x01, 0xb4, 0xe7, 0xf6, 0x20, 0xfe, 0xb5, 0xf2, 0xc7, 0xc3, 0x01, 0x9f, 0x8a, 0x7a, 0x1f,
+    0xb4, 0x8d, 0xff, 0x00, 0xa0, 0x35, 0x7d, 0x4f, 0xaa, 0xff, 0x00, 0xc8, 0x3e, 0x41, 0xf4,
+    0xfe, 0x75, 0xc9, 0x2d, 0xce, 0x8a, 0x7f, 0x0b, 0x39, 0x02, 0x32, 0x48, 0xac, 0x1f, 0x19,
+    0x5e, 0xfd, 0x83, 0xc2, 0x3a, 0x8c, 0xb9, 0xc3, 0x18, 0x8a, 0x2f, 0xd5, 0xb8, 0xfe, 0xb5,
+    0xb7, 0xbb, 0x2e, 0xde, 0x95, 0xc4, 0x7c, 0x55, 0xb9, 0x58, 0xbc, 0x28, 0x91, 0x67, 0xe6,
+    0x96, 0xe5, 0x00, 0xfc, 0x39, 0xab, 0x25, 0xec, 0x79, 0x25, 0xec, 0xa2, 0x1b, 0x77, 0x4c,
+    0x8c, 0xe0, 0x28, 0x1f, 0x85, 0x61, 0xd5, 0xed, 0x51, 0xb7, 0x5c, 0xfe, 0x15, 0x46, 0xa2,
+    0x4e, 0xec, 0x84, 0x14, 0x51, 0x45, 0x48, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40,
+    0x1d, 0x2f, 0xc3, 0xf7, 0xd9, 0xe3, 0xcd, 0x1d, 0x8f, 0xfc, 0xf7, 0xc7, 0xe6, 0xa6, 0xbe,
+    0xa4, 0x15, 0xf2, 0x97, 0x83, 0x64, 0x11, 0x78, 0xcf, 0x48, 0x72, 0x78, 0x17, 0x49, 0xfc,
+    0xeb, 0xea, 0xc0, 0x6a, 0xd6, 0xc5, 0xc0, 0x75, 0x2d, 0x20, 0xa5, 0xa6, 0x58, 0xb4, 0xf0,
+    0x7f, 0x0a, 0x68, 0xa7, 0x50, 0x34, 0x2f, 0xe7, 0x5e, 0x41, 0xf1, 0xe4, 0xb7, 0xf6, 0x6e,
+    0x8e, 0x37, 0x0d, 0xbe, 0x74, 0x9c, 0x7b, 0xe0, 0x57, 0xaf, 0x8a, 0xf1, 0x6f, 0x8f, 0x53,
+    0x7e, 0xf3, 0x47, 0x87, 0x3d, 0x9d, 0xff, 0x00, 0x90, 0xa0, 0x99, 0xec, 0x78, 0xc5, 0x14,
+    0x51, 0x59, 0x99, 0x05, 0x14, 0x51, 0x40, 0x05, 0x5a, 0xb1, 0x93, 0x6c, 0x85, 0x7d, 0x46,
+    0x47, 0xd4, 0x55, 0x5a, 0x55, 0x62, 0x8c, 0x18, 0x75, 0x14, 0xd0, 0x1b, 0xf7, 0xff, 0x00,
+    0xbd, 0xb4, 0xcf, 0x72, 0xb9, 0xfe, 0xb5, 0xf4, 0xb7, 0x84, 0xee, 0x97, 0x5e, 0xf0, 0x1e,
+    0x9b, 0x24, 0xdc, 0xad, 0xc5, 0x98, 0x8d, 0xc7, 0xe1, 0xb4, 0xff, 0x00, 0x2a, 0xf9, 0xa0,
+    0x1d, 0xf6, 0x29, 0xe9, 0x8a, 0xf7, 0xdf, 0x84, 0x17, 0x06, 0xe3, 0xe1, 0xed, 0x9a, 0x75,
+    0x31, 0x4b, 0x24, 0x5f, 0x93, 0x7f, 0xf5, 0xeb, 0x46, 0x55, 0x3d, 0xcf, 0x3d, 0xf8, 0x6d,
+    0xe3, 0x0d, 0x3b, 0xc0, 0xf0, 0x78, 0x8e, 0x1d, 0x51, 0x8a, 0xec, 0x98, 0x18, 0x61, 0x51,
+    0x97, 0x91, 0x86, 0x41, 0x50, 0x3f, 0x01, 0xcd, 0x72, 0x5a, 0xbe, 0xab, 0xa9, 0x78, 0xdb,
+    0x5b, 0x97, 0x54, 0xd4, 0xa4, 0x71, 0x6f, 0xb8, 0xf9, 0x30, 0x93, 0xc2, 0x2f, 0x65, 0x1f,
+    0xe3, 0x52, 0xf8, 0xbf, 0x49, 0x16, 0x7f, 0x12, 0xf5, 0x6b, 0x1b, 0x85, 0xf9, 0x7e, 0xd2,
+    0xf2, 0x28, 0xf5, 0x0d, 0xf3, 0x0f, 0xd0, 0xd4, 0xc0, 0x2a, 0x28, 0x00, 0x00, 0x07, 0x00,
+    0x56, 0xd4, 0x69, 0x29, 0xea, 0xf6, 0x31, 0xa9, 0x51, 0xc7, 0xdd, 0x23, 0x11, 0x85, 0x50,
+    0xaa, 0x00, 0x00, 0x60, 0x01, 0x52, 0x2a, 0x63, 0x93, 0x41, 0x6f, 0x4a, 0x41, 0x96, 0x35,
+    0xdc, 0x73, 0xea, 0x3f, 0x20, 0x74, 0xa7, 0x8c, 0x9a, 0x40, 0x98, 0xed, 0x52, 0xaa, 0xd3,
+    0x33, 0x93, 0x1a, 0x16, 0x97, 0x6d, 0x3c, 0x0a, 0x5c, 0x50, 0x67, 0xcc, 0x31, 0x45, 0x2d,
+    0x2e, 0x29, 0x29, 0x05, 0xee, 0x35, 0xbd, 0x29, 0x86, 0x9c, 0x41, 0xef, 0x4c, 0xa6, 0x52,
+    0x1a, 0x06, 0x5a, 0xb4, 0x22, 0x18, 0x4a, 0xa4, 0xa3, 0xe6, 0x15, 0x79, 0x38, 0x41, 0x48,
+    0x25, 0xb8, 0xb1, 0x8c, 0xbd, 0x5d, 0x1f, 0x2a, 0xd5, 0x34, 0x70, 0x1b, 0x3e, 0x94, 0xd9,
+    0xee, 0xf0, 0x30, 0xb4, 0x0a, 0x2e, 0xc4, 0xf2, 0xcc, 0x17, 0xbf, 0x35, 0x4a, 0x5b, 0x9e,
+    0x0f, 0x35, 0x56, 0x49, 0xcb, 0x1e, 0xb5, 0x01, 0x62, 0x78, 0xcd, 0x05, 0x28, 0xb7, 0xb9,
+    0x14, 0xa4, 0xbb, 0x9a, 0x4d, 0xb9, 0xe0, 0x53, 0xf6, 0xe4, 0xd4, 0x89, 0x1f, 0x35, 0x26,
+    0xb7, 0xb2, 0x18, 0x91, 0xb2, 0x9c, 0xe7, 0x15, 0x60, 0x17, 0xc8, 0xad, 0xcd, 0x26, 0xd2,
+    0xce, 0x4b, 0x46, 0x33, 0x04, 0x2f, 0x9e, 0x77, 0x1e, 0x82, 0xb3, 0xda, 0x15, 0x0e, 0xe1,
+    0x79, 0x5c, 0xfc, 0xa7, 0xda, 0x99, 0x9c, 0xb6, 0xb9, 0x5c, 0x03, 0xd6, 0x9c, 0x16, 0xa5,
+    0xd9, 0x81, 0x4a, 0x16, 0x99, 0x98, 0xc0, 0xb4, 0xe0, 0x29, 0xe1, 0x69, 0x71, 0x4a, 0xc5,
+    0x58, 0x68, 0x06, 0x8e, 0xf4, 0xb8, 0xa3, 0x1c, 0xd3, 0xb0, 0xc4, 0xa0, 0x8c, 0xd0, 0x4e,
+    0x29, 0xa5, 0xe8, 0x01, 0x1b, 0x81, 0x50, 0x3b, 0x53, 0x9d, 0xea, 0xb4, 0x8f, 0xd6, 0x90,
+    0x0c, 0x95, 0xf0, 0x38, 0xaa, 0x72, 0x49, 0x4e, 0x96, 0x4f, 0x7a, 0xa8, 0xef, 0x9a, 0xce,
+    0x52, 0x36, 0x84, 0x01, 0xde, 0xa1, 0x63, 0x43, 0x1a, 0x63, 0x1c, 0xd6, 0x12, 0x91, 0xba,
+    0x43, 0x58, 0xd4, 0x75, 0x32, 0xc5, 0x23, 0x82, 0x55, 0x49, 0x02, 0xa2, 0x23, 0x15, 0x9b,
+    0x4c, 0xa1, 0xa7, 0xad, 0x36, 0x9e, 0x69, 0xb5, 0x00, 0x26, 0x29, 0xd8, 0xa4, 0xa4, 0xa0,
+    0x07, 0x8a, 0x70, 0x50, 0x6a, 0x2c, 0x9a, 0x50, 0xf8, 0xa6, 0x98, 0x12, 0x15, 0xa6, 0x91,
+    0x4a, 0x24, 0xa5, 0x2c, 0x0d, 0x56, 0x8c, 0x08, 0xe9, 0xac, 0x33, 0x4f, 0x34, 0x86, 0xa5,
+    0x81, 0x16, 0x31, 0x45, 0x38, 0x8a, 0x6d, 0x40, 0xc4, 0xa5, 0xa2, 0x94, 0x0a, 0x00, 0x6d,
+    0x2e, 0x29, 0xe1, 0x69, 0xc1, 0x69, 0xd8, 0x08, 0xc2, 0xd3, 0xc2, 0xd3, 0x82, 0xd3, 0x82,
+    0xd5, 0x28, 0x88, 0x66, 0x29, 0xc1, 0x73, 0x4e, 0x0b, 0x56, 0x22, 0x8b, 0xbd, 0x69, 0x18,
+    0x5c, 0x4d, 0xd8, 0x62, 0x45, 0x8e, 0x4d, 0x4a, 0x17, 0x14, 0xfd, 0xb4, 0x62, 0xba, 0x14,
+    0x6c, 0x64, 0xe5, 0x71, 0x98, 0xa3, 0x14, 0xe2, 0x29, 0xa4, 0xd0, 0xc0, 0x42, 0x31, 0xcd,
+    0x31, 0x86, 0x6a, 0x64, 0x42, 0xc6, 0xb5, 0x2c, 0x7c, 0x3d, 0xa9, 0xea, 0x50, 0xb4, 0xb6,
+    0x5a, 0x7d, 0xcd, 0xc4, 0x6a, 0x70, 0x5a, 0x28, 0xcb, 0x0c, 0xfa, 0x71, 0x4b, 0x96, 0xe3,
+    0x57, 0xbd, 0x96, 0xa6, 0x09, 0x5a, 0x61, 0xe2, 0xaf, 0x5c, 0xdb, 0xbc, 0x32, 0x34, 0x72,
+    0x23, 0x23, 0xa9, 0x20, 0xab, 0x0c, 0x10, 0x7d, 0x0d, 0x53, 0x65, 0xac, 0xe5, 0x1b, 0x16,
+    0x9d, 0xc8, 0xfa, 0xd2, 0x11, 0x4f, 0xdb, 0x46, 0xda, 0xca, 0xc5, 0x11, 0xe2, 0x8c, 0x53,
+    0xf6, 0xd1, 0x8f, 0x6a, 0x5c, 0xa0, 0x37, 0x14, 0x98, 0xa7, 0xd1, 0x8a, 0x2c, 0x03, 0x76,
+    0xd2, 0x62, 0x9f, 0x8a, 0x08, 0xa2, 0xc0, 0x43, 0x20, 0xf9, 0x0d, 0x22, 0x7d, 0xdf, 0xc2,
+    0xa4, 0x90, 0x7c, 0x86, 0xa3, 0x4e, 0x95, 0x0f, 0x71, 0x90, 0xbd, 0x22, 0xfd, 0xe1, 0xf5,
+    0xa7, 0x30, 0xe7, 0x1e, 0xf4, 0xde, 0x8d, 0x59, 0x8c, 0x9e, 0x43, 0x85, 0xfa, 0xd1, 0x18,
+    0xc2, 0x81, 0xeb, 0x51, 0x31, 0xdc, 0xc0, 0x55, 0x84, 0xe4, 0xd5, 0xad, 0x58, 0x87, 0x3b,
+    0x6c, 0x4a, 0xa9, 0xd7, 0x9a, 0x9a, 0xe1, 0xb9, 0x02, 0xa1, 0x14, 0xa4, 0xf5, 0x02, 0x58,
+    0x57, 0x24, 0x9a, 0x90, 0xd2, 0x2f, 0xc8, 0x80, 0x52, 0x13, 0x9a, 0xa5, 0xa2, 0x00, 0x26,
+    0x98, 0x69, 0x69, 0x0d, 0x4b, 0x60, 0x14, 0x86, 0x8a, 0x29, 0x00, 0x94, 0x94, 0xea, 0x43,
+    0x40, 0xc4, 0xa4, 0xa5, 0xa2, 0x90, 0x09, 0x45, 0x14, 0x50, 0x01, 0x49, 0x4b, 0x49, 0x48,
+    0x02, 0x8a, 0x28, 0xa0, 0x02, 0x92, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x02, 0x50, 0x3a,
+    0x54, 0x80, 0x01, 0x4d, 0x1c, 0x1c, 0xd3, 0x81, 0x24, 0xf4, 0xad, 0x04, 0x2d, 0x14, 0x51,
+    0x40, 0x05, 0x14, 0x51, 0x8a, 0x00, 0x0f, 0x00, 0x9a, 0x91, 0xc6, 0x21, 0x84, 0xfa, 0xad,
+    0x46, 0xc3, 0xe5, 0x3f, 0x4a, 0xb5, 0x32, 0x6d, 0xb4, 0xb4, 0x6f, 0xef, 0x21, 0x35, 0x49,
+    0x68, 0xc0, 0xab, 0x8a, 0x5c, 0x53, 0xb1, 0x46, 0x29, 0x58, 0x04, 0xc5, 0x18, 0xa7, 0x51,
+    0x4c, 0x04, 0xc5, 0x18, 0xa5, 0xc5, 0x2e, 0x28, 0xb0, 0x84, 0xa5, 0x14, 0x52, 0xe2, 0x98,
+    0x09, 0x4e, 0x5c, 0x82, 0x0d, 0x14, 0x53, 0xb0, 0x1a, 0xf0, 0x9d, 0xd6, 0xd8, 0xac, 0xd9,
+    0x94, 0x87, 0x26, 0xae, 0x5a, 0xc9, 0xfb, 0xb2, 0x2a, 0xb5, 0xc1, 0xc3, 0x9a, 0xda, 0x6e,
+    0xf1, 0x44, 0xad, 0xce, 0x8b, 0xe1, 0x6f, 0xfc, 0x95, 0x3d, 0x17, 0xfd, 0xf6, 0xff, 0x00,
+    0xd0, 0x1a, 0xbe, 0xa4, 0xd5, 0x8e, 0x34, 0xf7, 0x3e, 0xe2, 0xbe, 0x5d, 0xf8, 0x56, 0x33,
+    0xf1, 0x4b, 0x47, 0x3e, 0x8c, 0xdf, 0xfa, 0x01, 0xaf, 0xa8, 0xb5, 0x81, 0xff, 0x00, 0x12,
+    0xd9, 0x4f, 0xa7, 0x35, 0xc8, 0xf7, 0x3a, 0x69, 0xfc, 0x2c, 0xe3, 0x01, 0xea, 0x7d, 0x6b,
+    0xcf, 0x3e, 0x2e, 0xe4, 0xe8, 0x96, 0x07, 0xb0, 0xb9, 0xfe, 0x95, 0xe8, 0x20, 0xfc, 0xa2,
+    0xbc, 0xf3, 0xe2, 0xe9, 0x61, 0xa0, 0xd9, 0x91, 0xd0, 0x5c, 0x73, 0xf9, 0x55, 0x11, 0x2d,
+    0x8f, 0x23, 0xd4, 0x4f, 0xfa, 0x59, 0xfa, 0x0a, 0xa9, 0x52, 0x4f, 0x27, 0x9b, 0x29, 0x7f,
+    0x5a, 0x8e, 0xb3, 0x7b, 0x92, 0x14, 0x51, 0x45, 0x20, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x28,
+    0xa2, 0x80, 0x34, 0xfc, 0x38, 0x09, 0xf1, 0x2e, 0x9b, 0xb7, 0xaf, 0xda, 0x50, 0x8f, 0xcc,
+    0x57, 0xd6, 0x8b, 0xd0, 0x57, 0xca, 0xde, 0x0e, 0xb7, 0x69, 0xbc, 0x5d, 0xa4, 0x80, 0x32,
+    0x1a, 0xe1, 0x7f, 0x4a, 0xfa, 0x94, 0x12, 0x3d, 0x6a, 0xe3, 0xb1, 0x70, 0x26, 0xa5, 0x06,
+    0xa3, 0x0c, 0x69, 0x77, 0xfb, 0x53, 0x34, 0x24, 0x06, 0x9c, 0x0d, 0x30, 0x38, 0xa7, 0x02,
+    0x28, 0x10, 0xfc, 0xd7, 0x89, 0x7c, 0x79, 0x8c, 0xfd, 0xaf, 0x47, 0x97, 0xb7, 0x96, 0xeb,
+    0xfa, 0x8a, 0xf6, 0xbc, 0x8a, 0xf2, 0x5f, 0x8e, 0xd6, 0xe5, 0xf4, 0x7d, 0x2e, 0xe0, 0x2f,
+    0x09, 0x3b, 0x29, 0x3f, 0x51, 0xff, 0x00, 0xd6, 0xa1, 0xec, 0x29, 0xec, 0x78, 0x65, 0x14,
+    0x51, 0x59, 0x99, 0x05, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51, 0x40, 0x1b, 0x16, 0xaf, 0xba,
+    0xc7, 0x19, 0xe9, 0x5e, 0xeb, 0xf0, 0x3a, 0x4d, 0xde, 0x14, 0x9e, 0x2c, 0xfd, 0xdb, 0xd7,
+    0x03, 0xf1, 0xc5, 0x78, 0x0d, 0x93, 0x11, 0x6b, 0x27, 0xd4, 0x57, 0xbb, 0x7c, 0x07, 0x3b,
+    0xb4, 0x2b, 0xc1, 0xdb, 0xed, 0x99, 0xfd, 0x2b, 0x44, 0xf4, 0x1c, 0x3e, 0x23, 0x8d, 0xf8,
+    0xc3, 0x01, 0xb7, 0xf8, 0xb2, 0xf2, 0x63, 0xfd, 0x7c, 0x30, 0xb0, 0xfc, 0x17, 0x6f, 0xf4,
+    0xac, 0x10, 0x09, 0xae, 0xcb, 0xe3, 0x84, 0x20, 0xfc, 0x4a, 0xd2, 0xf1, 0xd5, 0xac, 0x11,
+    0x8f, 0xe0, 0xef, 0xfe, 0x15, 0xc9, 0x2a, 0xd7, 0x66, 0x17, 0xe1, 0x66, 0x18, 0x8d, 0x24,
+    0x20, 0x5a, 0x91, 0x17, 0xda, 0x94, 0x26, 0x7b, 0x54, 0xcb, 0x19, 0xae, 0xa3, 0x95, 0xc8,
+    0x68, 0x5c, 0xd3, 0xc0, 0xc0, 0xa7, 0x84, 0xa7, 0xec, 0xc5, 0x06, 0x4d, 0xdc, 0x87, 0x14,
+    0xb8, 0xe2, 0xa5, 0xd9, 0x41, 0x4a, 0x04, 0x43, 0x48, 0xd5, 0x29, 0x4c, 0xfd, 0x69, 0xa5,
+    0x47, 0x4a, 0x00, 0x85, 0xba, 0x53, 0x2a, 0x66, 0x00, 0x54, 0x2d, 0xed, 0x41, 0x71, 0x62,
+    0xa7, 0xdf, 0x19, 0xab, 0x05, 0xbe, 0x5c, 0x66, 0xaa, 0x52, 0xef, 0x3e, 0xb4, 0x0d, 0xc6,
+    0xe3, 0xde, 0x4c, 0x77, 0xaa, 0xec, 0xc5, 0xba, 0x54, 0xc9, 0x03, 0xcc, 0x7a, 0x56, 0x8d,
+    0xbe, 0x96, 0x5b, 0x04, 0x8a, 0x43, 0x56, 0x5b, 0x18, 0xeb, 0x0b, 0xb1, 0xe0, 0x54, 0xc9,
+    0x63, 0x23, 0x73, 0x8a, 0xe8, 0xa3, 0xd3, 0xe3, 0x41, 0xc8, 0xa9, 0x7c, 0xb8, 0xd4, 0x60,
+    0x0a, 0x2c, 0x69, 0x69, 0x33, 0x97, 0x6b, 0x56, 0x8c, 0xf2, 0x2a, 0x58, 0xa3, 0x19, 0xe6,
+    0xb6, 0xee, 0x61, 0x46, 0x42, 0x40, 0x15, 0x99, 0xb7, 0x6b, 0x53, 0xb1, 0x94, 0xaf, 0xb3,
+    0x2c, 0xc7, 0x6d, 0x95, 0xc8, 0xa7, 0x7d, 0x9b, 0x15, 0x25, 0xbb, 0x7c, 0xb8, 0xa5, 0x67,
+    0x39, 0xc5, 0x05, 0x24, 0xac, 0x42, 0x6d, 0xc0, 0xed, 0x4d, 0xf2, 0xc0, 0xed, 0x53, 0x6f,
+    0x34, 0xda, 0x02, 0xc8, 0x88, 0xc7, 0xed, 0x48, 0x63, 0x15, 0x63, 0x23, 0x14, 0xd2, 0xc2,
+    0x81, 0xd8, 0xae, 0x52, 0x98, 0xc0, 0xd5, 0x86, 0x20, 0x8e, 0x9c, 0xd4, 0x4e, 0x46, 0x29,
+    0x09, 0xa2, 0xb3, 0x9e, 0x2a, 0x07, 0x6c, 0x75, 0xa9, 0x9c, 0x8c, 0x9a, 0xad, 0x25, 0x22,
+    0x59, 0x14, 0x92, 0x60, 0x55, 0x59, 0x65, 0xcd, 0x2c, 0xad, 0x82, 0x73, 0x55, 0x1d, 0xf3,
+    0x51, 0x26, 0x6f, 0x08, 0x0d, 0x91, 0xf3, 0x50, 0xb1, 0xa7, 0x13, 0x93, 0x4c, 0x22, 0xb0,
+    0x93, 0x37, 0x48, 0x61, 0x3c, 0xd3, 0x4f, 0x5a, 0x71, 0xa6, 0x9e, 0x95, 0x9b, 0x28, 0xb3,
+    0x6d, 0x76, 0x20, 0x8c, 0xa1, 0x5c, 0xf3, 0x91, 0x55, 0x5d, 0x8b, 0x33, 0x31, 0xee, 0x73,
+    0x45, 0x27, 0x5a, 0x6e, 0x4d, 0xab, 0x09, 0x45, 0x27, 0x71, 0x29, 0xb8, 0xa7, 0xe2, 0x9c,
+    0xab, 0x51, 0x61, 0x91, 0xed, 0xa4, 0xd8, 0x6a, 0xca, 0x81, 0x4f, 0x08, 0x2a, 0xd5, 0x31,
+    0x5c, 0xa5, 0xb4, 0xd3, 0x48, 0x35, 0x75, 0xa3, 0x15, 0x1b, 0x45, 0x52, 0xe9, 0xb0, 0xb9,
+    0x5b, 0x06, 0x80, 0x48, 0xa9, 0x1a, 0x32, 0x29, 0xbb, 0x6a, 0x2c, 0xd0, 0xc0, 0x35, 0x06,
+    0x8c, 0x52, 0xe2, 0x80, 0x19, 0x49, 0xb6, 0xa4, 0xc5, 0x28, 0x5a, 0x76, 0x01, 0x81, 0x29,
+    0xc1, 0x69, 0xfb, 0x69, 0xc1, 0x6a, 0x94, 0x40, 0x8c, 0x0a, 0x70, 0x14, 0xf0, 0xb4, 0xe0,
+    0xb5, 0x6a, 0x01, 0x71, 0x81, 0x69, 0xc0, 0x53, 0xc2, 0x53, 0xb6, 0x56, 0x8a, 0x24, 0xb6,
+    0x35, 0x17, 0x26, 0xac, 0x85, 0xc0, 0xa6, 0xc6, 0xbc, 0xd4, 0xf8, 0xad, 0x63, 0x13, 0x19,
+    0xcb, 0x52, 0x3d, 0xb4, 0x9b, 0x6a, 0x4c, 0x50, 0x46, 0x05, 0x3b, 0x13, 0x72, 0x17, 0x18,
+    0xa8, 0xc0, 0xe6, 0xa4, 0x63, 0x93, 0x4d, 0x02, 0xa5, 0x9a, 0x2d, 0x89, 0xa2, 0xaf, 0xa2,
+    0xbc, 0x1f, 0x35, 0x94, 0xfe, 0x14, 0xd3, 0xbe, 0xc0, 0x53, 0xcb, 0x48, 0x55, 0x59, 0x57,
+    0xf8, 0x5c, 0x0f, 0x98, 0x1f, 0x7c, 0xe4, 0xfe, 0x35, 0xf3, 0xa4, 0x67, 0x06, 0xad, 0xc3,
+    0x73, 0x34, 0x4a, 0xc2, 0x29, 0x64, 0x40, 0xdc, 0x10, 0xac, 0x46, 0x69, 0x4e, 0x1c, 0xea,
+    0xc6, 0xd8, 0x6c, 0x47, 0xb0, 0x9b, 0x76, 0xbd, 0xce, 0x97, 0xe2, 0x55, 0xc5, 0x95, 0xe7,
+    0x8b, 0x66, 0x6b, 0x2d, 0xa7, 0x64, 0x6a, 0x93, 0x3a, 0xf4, 0x69, 0x06, 0x73, 0xf9, 0x0c,
+    0x0f, 0xc2, 0xb8, 0x67, 0x8c, 0x93, 0x57, 0xdc, 0xd5, 0x67, 0xeb, 0x9a, 0x1c, 0x52, 0x56,
+    0x32, 0x95, 0x47, 0x39, 0xb9, 0x77, 0x2b, 0x6c, 0xa4, 0xdb, 0x53, 0x1a, 0x61, 0x15, 0x16,
+    0x29, 0x31, 0x98, 0xa4, 0x22, 0x9c, 0x4d, 0x30, 0x9a, 0x86, 0x52, 0x1a, 0x45, 0x25, 0x29,
+    0x34, 0x95, 0x23, 0x0a, 0x29, 0x09, 0xa4, 0xa9, 0x6c, 0x04, 0x7f, 0xba, 0x6a, 0x24, 0xe9,
+    0x52, 0x9e, 0x86, 0xa2, 0x4e, 0x95, 0x0f, 0x71, 0x91, 0x9f, 0xbf, 0xf8, 0xd3, 0x5f, 0xef,
+    0x9a, 0x7b, 0xfd, 0xfa, 0x64, 0x9f, 0x7e, 0xb3, 0x63, 0x10, 0x75, 0xab, 0x49, 0xc2, 0xe6,
+    0xab, 0x25, 0x4c, 0x0e, 0x10, 0xd3, 0x88, 0x99, 0x14, 0x87, 0x2e, 0x68, 0x41, 0x96, 0xfa,
+    0x53, 0x6a, 0x44, 0xe0, 0x52, 0xea, 0x31, 0xe4, 0xd2, 0x66, 0x93, 0x34, 0xa0, 0x66, 0x98,
+    0x84, 0xa5, 0xc5, 0x3b, 0x18, 0xa4, 0x24, 0x50, 0x02, 0x62, 0x9a, 0x78, 0xa0, 0xb5, 0x34,
+    0xb5, 0x26, 0x31, 0x69, 0x29, 0x33, 0x49, 0x9a, 0x40, 0x3b, 0x34, 0x99, 0xa6, 0xd1, 0x40,
+    0x0e, 0xcd, 0x25, 0x25, 0x14, 0x80, 0x5c, 0xd2, 0x66, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28,
+    0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x8a, 0x28, 0x02, 0xc0, 0x5f, 0x5a, 0x75, 0x14, 0x56,
+    0x82, 0x0a, 0x5c, 0x50, 0x29, 0xd8, 0xa6, 0x03, 0x71, 0x4e, 0xc5, 0x2e, 0x28, 0xa7, 0x60,
+    0x18, 0xe3, 0xf7, 0x6d, 0xf4, 0xad, 0x1b, 0xe5, 0xdb, 0x69, 0x65, 0xe8, 0x14, 0x8a, 0xa2,
+    0x57, 0x70, 0xc7, 0xa9, 0xc5, 0x6b, 0x6a, 0x69, 0x8d, 0x3e, 0x13, 0xfd, 0xc9, 0x0a, 0xfe,
+    0x82, 0xb4, 0x8a, 0xf7, 0x64, 0x4b, 0x7a, 0xa3, 0x26, 0x8c, 0x52, 0xe2, 0x97, 0x15, 0x16,
+    0x18, 0x94, 0x62, 0x9d, 0x8a, 0x29, 0xd8, 0x04, 0xc5, 0x18, 0xa5, 0xa2, 0x8b, 0x00, 0x51,
+    0x4b, 0x83, 0x46, 0xda, 0x60, 0x1b, 0x69, 0x76, 0x8a, 0x51, 0x4b, 0x40, 0x16, 0x2d, 0x7a,
+    0xe2, 0x99, 0x70, 0x3f, 0x79, 0x44, 0x2d, 0xb5, 0xa9, 0x66, 0x3b, 0x9b, 0x35, 0x7f, 0x64,
+    0x47, 0x49, 0xf0, 0xb5, 0x82, 0x7c, 0x50, 0xd2, 0x33, 0xdd, 0x8f, 0xfe, 0x82, 0x45, 0x7d,
+    0x47, 0xaa, 0x0c, 0xe9, 0x77, 0x00, 0x7f, 0x72, 0xbe, 0x50, 0xf0, 0x2d, 0xc2, 0xd9, 0xfc,
+    0x46, 0xd0, 0xa6, 0x6e, 0x17, 0xed, 0x2a, 0xa7, 0xe8, 0x4d, 0x7d, 0x69, 0x76, 0x9b, 0xec,
+    0xe6, 0x5f, 0x54, 0x3f, 0xca, 0xb9, 0xe5, 0xb9, 0xd1, 0x4b, 0x66, 0x79, 0xea, 0x3e, 0x60,
+    0x53, 0xf8, 0x57, 0x13, 0xf1, 0x4a, 0x0f, 0x3f, 0xc2, 0x5b, 0xc7, 0x3e, 0x54, 0xca, 0xdf,
+    0xce, 0xba, 0xf8, 0x9f, 0x08, 0xe8, 0x7b, 0x1a, 0xca, 0xf1, 0x55, 0x81, 0xd5, 0x3c, 0x35,
+    0x7d, 0x6a, 0xa3, 0x2e, 0xd1, 0x12, 0xbf, 0x51, 0xcd, 0x55, 0x88, 0x7b, 0x1f, 0x3b, 0x51,
+    0x4a, 0x41, 0x52, 0x41, 0x18, 0x23, 0xa8, 0xa4, 0xac, 0x49, 0x0a, 0x28, 0xa2, 0x80, 0x0a,
+    0x28, 0xa2, 0x80, 0x0a, 0x28, 0xa2, 0x80, 0x3b, 0x8f, 0x85, 0x76, 0x8d, 0x7b, 0xe3, 0x5b,
+    0x56, 0x6f, 0xf5, 0x76, 0xa8, 0xd2, 0x74, 0xe9, 0xc5, 0x7d, 0x10, 0x09, 0xf5, 0xaf, 0x24,
+    0xf8, 0x2d, 0xa5, 0x98, 0xec, 0xaf, 0xf5, 0x47, 0x5f, 0xf5, 0x8c, 0x22, 0x43, 0xea, 0x07,
+    0x27, 0xf5, 0xaf, 0x57, 0x07, 0x15, 0xa2, 0xd8, 0xb8, 0xec, 0x4c, 0x18, 0xd3, 0x83, 0x0f,
+    0x4a, 0x84, 0x35, 0x3b, 0x75, 0x32, 0x89, 0x83, 0x0a, 0x70, 0x61, 0x50, 0x86, 0xa7, 0x03,
+    0x9a, 0x06, 0x4d, 0xbc, 0x57, 0x11, 0xf1, 0x66, 0xc0, 0xea, 0x1e, 0x03, 0xba, 0x64, 0x19,
+    0x6b, 0x76, 0x59, 0xba, 0x76, 0x07, 0x9f, 0xd2, 0xbb, 0x3c, 0xd5, 0x6d, 0x46, 0xcd, 0x35,
+    0x2d, 0x32, 0xe6, 0xca, 0x41, 0x94, 0x9e, 0x36, 0x43, 0xf8, 0x8a, 0x04, 0xf5, 0x47, 0xc8,
+    0x54, 0x55, 0x8b, 0xfb, 0x49, 0x2c, 0x35, 0x0b, 0x8b, 0x49, 0x46, 0x1e, 0x19, 0x19, 0x18,
+    0x7d, 0x0d, 0x57, 0xac, 0x8c, 0x82, 0x8a, 0x28, 0xa0, 0x02, 0x8a, 0x28, 0xa0, 0x0b, 0xb0,
+    0xfc, 0x96, 0x79, 0x3c, 0x65, 0xab, 0xdf, 0xbe, 0x01, 0xc4, 0x47, 0x86, 0xa7, 0x91, 0x87,
+    0x0f, 0x74, 0xc7, 0x3f, 0x45, 0x15, 0xf3, 0xcb, 0x4c, 0x5a, 0x14, 0x8b, 0x18, 0x03, 0xad,
+    0x7d, 0x3b, 0xf0, 0x52, 0xd7, 0xc9, 0xf0, 0x3d, 0x9b, 0x63, 0x06, 0x4d, 0xf2, 0x7e, 0x67,
+    0x1f, 0xd2, 0xad, 0x6c, 0x54, 0x3e, 0x23, 0x8c, 0xf8, 0xd6, 0xbb, 0xbe, 0x27, 0x69, 0x03,
+    0xfe, 0xa1, 0xa3, 0xff, 0x00, 0x43, 0x92, 0xb9, 0x61, 0x08, 0x1d, 0x6b, 0xa9, 0xf8, 0xd4,
+    0xc1, 0x7e, 0x28, 0xe9, 0x07, 0xfe, 0xa1, 0xa3, 0xff, 0x00, 0x46, 0x49, 0x5c, 0xd2, 0xbe,
+    0x6b, 0xbb, 0x0b, 0xf0, 0x1c, 0x58, 0xb6, 0xf9, 0xc5, 0x54, 0x03, 0xb5, 0x3c, 0x2f, 0xb5,
+    0x01, 0xa9, 0xe1, 0x85, 0x75, 0x1c, 0x83, 0x76, 0x9f, 0x4a, 0x7e, 0xd0, 0x7b, 0x52, 0x8c,
+    0x1a, 0x32, 0x29, 0x0c, 0x61, 0x5a, 0x18, 0x1a, 0x71, 0x22, 0x9a, 0x5c, 0x50, 0x03, 0x48,
+    0xa8, 0x9f, 0x02, 0x9c, 0xef, 0x50, 0x33, 0x13, 0x40, 0x84, 0x6e, 0x4d, 0x44, 0x45, 0x3c,
+    0x9e, 0xd4, 0x2a, 0x96, 0x6c, 0x0a, 0x68, 0xb5, 0xa0, 0xc0, 0xa4, 0xf4, 0x15, 0x3c, 0x56,
+    0xc5, 0x88, 0xcd, 0x58, 0x86, 0xdc, 0x00, 0x32, 0x2a, 0xd2, 0xa0, 0x14, 0x82, 0xed, 0x96,
+    0x6c, 0xed, 0x10, 0x28, 0x24, 0x55, 0xb3, 0xb5, 0x47, 0x18, 0xc5, 0x31, 0x08, 0x58, 0xc0,
+    0xa8, 0x9e, 0x42, 0x68, 0x37, 0x56, 0x48, 0x7b, 0x3d, 0x44, 0xf2, 0x81, 0x51, 0xb3, 0x13,
+    0xde, 0xa3, 0xeb, 0x41, 0x3c, 0xc3, 0xde, 0x40, 0xcb, 0x81, 0x9a, 0xa8, 0xf1, 0xe0, 0xd5,
+    0x8c, 0x1a, 0x0a, 0xf1, 0x4c, 0x96, 0xae, 0x36, 0x0e, 0x0e, 0x0d, 0x4c, 0xc8, 0x0f, 0x38,
+    0xe6, 0xab, 0xf2, 0xad, 0x56, 0x51, 0xb2, 0xb4, 0x87, 0x12, 0x3d, 0xbd, 0xb1, 0x48, 0x50,
+    0xd4, 0xa5, 0x80, 0xeb, 0x4d, 0x32, 0x28, 0xef, 0x48, 0x64, 0x46, 0x33, 0x8a, 0x8d, 0x94,
+    0x8a, 0x98, 0xca, 0x01, 0xe9, 0x50, 0xbc, 0x99, 0x14, 0xc5, 0xa1, 0x0b, 0xb1, 0xa8, 0x5b,
+    0x35, 0x2b, 0x38, 0xcd, 0x44, 0xce, 0x29, 0x12, 0x40, 0xed, 0x8a, 0xad, 0x23, 0x62, 0xa6,
+    0x95, 0xc1, 0x35, 0x56, 0x43, 0xcd, 0x20, 0x8a, 0xbb, 0x2b, 0x4f, 0xd0, 0xd5, 0x36, 0xab,
+    0xae, 0x37, 0x0c, 0x1a, 0xa8, 0xeb, 0x82, 0x45, 0x65, 0x33, 0xaa, 0x04, 0x54, 0xd3, 0x4e,
+    0xc5, 0x15, 0x93, 0x34, 0x23, 0x61, 0x4d, 0x2b, 0x52, 0x52, 0x11, 0x52, 0xd0, 0x11, 0x15,
+    0xa3, 0x15, 0x26, 0xda, 0x4d, 0xb8, 0xa9, 0xb0, 0xc6, 0x85, 0x34, 0xe0, 0x29, 0xd8, 0xa5,
+    0x02, 0xad, 0x21, 0x08, 0x05, 0x49, 0x8a, 0x00, 0x1e, 0xb4, 0xee, 0x2a, 0xd2, 0x13, 0x18,
+    0x69, 0xa4, 0xd3, 0xce, 0x2a, 0x23, 0xd6, 0x86, 0x08, 0x08, 0xcd, 0x30, 0xc7, 0x4f, 0x15,
+    0x22, 0x81, 0xb8, 0x12, 0x32, 0x33, 0xd2, 0x95, 0x93, 0x19, 0x1f, 0xd9, 0x25, 0xf2, 0xbc,
+    0xdf, 0x29, 0xfc, 0xbf, 0xef, 0x6d, 0xe2, 0xa3, 0x31, 0xd7, 0x7e, 0xb7, 0x56, 0x46, 0xcb,
+    0x77, 0x9b, 0x18, 0x8b, 0x67, 0x29, 0xdf, 0xe9, 0x8a, 0xe2, 0x9d, 0x06, 0xe3, 0xb4, 0x7c,
+    0xb9, 0xe0, 0x7b, 0x55, 0x4a, 0x92, 0x5b, 0x0b, 0x98, 0xab, 0xb2, 0x94, 0x2d, 0x4d, 0xb2,
+    0x94, 0x25, 0x4a, 0x80, 0x5c, 0x88, 0x2f, 0xb5, 0x38, 0x26, 0x6a, 0x61, 0x1e, 0x6a, 0x65,
+    0x87, 0x3d, 0xaa, 0xd4, 0x09, 0x73, 0x48, 0xac, 0xb1, 0xd3, 0xfc, 0xb3, 0xe9, 0x57, 0x16,
+    0x0c, 0x75, 0xa5, 0x31, 0x62, 0xb4, 0x50, 0x33, 0x73, 0x29, 0x84, 0xa7, 0x6c, 0x3e, 0x95,
+    0x60, 0xa6, 0x29, 0x36, 0xd3, 0xe5, 0x17, 0x33, 0x19, 0x1a, 0xe2, 0xa6, 0xda, 0x29, 0x80,
+    0x62, 0xa4, 0xcf, 0x14, 0xd1, 0x37, 0x18, 0x40, 0x15, 0x13, 0xf3, 0xd2, 0xa4, 0x63, 0x93,
+    0x4d, 0xc5, 0x0c, 0x64, 0x38, 0x34, 0x05, 0x27, 0xb5, 0x4c, 0x13, 0x35, 0x20, 0x40, 0x29,
+    0x58, 0x77, 0x22, 0x54, 0xc7, 0x5a, 0x77, 0x4a, 0x90, 0xa8, 0xa6, 0x30, 0xc5, 0x02, 0x23,
+    0x73, 0x50, 0xb1, 0xa7, 0x48, 0xf5, 0x03, 0x3e, 0x6b, 0x36, 0xcb, 0x8c, 0x45, 0x66, 0x15,
+    0x19, 0x6a, 0x42, 0x69, 0x84, 0xd6, 0x4e, 0x46, 0xc9, 0x01, 0x34, 0x84, 0xd2, 0x13, 0x4d,
+    0xac, 0xdb, 0x18, 0xb9, 0xa4, 0x26, 0x93, 0x34, 0x84, 0xd4, 0xb6, 0x02, 0x93, 0x49, 0x9a,
+    0x69, 0x34, 0x9b, 0xaa, 0x6e, 0x31, 0xc4, 0xd4, 0x71, 0xf5, 0x22, 0x82, 0x69, 0x23, 0xff,
+    0x00, 0x58, 0x6a, 0x6f, 0xa8, 0x04, 0x9f, 0x7e, 0xa3, 0x7e, 0xa3, 0xe9, 0x52, 0xcd, 0xf7,
+    0x87, 0xd2, 0xa2, 0x6e, 0xd5, 0x2c, 0x62, 0xad, 0x3d, 0x8e, 0x23, 0xfa, 0xd4, 0x63, 0xee,
+    0xfd, 0x69, 0xd2, 0x9e, 0x00, 0xa3, 0xa0, 0x0c, 0xa7, 0xe6, 0xa3, 0x14, 0xf5, 0x1b, 0x8d,
+    0x24, 0x03, 0xd1, 0x77, 0x1a, 0x98, 0x00, 0xa2, 0x85, 0x01, 0x45, 0x35, 0x9b, 0x35, 0xa5,
+    0xac, 0x84, 0x35, 0x8d, 0x30, 0xf3, 0x4e, 0x34, 0xd2, 0x71, 0x50, 0xc0, 0x61, 0xa4, 0xa3,
+    0xad, 0x14, 0x86, 0x14, 0x94, 0xb8, 0xa3, 0x14, 0x80, 0x4a, 0x28, 0xa2, 0x80, 0x0a, 0x28,
+    0xa3, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00, 0x51, 0x45, 0x14, 0x00,
+    0x51, 0x45, 0x14, 0x01, 0x6f, 0x14, 0x62, 0x97, 0x14, 0xed, 0xbc, 0x56, 0xb6, 0x10, 0xda,
+    0x75, 0x14, 0x62, 0x98, 0x85, 0xa3, 0x14, 0xa2, 0x96, 0x98, 0x08, 0xa3, 0x32, 0x20, 0xf5,
+    0x61, 0xfc, 0xeb, 0x6f, 0x51, 0x5d, 0xfa, 0x55, 0xd1, 0x1f, 0xf2, 0xca, 0x55, 0x6f, 0xd2,
+    0xb1, 0x93, 0xfe, 0x3e, 0x21, 0x1e, 0xb2, 0x0a, 0xe8, 0x55, 0x04, 0xfa, 0x7e, 0xad, 0x1f,
+    0x7d, 0xa1, 0x87, 0xe1, 0xff, 0x00, 0xea, 0xad, 0xa9, 0xaf, 0x75, 0xa2, 0x27, 0xba, 0x67,
+    0x3b, 0x45, 0x08, 0x32, 0x8a, 0x7d, 0xa9, 0xdb, 0x45, 0x64, 0x8b, 0x1b, 0x4b, 0xb4, 0xd3,
+    0xb1, 0x4b, 0x4e, 0xc0, 0x37, 0x6d, 0x2e, 0x29, 0xc0, 0x51, 0xb6, 0x9d, 0x84, 0x26, 0x28,
+    0xc5, 0x3b, 0x02, 0x97, 0x14, 0x00, 0xd0, 0x29, 0xd4, 0xb4, 0x53, 0xb0, 0x09, 0x4b, 0x45,
+    0x2e, 0x33, 0x45, 0x80, 0x75, 0x9d, 0xcf, 0xd8, 0x75, 0x9d, 0x3a, 0xf0, 0x0f, 0xf5, 0x37,
+    0x08, 0xc7, 0xf3, 0x15, 0xf6, 0x64, 0x52, 0xad, 0xc5, 0xba, 0xb8, 0xe5, 0x64, 0x5d, 0xc3,
+    0xe8, 0x45, 0x7c, 0x57, 0x74, 0xa4, 0xdb, 0xb1, 0x1d, 0x47, 0x35, 0xf5, 0x9f, 0x81, 0x75,
+    0x41, 0xab, 0x78, 0x27, 0x48, 0xbc, 0x07, 0x25, 0xad, 0x95, 0x5b, 0xea, 0xbc, 0x1f, 0xe5,
+    0x58, 0xd4, 0x5a, 0x9b, 0x51, 0x7d, 0x0e, 0x5e, 0xee, 0x33, 0x06, 0xa3, 0x3c, 0x47, 0xb3,
+    0x1f, 0xe7, 0x4d, 0xcd, 0x68, 0x78, 0xa2, 0x0f, 0xb3, 0xea, 0xc6, 0x40, 0x38, 0x90, 0x6e,
+    0xac, 0xbd, 0xd9, 0x00, 0x8e, 0x95, 0x4b, 0x54, 0x27, 0xa3, 0x3c, 0x47, 0xc7, 0xfa, 0x01,
+    0xd1, 0xbc, 0x41, 0x24, 0xb1, 0xa1, 0x16, 0xb7, 0x44, 0xc9, 0x19, 0x03, 0x80, 0x7b, 0x8a,
+    0xe5, 0x2b, 0xe8, 0x6d, 0x7f, 0x44, 0xb6, 0xf1, 0x0e, 0x95, 0x25, 0x95, 0xc0, 0xc3, 0x75,
+    0x8d, 0xfb, 0xa3, 0x76, 0x35, 0xe0, 0x9a, 0x96, 0x9b, 0x73, 0xa4, 0xdf, 0xcb, 0x65, 0x77,
+    0x19, 0x49, 0x63, 0x38, 0x3e, 0x84, 0x76, 0x23, 0xd8, 0xd6, 0x73, 0x5d, 0x49, 0x2a, 0x51,
+    0x45, 0x15, 0x00, 0x14, 0x51, 0x45, 0x00, 0x15, 0x2d, 0xb5, 0xbc, 0x97, 0x77, 0x51, 0x5b,
+    0xc2, 0xa5, 0xa4, 0x95, 0x82, 0xa8, 0x1d, 0xc9, 0xa8, 0xc0, 0x24, 0x80, 0x06, 0x49, 0xe8,
+    0x05, 0x7b, 0x37, 0xc3, 0xbf, 0x01, 0x2e, 0x9c, 0xb0, 0xeb, 0x3a, 0xa2, 0x9f, 0xb6, 0x11,
+    0xba, 0x18, 0x4f, 0x48, 0xc1, 0xee, 0x7d, 0xff, 0x00, 0x95, 0x38, 0xab, 0x81, 0xde, 0x78,
+    0x6f, 0x49, 0x8f, 0x42, 0xd0, 0x2d, 0x34, 0xe8, 0xf1, 0xfb, 0xa8, 0xc6, 0xf2, 0x3b, 0xb1,
+    0xe4, 0x9f, 0xce, 0xb5, 0xc1, 0xa8, 0x01, 0xa7, 0x06, 0xc5, 0x68, 0x68, 0x4d, 0x9a, 0x50,
+    0x6a, 0x20, 0xde, 0xf4, 0xfd, 0xd4, 0x0c, 0x90, 0x1a, 0x50, 0x6a, 0x3d, 0xd4, 0xa1, 0xa8,
+    0x02, 0x40, 0x7d, 0xe9, 0xdb, 0xaa, 0x2d, 0xd4, 0xbb, 0xa8, 0x03, 0xc1, 0xbe, 0x2f, 0x68,
+    0x0d, 0xa7, 0x78, 0x94, 0x6a, 0x71, 0x27, 0xfa, 0x35, 0xf0, 0xc9, 0x20, 0x70, 0x1c, 0x75,
+    0x1f, 0xd6, 0xbc, 0xea, 0xbe, 0xa4, 0xf1, 0x5f, 0x87, 0x61, 0xf1, 0x3f, 0x87, 0xee, 0x34,
+    0xf9, 0x30, 0x24, 0x23, 0x74, 0x2e, 0x7f, 0x85, 0xc7, 0x43, 0x5f, 0x32, 0x5f, 0xd8, 0x5c,
+    0xe9, 0x97, 0xd3, 0x59, 0x5d, 0xc4, 0x62, 0x9e, 0x16, 0x2a, 0xea, 0x7d, 0x6a, 0x24, 0xba,
+    0x99, 0xb5, 0x66, 0x56, 0xa2, 0x8a, 0x2a, 0x44, 0x14, 0x51, 0x4a, 0x06, 0x68, 0x01, 0x51,
+    0x19, 0xd8, 0x2a, 0x8c, 0xb1, 0x38, 0x03, 0xd4, 0x9a, 0xfb, 0x17, 0xc0, 0x9a, 0x77, 0xf6,
+    0x5f, 0x87, 0x2c, 0xed, 0x08, 0x00, 0xc1, 0x02, 0x21, 0xc7, 0xae, 0x39, 0xfd, 0x6b, 0xe7,
+    0x9f, 0x86, 0x3e, 0x14, 0x3a, 0xe6, 0xb3, 0x1d, 0xfc, 0xf1, 0x9f, 0xb0, 0xd9, 0x30, 0x76,
+    0x24, 0x71, 0x24, 0x9d, 0x87, 0xe1, 0x5f, 0x4f, 0x68, 0xe9, 0x8b, 0x4d, 0xdd, 0xd9, 0xaa,
+    0xb6, 0x89, 0xa5, 0x35, 0xad, 0xcf, 0x08, 0xf8, 0xcd, 0x2a, 0xdc, 0x7c, 0x57, 0xd3, 0xe3,
+    0x5e, 0x4c, 0x3a, 0x7a, 0x2b, 0x7b, 0x1d, 0xf2, 0x37, 0xf2, 0x22, 0xb0, 0x54, 0x71, 0x56,
+    0x3c, 0x73, 0x71, 0xfd, 0xa3, 0xf1, 0x9f, 0x59, 0x91, 0x0e, 0x52, 0x00, 0xb1, 0x0f, 0x6d,
+    0xb1, 0xaa, 0x9f, 0xd7, 0x35, 0x18, 0x43, 0x5e, 0x86, 0x15, 0x5a, 0x07, 0x9d, 0x8b, 0x77,
+    0xa8, 0x37, 0x14, 0xa0, 0x53, 0xc2, 0x1a, 0x36, 0x57, 0x49, 0xcc, 0x25, 0x3c, 0x52, 0x6d,
+    0x34, 0xb8, 0x22, 0x90, 0x0d, 0x61, 0xc5, 0x30, 0x8c, 0xd4, 0x84, 0x1c, 0xd0, 0x10, 0xb1,
+    0x0a, 0x3d, 0x69, 0x81, 0x09, 0x4a, 0x8d, 0x93, 0x8a, 0xec, 0xad, 0x7c, 0x13, 0x73, 0x77,
+    0xa6, 0x1b, 0xb5, 0x95, 0x57, 0x8c, 0xaa, 0x9e, 0xf5, 0xca, 0x49, 0x19, 0x8e, 0x42, 0x87,
+    0xa8, 0x38, 0x34, 0x93, 0x4f, 0x62, 0xe7, 0x4e, 0x50, 0xb3, 0x6b, 0x72, 0xa6, 0xce, 0x7a,
+    0x1a, 0xb9, 0x6d, 0x0f, 0xcb, 0x9a, 0x8c, 0xa6, 0x4d, 0x5d, 0x89, 0x70, 0xa2, 0x99, 0x2b,
+    0x51, 0x40, 0xc5, 0x39, 0x57, 0x2c, 0x29, 0x71, 0x4f, 0x89, 0x72, 0xd9, 0xf4, 0xa4, 0x68,
+    0x91, 0x37, 0x6a, 0x61, 0x5e, 0x6a, 0x52, 0xa7, 0xb7, 0x5a, 0x36, 0x1a, 0x66, 0x96, 0x20,
+    0x31, 0x9c, 0xf6, 0xa4, 0x11, 0xf7, 0xa9, 0xd8, 0x05, 0xa8, 0x8b, 0x7a, 0x50, 0x26, 0x92,
+    0x10, 0xa8, 0x03, 0x9a, 0x89, 0x9b, 0x9e, 0x29, 0xcc, 0xd5, 0x1b, 0x37, 0x34, 0x85, 0x71,
+    0xa4, 0x52, 0x06, 0x2b, 0xd2, 0x94, 0x9a, 0x69, 0x14, 0x13, 0x71, 0x0b, 0x12, 0x69, 0xa5,
+    0xa9, 0x4f, 0x15, 0x13, 0x1a, 0x05, 0x71, 0x59, 0xea, 0x16, 0x7f, 0x53, 0x48, 0xed, 0x8a,
+    0xae, 0xcc, 0x73, 0x40, 0xae, 0x48, 0xd2, 0x0e, 0xd5, 0x0b, 0x36, 0x69, 0x8e, 0xd5, 0x03,
+    0x31, 0xa4, 0x35, 0x1b, 0x92, 0x39, 0x15, 0x03, 0x0a, 0x42, 0xc6, 0x82, 0xc7, 0xbd, 0x23,
+    0x44, 0xac, 0x30, 0xf7, 0xaa, 0xb2, 0x75, 0xab, 0x44, 0xe6, 0xa0, 0x70, 0x09, 0xa8, 0x91,
+    0xac, 0x0a, 0xf8, 0xa4, 0x2b, 0x52, 0x95, 0xc5, 0x34, 0x8a, 0xcd, 0xa3, 0x5b, 0x91, 0x11,
+    0x49, 0x8a, 0x90, 0x8a, 0x4c, 0x54, 0xb4, 0x04, 0x74, 0x53, 0xf1, 0x4d, 0x22, 0x95, 0x86,
+    0x36, 0x8c, 0xd3, 0xb1, 0x49, 0xb4, 0x9a, 0x35, 0x01, 0xa4, 0x9a, 0x4c, 0x9a, 0x93, 0x61,
+    0xf4, 0xa3, 0xcb, 0x6a, 0x2c, 0xc2, 0xe3, 0x32, 0x69, 0x2a, 0x5f, 0x28, 0xd0, 0x23, 0x34,
+    0x72, 0xb1, 0x5d, 0x0d, 0x5e, 0xb5, 0x32, 0x8a, 0x16, 0x2f, 0x6a, 0x94, 0x26, 0x2b, 0x44,
+    0x89, 0x72, 0x13, 0x14, 0x6d, 0xcd, 0x4a, 0x10, 0x9e, 0x82, 0xa4, 0x58, 0x49, 0xab, 0xb1,
+    0x93, 0x95, 0x8a, 0xbe, 0x5e, 0x69, 0xeb, 0x09, 0xf4, 0xab, 0x6b, 0x08, 0x15, 0x20, 0x8c,
+    0x0e, 0xd5, 0x5c, 0xa2, 0x72, 0x65, 0x65, 0x86, 0xa7, 0x48, 0xc7, 0xa5, 0x3f, 0x6d, 0x38,
+    0x0a, 0xa4, 0x84, 0x77, 0x9e, 0x02, 0xd1, 0xb4, 0x8b, 0xfb, 0x1b, 0x99, 0x6f, 0x22, 0x8a,
+    0x6b, 0x80, 0xfb, 0x76, 0x48, 0x7e, 0xea, 0xe3, 0xad, 0x72, 0x5a, 0xfd, 0xad, 0xa5, 0xb6,
+    0xb7, 0x79, 0x0d, 0x8b, 0x6e, 0xb6, 0x47, 0xc2, 0x73, 0x9c, 0x7b, 0x66, 0xaa, 0x2b, 0xb2,
+    0x67, 0x63, 0xb2, 0xe7, 0xae, 0x0e, 0x29, 0x86, 0x9a, 0x5a, 0x9b, 0x4a, 0xa2, 0x74, 0xd4,
+    0x12, 0xd5, 0x75, 0x2b, 0x15, 0xa6, 0x6d, 0xa9, 0xd8, 0x73, 0x4d, 0x22, 0x83, 0x12, 0x1d,
+    0xb4, 0x84, 0x54, 0x84, 0x53, 0x4d, 0x00, 0x33, 0x14, 0xaa, 0x99, 0x3e, 0xd4, 0xe5, 0x5c,
+    0xd4, 0x80, 0x01, 0x4a, 0xc0, 0x20, 0x5a, 0x70, 0x43, 0x4f, 0x55, 0xcd, 0x4e, 0x91, 0x64,
+    0x7b, 0x9a, 0x76, 0x29, 0x22, 0xa9, 0x43, 0x55, 0xa7, 0x05, 0x3a, 0xd7, 0xac, 0x78, 0x73,
+    0xc1, 0x49, 0xa7, 0xe8, 0xd3, 0xf8, 0x8b, 0x59, 0xb7, 0x0e, 0x21, 0x89, 0xa5, 0x82, 0xda,
+    0x4e, 0x8d, 0x81, 0x90, 0x58, 0x7e, 0x1d, 0x2b, 0xca, 0xef, 0xf2, 0x64, 0x35, 0x9f, 0x32,
+    0x95, 0xed, 0xd0, 0xd6, 0x74, 0x9c, 0x12, 0x72, 0xea, 0x66, 0x48, 0x6a, 0x22, 0x69, 0xf2,
+    0x75, 0x35, 0x11, 0xae, 0x79, 0x32, 0xd2, 0xd0, 0x42, 0x69, 0x09, 0xa0, 0x8a, 0x4a, 0xce,
+    0xe3, 0x00, 0x29, 0x08, 0xa3, 0x76, 0x29, 0xac, 0xf5, 0x2d, 0xa0, 0x1d, 0x81, 0x4d, 0x24,
+    0x54, 0x65, 0x8d, 0x25, 0x43, 0x63, 0x1c, 0xc4, 0x54, 0x64, 0xd2, 0x9a, 0x6d, 0x4b, 0x60,
+    0x14, 0x27, 0x12, 0x51, 0x40, 0xfb, 0xe2, 0x90, 0xc9, 0x66, 0x19, 0xc1, 0xa8, 0x1b, 0xa0,
+    0xab, 0x2e, 0x32, 0xb5, 0x59, 0xa9, 0xc8, 0x48, 0x40, 0x79, 0x14, 0xae, 0x72, 0xd4, 0xb1,
+    0xa8, 0x39, 0xcf, 0x6a, 0x69, 0xea, 0x6a, 0x7a, 0x0c, 0x05, 0x4f, 0x12, 0xe0, 0x66, 0xa1,
+    0x41, 0x93, 0x56, 0x33, 0x81, 0x55, 0x14, 0x26, 0x2b, 0x1a, 0x8c, 0xd2, 0x93, 0x9a, 0x4a,
+    0x6c, 0x06, 0xb1, 0xa8, 0xc9, 0xcd, 0x2b, 0x1c, 0x9a, 0x4a, 0x86, 0x30, 0xa3, 0x19, 0xa0,
+    0x53, 0xb3, 0x81, 0x40, 0x09, 0xd2, 0x92, 0x96, 0x9b, 0x40, 0x0b, 0x45, 0x14, 0xa2, 0x90,
+    0x09, 0x8a, 0x09, 0xa5, 0x34, 0xda, 0x60, 0x14, 0x51, 0x45, 0x20, 0x0a, 0x29, 0x69, 0x28,
+    0x00, 0xa2, 0x8a, 0x28, 0x00, 0xa2, 0x96, 0x92, 0x80, 0x2f, 0x01, 0x52, 0x11, 0xf2, 0xd2,
+    0x2a, 0xd3, 0xcf, 0x4a, 0xe8, 0x48, 0x92, 0x3c, 0x52, 0xe2, 0x8a, 0x28, 0xb0, 0x05, 0x00,
+    0x66, 0x97, 0x14, 0xe1, 0x4c, 0x04, 0x84, 0x67, 0x50, 0xb6, 0x5f, 0xf6, 0xf3, 0x5d, 0x36,
+    0x94, 0x81, 0xf5, 0x2b, 0xfb, 0x7f, 0xf9, 0xe9, 0x08, 0xfe, 0xbf, 0xe3, 0x5c, 0xf5, 0x82,
+    0x97, 0xd6, 0x22, 0x1f, 0xdd, 0x5c, 0xd6, 0xde, 0x8b, 0x29, 0x3e, 0x27, 0xba, 0x5f, 0xfa,
+    0x64, 0x3f, 0x4c, 0x56, 0x94, 0xf4, 0x57, 0xf3, 0xfd, 0x0c, 0xe6, 0x73, 0xf1, 0xa9, 0x50,
+    0x50, 0xf5, 0x56, 0x22, 0x9f, 0xb6, 0xac, 0xdf, 0xc3, 0xf6, 0x7d, 0x56, 0xee, 0x2e, 0xdb,
+    0xf7, 0x0f, 0xa1, 0xa8, 0x71, 0x51, 0x6b, 0x68, 0x5d, 0xef, 0xa8, 0xdc, 0x0a, 0x5a, 0x5a,
+    0x29, 0xd8, 0x04, 0xc5, 0x2d, 0x14, 0xb8, 0xa2, 0xc0, 0x25, 0x14, 0xb8, 0xa5, 0x02, 0x9d,
+    0x80, 0x4c, 0x52, 0xe2, 0x9d, 0x8a, 0x31, 0x4c, 0x06, 0xe2, 0x94, 0x0a, 0x70, 0x14, 0xb8,
+    0xa7, 0x60, 0x18, 0xe8, 0x19, 0x19, 0x7d, 0x45, 0x7b, 0x87, 0xc0, 0x8d, 0x64, 0x5c, 0xf8,
+    0x56, 0xe7, 0x4b, 0x76, 0xfd, 0xed, 0x94, 0xe4, 0x80, 0x7f, 0xba, 0xdc, 0xff, 0x00, 0x30,
+    0x6b, 0xc5, 0x02, 0x93, 0xda, 0xba, 0xcf, 0x84, 0xba, 0xb7, 0xf6, 0x2f, 0xc4, 0x45, 0xb5,
+    0x90, 0xed, 0x87, 0x51, 0x8c, 0xc5, 0xd3, 0xf8, 0xba, 0xaf, 0xea, 0x0f, 0xe7, 0x59, 0x55,
+    0x8e, 0x97, 0x2e, 0x0e, 0xcc, 0xf7, 0x6f, 0x16, 0xdb, 0x79, 0xb6, 0x09, 0x70, 0xa3, 0x26,
+    0x33, 0xcf, 0xd2, 0xb8, 0xd4, 0x7e, 0x08, 0xfc, 0x6b, 0xd2, 0x2e, 0x62, 0x17, 0x56, 0x92,
+    0x40, 0xfd, 0x1d, 0x71, 0x5e, 0x6d, 0x34, 0x6d, 0x6d, 0x3b, 0xc4, 0xc3, 0xe6, 0x46, 0xc5,
+    0x44, 0x76, 0xb1, 0xa5, 0x45, 0xad, 0xc9, 0x83, 0x56, 0x37, 0x88, 0xbc, 0x31, 0xa7, 0xf8,
+    0x96, 0xd8, 0x25, 0xca, 0x94, 0x9d, 0x07, 0xee, 0xe7, 0x4f, 0xbc, 0xbe, 0xde, 0xe3, 0xda,
+    0xb5, 0x41, 0xe3, 0x8a, 0x70, 0x35, 0x56, 0x33, 0x3c, 0x57, 0x59, 0xf8, 0x7f, 0xad, 0x69,
+    0x25, 0x9d, 0x22, 0x17, 0x70, 0x0f, 0xf9, 0x69, 0x0f, 0x27, 0x1e, 0xeb, 0xd4, 0x57, 0x2e,
+    0xe8, 0xf1, 0xb1, 0x57, 0x56, 0x56, 0x1d, 0x43, 0x0c, 0x1a, 0xfa, 0x55, 0x5b, 0x15, 0x04,
+    0xda, 0x5e, 0x9d, 0x74, 0xe1, 0xe7, 0xb2, 0xb7, 0x91, 0x87, 0x76, 0x8c, 0x13, 0x50, 0xe0,
+    0x80, 0xf9, 0xcd, 0x60, 0x99, 0x80, 0x2b, 0x13, 0x90, 0x7a, 0x61, 0x4d, 0x69, 0x58, 0x78,
+    0x67, 0x59, 0xd4, 0xdc, 0x2d, 0xae, 0x9f, 0x3b, 0x67, 0xf8, 0x8a, 0xed, 0x03, 0xf1, 0x35,
+    0xf4, 0x14, 0x76, 0x96, 0xb1, 0x80, 0x12, 0xde, 0x15, 0x03, 0xa0, 0x08, 0x06, 0x2a, 0xc2,
+    0x90, 0x06, 0x00, 0xc7, 0xd2, 0x8e, 0x44, 0x07, 0x15, 0xe0, 0xbf, 0x87, 0x50, 0x68, 0xc5,
+    0x6f, 0xf5, 0x40, 0x97, 0x17, 0xc3, 0x94, 0x41, 0xca, 0x45, 0xfe, 0x27, 0xde, 0xbd, 0x04,
+    0x35, 0x56, 0x0d, 0x52, 0x06, 0xf7, 0xa7, 0x62, 0x91, 0x38, 0x34, 0xfd, 0xc6, 0xab, 0x86,
+    0xa7, 0x86, 0xa0, 0x64, 0xc1, 0xa9, 0xc1, 0xaa, 0x10, 0xd4, 0xe0, 0x68, 0x0b, 0x92, 0xee,
+    0xa5, 0x0d, 0xc7, 0x53, 0x51, 0x66, 0x8c, 0xd0, 0x04, 0xfb, 0xc7, 0xad, 0x2e, 0xef, 0xad,
+    0x41, 0xb8, 0xd2, 0x86, 0x34, 0x58, 0x77, 0x26, 0x0f, 0x5c, 0x77, 0x8e, 0x3c, 0x09, 0x6b,
+    0xe2, 0xb8, 0x3e, 0xd1, 0x01, 0x58, 0x35, 0x28, 0xc7, 0xc9, 0x2e, 0x38, 0x90, 0x7f, 0x75,
+    0xbf, 0xc6, 0xba, 0xcd, 0xde, 0xd4, 0xbb, 0xfd, 0xa8, 0xb0, 0xb7, 0x3e, 0x5a, 0xd5, 0x74,
+    0x4d, 0x47, 0x44, 0xbc, 0x6b, 0x5d, 0x42, 0xd6, 0x48, 0x64, 0x1d, 0x32, 0x38, 0x6f, 0x70,
+    0x7b, 0x8a, 0xcf, 0xaf, 0xab, 0xae, 0x6d, 0xed, 0xaf, 0x23, 0x09, 0x73, 0x6f, 0x14, 0xc8,
+    0x0e, 0x42, 0xc8, 0x81, 0x80, 0x3f, 0x8d, 0x73, 0xd7, 0xfe, 0x01, 0xf0, 0xce, 0xa5, 0x21,
+    0x92, 0x5d, 0x31, 0x23, 0x73, 0xd5, 0xa1, 0x62, 0x9f, 0xa0, 0xe2, 0xa7, 0x93, 0xb1, 0x36,
+    0x3e, 0x72, 0xeb, 0x5b, 0x7e, 0x1d, 0xf0, 0xb6, 0xa5, 0xe2, 0x4b, 0xd5, 0xb7, 0xb2, 0x85,
+    0xb6, 0xe7, 0xe7, 0x99, 0x86, 0x12, 0x31, 0xea, 0x4f, 0xf4, 0xaf, 0x77, 0xd3, 0x7c, 0x0d,
+    0xe1, 0xad, 0x29, 0x83, 0xdb, 0xe9, 0x50, 0xb4, 0x83, 0xf8, 0xe6, 0xcc, 0x87, 0xff, 0x00,
+    0x1e, 0xe2, 0xb7, 0xa2, 0x8e, 0x28, 0x10, 0x47, 0x0c, 0x69, 0x1a, 0x0e, 0x8a, 0x8a, 0x14,
+    0x7e, 0x42, 0x85, 0x0e, 0xe1, 0x62, 0x1d, 0x0f, 0x4a, 0x83, 0x43, 0xd2, 0x6d, 0xb4, 0xeb,
+    0x65, 0x50, 0x91, 0x28, 0x52, 0x40, 0xc6, 0xe6, 0xee, 0x4f, 0xd6, 0xbb, 0xbb, 0x72, 0xb6,
+    0xba, 0x72, 0xbc, 0xa4, 0x2a, 0xa2, 0x6e, 0x63, 0xe8, 0x3a, 0x9a, 0xe5, 0xac, 0x62, 0x33,
+    0xde, 0xc6, 0x98, 0xef, 0xcd, 0x58, 0xf8, 0x8f, 0xaa, 0x8d, 0x17, 0xe1, 0xe6, 0xb5, 0x74,
+    0xae, 0x11, 0xcd, 0xb1, 0x86, 0x3c, 0xff, 0x00, 0x79, 0xfe, 0x41, 0x8f, 0xcf, 0xf4, 0xa2,
+    0x5d, 0x8d, 0x63, 0xa2, 0xb9, 0xf3, 0x86, 0x91, 0x74, 0xfa, 0xbf, 0x88, 0xb5, 0x8d, 0x5d,
+    0xc9, 0x26, 0xe6, 0x77, 0x93, 0x9f, 0xf6, 0x98, 0xb5, 0x74, 0x18, 0xac, 0x2f, 0x0a, 0xdb,
+    0xf9, 0x5a, 0x4f, 0x98, 0x46, 0x0c, 0xae, 0x4f, 0xe1, 0xd2, 0xb7, 0x73, 0x8a, 0xf4, 0x68,
+    0xab, 0x53, 0x47, 0x91, 0x59, 0xde, 0x6c, 0x5d, 0xb4, 0xbb, 0x71, 0x40, 0x6a, 0x78, 0x65,
+    0x35, 0xb1, 0x1a, 0x0c, 0xc0, 0xa4, 0x34, 0xfc, 0x0a, 0x69, 0x1c, 0xd0, 0x0c, 0x61, 0xa0,
+    0x1d, 0xa4, 0x11, 0x41, 0x14, 0x98, 0x26, 0x91, 0x27, 0x43, 0x17, 0x8b, 0xaf, 0x6d, 0xf4,
+    0xf3, 0x6b, 0x1b, 0x6d, 0xc8, 0xc6, 0x6b, 0x9d, 0x6f, 0x9d, 0xcb, 0x1e, 0xa4, 0xe6, 0x9d,
+    0xb6, 0x97, 0x6f, 0x14, 0x92, 0x4b, 0x63, 0x49, 0x4e, 0x53, 0xdd, 0x8d, 0x8d, 0x32, 0xd5,
+    0x68, 0x2e, 0x05, 0x47, 0x12, 0x55, 0xa0, 0xb5, 0x41, 0x14, 0x47, 0xb3, 0x8a, 0x9a, 0x15,
+    0xc6, 0x29, 0x36, 0xd4, 0xd1, 0xae, 0x17, 0x34, 0x1a, 0x44, 0x5a, 0x6b, 0x36, 0x28, 0x76,
+    0x00, 0x75, 0xe9, 0x55, 0xde, 0x5f, 0x4a, 0x0a, 0x6e, 0xc2, 0xc8, 0xd9, 0xa8, 0x0b, 0x1a,
+    0x09, 0x24, 0xd1, 0xb4, 0x9a, 0x0c, 0x9b, 0x1b, 0x48, 0x6a, 0x65, 0x81, 0x8d, 0x4a, 0xb6,
+    0x99, 0xea, 0x0d, 0x21, 0xa8, 0xb6, 0x52, 0x34, 0x95, 0xa3, 0xf6, 0x45, 0x03, 0x91, 0x4c,
+    0x30, 0x20, 0xf4, 0xc5, 0x03, 0xe4, 0x66, 0x73, 0x2b, 0x1a, 0x89, 0x94, 0x8a, 0xd4, 0x31,
+    0xaf, 0x60, 0x2a, 0x39, 0x23, 0x4c, 0x1a, 0x09, 0x71, 0x31, 0xdf, 0x39, 0xe6, 0xa3, 0xd9,
+    0x9a, 0xbf, 0x34, 0x23, 0x19, 0xaa, 0xdb, 0x70, 0x71, 0x41, 0x16, 0x2a, 0xbc, 0x44, 0xf3,
+    0x50, 0x3c, 0x44, 0x76, 0xad, 0x7d, 0x83, 0x1c, 0x8a, 0x8d, 0xa3, 0x52, 0x28, 0xb1, 0x49,
+    0xb4, 0x63, 0xec, 0x34, 0x84, 0x56, 0x8b, 0xc4, 0x01, 0xe9, 0x50, 0x3c, 0x43, 0x1c, 0x54,
+    0xd8, 0xa5, 0x3e, 0xe5, 0x16, 0x5a, 0x61, 0x4a, 0xb2, 0xc9, 0x83, 0x4c, 0x2b, 0x49, 0xa3,
+    0x55, 0x22, 0xb1, 0x04, 0x53, 0x71, 0x56, 0x36, 0xd3, 0x4a, 0xd4, 0xd8, 0xb5, 0x22, 0xbe,
+    0xda, 0x42, 0xbe, 0xd5, 0x31, 0x4e, 0x69, 0x36, 0x9a, 0x56, 0x1d, 0xc8, 0x36, 0xd1, 0xb2,
+    0xa6, 0xd8, 0x69, 0x42, 0xe2, 0x95, 0x87, 0xcc, 0x44, 0xb1, 0x64, 0xd4, 0xab, 0x10, 0xa9,
+    0x02, 0xd4, 0xa2, 0x3f, 0x6a, 0xa5, 0x13, 0x39, 0x4c, 0x84, 0x22, 0x8e, 0xd4, 0xa1, 0x41,
+    0xed, 0x53, 0x88, 0x89, 0xa9, 0x16, 0x1c, 0x76, 0xa7, 0x63, 0x37, 0x32, 0xb0, 0x8b, 0x3d,
+    0xa9, 0x7c, 0x81, 0x57, 0x04, 0x54, 0xf1, 0x17, 0xb5, 0x3b, 0x0b, 0x99, 0x94, 0xc4, 0x02,
+    0x9e, 0xb0, 0x01, 0xda, 0xad, 0x88, 0xe9, 0x42, 0x0a, 0x76, 0x02, 0xb8, 0x8b, 0x14, 0xe1,
+    0x1d, 0x4f, 0xb6, 0x8c, 0x53, 0xb0, 0x11, 0x6c, 0xe2, 0x8d, 0xb5, 0x26, 0x28, 0xc5, 0x31,
+    0x91, 0x95, 0x14, 0xdc, 0x62, 0xa4, 0xc5, 0x21, 0xe9, 0x4d, 0x00, 0xc2, 0x45, 0x31, 0x8d,
+    0x38, 0x8a, 0x69, 0xa0, 0x63, 0x0d, 0x21, 0xa7, 0x13, 0x8a, 0x89, 0x9e, 0x90, 0x84, 0x63,
+    0x4d, 0xfb, 0xcd, 0x8a, 0x63, 0x3d, 0x3a, 0x23, 0xde, 0x95, 0xc7, 0x62, 0x60, 0x30, 0x28,
+    0x07, 0x9a, 0x8d, 0x9c, 0x7a, 0xd0, 0xae, 0x09, 0xa0, 0x0b, 0x71, 0x2e, 0x48, 0xcd, 0x77,
+    0xbf, 0x0e, 0x7c, 0x34, 0x35, 0xdf, 0x10, 0xc4, 0x66, 0x8f, 0x75, 0xb4, 0x1f, 0xbc, 0x93,
+    0x23, 0x83, 0xe8, 0x3f, 0x13, 0xfc, 0x8d, 0x70, 0xd6, 0x6b, 0xe6, 0x4a, 0xab, 0xeb, 0x5f,
+    0x43, 0x7c, 0x2b, 0xd2, 0xe3, 0xb3, 0xf0, 0xd1, 0xbc, 0xda, 0x3c, 0xcb, 0x97, 0x3c, 0xe3,
+    0x90, 0xa3, 0x80, 0x3f, 0xad, 0x45, 0x69, 0xf2, 0x53, 0x6d, 0x1d, 0x34, 0x17, 0xda, 0xec,
+    0x56, 0xf8, 0xab, 0x74, 0x2d, 0xfc, 0x3a, 0x6d, 0x63, 0x50, 0x16, 0x42, 0xb1, 0x8c, 0x76,
+    0xe7, 0x77, 0xfe, 0xcb, 0x8f, 0xc6, 0xbe, 0x73, 0xbe, 0xe5, 0xd8, 0xfb, 0xd7, 0xbb, 0x7c,
+    0x60, 0x90, 0x96, 0xb6, 0x50, 0x78, 0xc3, 0xe7, 0xf0, 0x03, 0xfc, 0x6b, 0xc2, 0x6f, 0x3b,
+    0xd6, 0x74, 0x15, 0xa9, 0x22, 0xb1, 0x2f, 0x58, 0xaf, 0x23, 0x22, 0x4e, 0xb5, 0x19, 0x38,
+    0xa9, 0x24, 0xea, 0x6a, 0x16, 0xeb, 0x58, 0xcf, 0x70, 0x42, 0x16, 0xa6, 0x13, 0x4e, 0x22,
+    0x98, 0x45, 0x64, 0xd8, 0xc4, 0x26, 0x92, 0x96, 0x92, 0xa5, 0x80, 0xd3, 0x45, 0x2e, 0x29,
+    0x31, 0x48, 0x06, 0xd2, 0x53, 0xb1, 0x49, 0x8a, 0x90, 0x12, 0x8e, 0xe2, 0x97, 0x8a, 0x69,
+    0xe9, 0x40, 0xcb, 0x23, 0x95, 0x15, 0x55, 0xf8, 0x35, 0x65, 0x0e, 0x52, 0xa0, 0x94, 0x61,
+    0x8d, 0x54, 0xb6, 0x12, 0x16, 0x2e, 0x14, 0x9a, 0x8a, 0x8a, 0x2a, 0x2e, 0x32, 0x54, 0x18,
+    0xa7, 0x13, 0x51, 0xab, 0x53, 0xc5, 0x52, 0x62, 0x16, 0x98, 0xcd, 0x4e, 0x26, 0xa3, 0x27,
+    0x26, 0x93, 0x60, 0x25, 0x14, 0x53, 0x94, 0x66, 0x90, 0xc0, 0x0e, 0x29, 0x3b, 0xd3, 0xcd,
+    0x32, 0x98, 0x09, 0x45, 0x14, 0x54, 0x80, 0x62, 0x9d, 0x48, 0x05, 0x29, 0xa6, 0x02, 0x1a,
+    0x4a, 0x0d, 0x14, 0x80, 0x4a, 0x29, 0x68, 0xa0, 0x02, 0x92, 0x96, 0x92, 0x80, 0x0a, 0x28,
+    0xa5, 0xa0, 0x00, 0xd2, 0x52, 0xd2, 0x50, 0x06, 0x9c, 0x6d, 0xd0, 0xd3, 0xc8, 0x18, 0xa6,
+    0x34, 0x46, 0x09, 0xde, 0x13, 0xdb, 0x95, 0xf7, 0x14, 0xea, 0xe9, 0xf2, 0x24, 0x6e, 0xda,
+    0x5c, 0x52, 0x81, 0x4e, 0x0b, 0xeb, 0x4e, 0xc2, 0x1b, 0x8a, 0x50, 0x39, 0xa7, 0x50, 0x70,
+    0x01, 0x27, 0xb5, 0x00, 0x58, 0xd1, 0x53, 0x7e, 0xa3, 0x71, 0x27, 0x65, 0x5c, 0x55, 0x9d,
+    0x16, 0x5c, 0xf8, 0xaa, 0x7f, 0x75, 0x61, 0xf9, 0x53, 0xb4, 0x28, 0xbc, 0xbd, 0x3a, 0x6b,
+    0x86, 0xe0, 0xc8, 0xc4, 0xfe, 0x15, 0x99, 0xa4, 0xdc, 0x6d, 0xf1, 0x00, 0x94, 0x1e, 0x19,
+    0x98, 0x73, 0xef, 0x57, 0xb2, 0x8f, 0x9b, 0x33, 0x7a, 0xb9, 0x1a, 0xfe, 0x24, 0x8b, 0x66,
+    0xa9, 0x1c, 0xc0, 0x71, 0x2c, 0x78, 0x3f, 0x50, 0x7f, 0xc0, 0xd6, 0x4e, 0x2b, 0xa1, 0xf1,
+    0x0a, 0x89, 0x6c, 0x22, 0x9c, 0x75, 0x8d, 0xc1, 0x3f, 0x43, 0xc1, 0xfe, 0x95, 0x83, 0x8a,
+    0x72, 0x56, 0x93, 0x1d, 0x37, 0x78, 0x8d, 0xc5, 0x2e, 0x29, 0xd8, 0xa3, 0x14, 0x8b, 0x13,
+    0x14, 0x62, 0x9d, 0x8a, 0x5c, 0x53, 0xb0, 0x5c, 0x68, 0x14, 0xe0, 0x29, 0x40, 0xa5, 0xda,
+    0x7d, 0x29, 0xd8, 0x43, 0x71, 0x4b, 0x4e, 0xda, 0x69, 0x42, 0xf3, 0x45, 0x80, 0x6a, 0xa9,
+    0x35, 0x66, 0x2b, 0x7c, 0xf2, 0x78, 0xa7, 0x43, 0x16, 0x79, 0x35, 0x60, 0xba, 0xa0, 0xeb,
+    0x5a, 0xc6, 0x3d, 0xc8, 0x94, 0xba, 0x21, 0xa2, 0x24, 0x41, 0x59, 0x97, 0x33, 0xc9, 0x63,
+    0x79, 0x6b, 0xa8, 0x5b, 0x9c, 0x4b, 0x6d, 0x2a, 0xc8, 0xa7, 0xe8, 0x73, 0xfd, 0x2a, 0xe4,
+    0xb2, 0x96, 0xe0, 0x74, 0xa8, 0x25, 0x8c, 0x4b, 0x13, 0x21, 0xe8, 0xc3, 0x15, 0x35, 0x17,
+    0x34, 0x6c, 0x87, 0x1b, 0xad, 0xcf, 0xa9, 0xf4, 0x4d, 0x5a, 0x1d, 0x6f, 0x45, 0xb3, 0xd4,
+    0xad, 0xdb, 0x31, 0xdc, 0xc4, 0xb2, 0x0f, 0x6c, 0x8e, 0x47, 0xe7, 0x5c, 0xff, 0x00, 0x8a,
+    0xac, 0xbc, 0xbb, 0x95, 0xbb, 0x41, 0xf2, 0xc8, 0x30, 0xd8, 0xf5, 0xae, 0x0f, 0xe0, 0xaf,
+    0x8a, 0x84, 0x3e, 0x7f, 0x85, 0xef, 0x64, 0xdb, 0x22, 0xb1, 0x96, 0xd7, 0x3d, 0xff, 0x00,
+    0xbc, 0xbf, 0xd7, 0xf3, 0xaf, 0x5d, 0xd4, 0x6d, 0x56, 0xfa, 0xce, 0x48, 0x5b, 0xa9, 0x19,
+    0x1e, 0xc6, 0xb8, 0x53, 0xb3, 0x3a, 0xfe, 0x28, 0x9e, 0x7d, 0x1b, 0x60, 0xe0, 0x9a, 0x94,
+    0x37, 0xad, 0x43, 0x34, 0x4d, 0x04, 0xad, 0x1b, 0x8c, 0x32, 0x9c, 0x1a, 0x15, 0xf8, 0xad,
+    0x4c, 0x4b, 0x21, 0xa9, 0xea, 0xd5, 0x5d, 0x5f, 0xf0, 0xa7, 0x86, 0xfc, 0x68, 0x19, 0x60,
+    0x35, 0x3c, 0x3d, 0x57, 0x0d, 0x4f, 0x0d, 0x40, 0x13, 0x86, 0xa7, 0x86, 0xaa, 0xe1, 0xa9,
+    0x43, 0x52, 0xb0, 0x16, 0x43, 0x54, 0x81, 0xb3, 0xde, 0xaa, 0x86, 0x3e, 0xb4, 0xf0, 0xf4,
+    0x58, 0x65, 0x80, 0xd4, 0xed, 0xd5, 0x5c, 0x3f, 0xbd, 0x38, 0x38, 0xa0, 0x2e, 0x4e, 0x1e,
+    0x94, 0x3f, 0xd6, 0xa1, 0x0d, 0x9a, 0x5c, 0xd2, 0x1d, 0xc9, 0x83, 0xfd, 0x69, 0x77, 0x8f,
+    0x7a, 0x83, 0x75, 0x2e, 0xea, 0x02, 0xe4, 0xdb, 0x85, 0x2e, 0xea, 0x83, 0x75, 0x2e, 0xef,
+    0x7a, 0x02, 0xe4, 0xfb, 0x89, 0xa4, 0xdd, 0x51, 0x03, 0x46, 0x68, 0x0b, 0x93, 0x6e, 0xa4,
+    0x2d, 0x50, 0xe6, 0xa5, 0x86, 0x33, 0x3c, 0xca, 0x8b, 0xc9, 0x27, 0x14, 0x01, 0xd0, 0x78,
+    0x7a, 0xdb, 0x2c, 0xf7, 0x0c, 0x3a, 0x0c, 0x0a, 0xf2, 0xff, 0x00, 0xda, 0x03, 0x5f, 0x77,
+    0x4d, 0x33, 0xc3, 0x16, 0xcd, 0x97, 0x99, 0xbe, 0xd3, 0x38, 0x1f, 0x8a, 0xa0, 0xfc, 0xf2,
+    0x7f, 0x01, 0x5e, 0xcb, 0x0a, 0xc3, 0xa6, 0x69, 0xa5, 0xe6, 0x71, 0x1c, 0x71, 0x21, 0x79,
+    0x1c, 0xf4, 0x50, 0x06, 0x49, 0x3f, 0x41, 0x5f, 0x2e, 0xcf, 0xa9, 0x49, 0xe2, 0xff, 0x00,
+    0x1b, 0xea, 0x5e, 0x21, 0x98, 0x1f, 0x2b, 0xcc, 0x2b, 0x6e, 0x0f, 0xf0, 0xa8, 0xe1, 0x47,
+    0xe0, 0x3f, 0x9d, 0x4c, 0x23, 0xcf, 0x3b, 0x0e, 0xac, 0xbd, 0x9c, 0x0b, 0xd6, 0x96, 0xe2,
+    0xd6, 0xce, 0x28, 0x17, 0xa2, 0x28, 0x15, 0x35, 0x2e, 0x28, 0xc5, 0x7a, 0xc9, 0x58, 0xf1,
+    0xf7, 0xd4, 0x05, 0x26, 0x29, 0xc0, 0x52, 0x10, 0x68, 0x0b, 0x09, 0x92, 0x29, 0x72, 0x69,
+    0x31, 0x4a, 0x05, 0x03, 0x13, 0x9a, 0x06, 0x69, 0xc1, 0x69, 0xe1, 0x68, 0xb0, 0xac, 0x30,
+    0x53, 0xc7, 0x38, 0xcd, 0x2e, 0xda, 0x50, 0xb8, 0xa0, 0x68, 0x72, 0x75, 0xab, 0x38, 0xe2,
+    0xa0, 0x45, 0xcb, 0x01, 0x56, 0x71, 0x81, 0x42, 0x34, 0x8a, 0x1b, 0x8a, 0x56, 0x6c, 0x2d,
+    0x07, 0x8a, 0x8d, 0xf9, 0xe9, 0x41, 0x57, 0xb1, 0x13, 0x39, 0x6e, 0xf4, 0xcd, 0xb9, 0xa9,
+    0x52, 0x22, 0xc6, 0xae, 0x43, 0x6b, 0xc6, 0x4f, 0x4a, 0x04, 0xa2, 0xd9, 0x4d, 0x20, 0x66,
+    0x35, 0x7a, 0x2b, 0x30, 0x06, 0x48, 0xa9, 0xc4, 0x6b, 0x18, 0xa4, 0x79, 0x4f, 0x4c, 0xd2,
+    0xb9, 0xaa, 0x82, 0x5b, 0x88, 0x55, 0x13, 0xd2, 0xa2, 0x79, 0x87, 0x6e, 0x94, 0xd7, 0x62,
+    0x7b, 0xd4, 0x2d, 0x9e, 0x68, 0xb0, 0x39, 0x0e, 0x79, 0x49, 0xa8, 0x89, 0xcf, 0x5a, 0x29,
+    0xaf, 0x4c, 0x86, 0xc4, 0x66, 0x23, 0x81, 0x50, 0x36, 0x49, 0xa9, 0xb1, 0x91, 0x48, 0x56,
+    0x82, 0x37, 0x2b, 0x95, 0xcf, 0x5a, 0xaf, 0x32, 0x05, 0x39, 0x15, 0x71, 0x96, 0xab, 0xce,
+    0x32, 0xb4, 0x89, 0x68, 0x10, 0x6e, 0x4e, 0x2a, 0xb4, 0xaa, 0x55, 0xaa, 0xc5, 0xbf, 0x5c,
+    0x51, 0x72, 0xa2, 0x80, 0xe8, 0x51, 0x7a, 0x88, 0xf4, 0xab, 0x05, 0x6a, 0x16, 0x42, 0x0d,
+    0x22, 0x0a, 0xf2, 0x01, 0x50, 0x95, 0xab, 0x4c, 0x94, 0xc2, 0x9c, 0x74, 0xa0, 0xd2, 0x32,
+    0xb1, 0x5c, 0xae, 0x69, 0x85, 0x3d, 0x2a, 0xc6, 0xc3, 0xe9, 0x4d, 0xd9, 0x48, 0xa5, 0x22,
+    0xb1, 0x5a, 0x4d, 0xb5, 0x67, 0x66, 0x7b, 0x50, 0x22, 0xc9, 0xa5, 0x62, 0xb9, 0xca, 0xfb,
+    0x69, 0xc2, 0x32, 0x7b, 0x55, 0x81, 0x06, 0x6a, 0x74, 0x82, 0x8b, 0x09, 0xcf, 0xb1, 0x59,
+    0x22, 0xc5, 0x4e, 0xb1, 0x7a, 0xd5, 0x85, 0x83, 0x15, 0x20, 0x88, 0x53, 0x23, 0x56, 0x56,
+    0x11, 0xfa, 0x0a, 0x78, 0x8c, 0xd5, 0xa1, 0x1f, 0xb5, 0x2f, 0x97, 0x4e, 0xc3, 0x48, 0xae,
+    0x23, 0xc5, 0x1b, 0x6a, 0xcf, 0x97, 0xc5, 0x34, 0xa5, 0x3b, 0x15, 0x62, 0x0c, 0x51, 0x8a,
+    0x90, 0xad, 0x34, 0x8a, 0x02, 0xc3, 0x31, 0x49, 0x8a, 0x7d, 0x21, 0xa0, 0x63, 0x31, 0x49,
+    0x8a, 0x75, 0x34, 0x9c, 0x53, 0x10, 0xd3, 0x4c, 0x34, 0xac, 0xd5, 0x13, 0x36, 0x28, 0x00,
+    0x63, 0x51, 0xb3, 0xd3, 0x5d, 0xea, 0x06, 0x7a, 0x96, 0xc3, 0x56, 0x3d, 0x9e, 0xa1, 0x67,
+    0xa6, 0xb3, 0x66, 0x98, 0x6a, 0x5b, 0x34, 0x51, 0x11, 0x9a, 0xa4, 0x47, 0xc2, 0xd4, 0x45,
+    0x49, 0xa7, 0x00, 0x7a, 0x54, 0x94, 0xd2, 0xb0, 0xac, 0xfc, 0xd4, 0x91, 0x64, 0x9a, 0x8f,
+    0x66, 0x4d, 0x59, 0x81, 0x3e, 0x61, 0x54, 0xae, 0x4c, 0xad, 0x63, 0x67, 0x49, 0x8f, 0x33,
+    0x02, 0x7b, 0x0a, 0xfa, 0x93, 0xc3, 0x36, 0xe2, 0xd3, 0xc3, 0x3a, 0x74, 0x20, 0x01, 0xb6,
+    0x05, 0xce, 0x3d, 0xc6, 0x6b, 0xe6, 0x4d, 0x25, 0x7f, 0x7a, 0x2b, 0xea, 0xab, 0x25, 0x09,
+    0x63, 0x6e, 0xab, 0xd0, 0x44, 0xa0, 0x7e, 0x55, 0xcf, 0x8c, 0x7e, 0xec, 0x51, 0xd1, 0x49,
+    0x7e, 0xec, 0xf1, 0xaf, 0x8a, 0xf2, 0x17, 0xd4, 0xb1, 0x9e, 0x02, 0x12, 0x3f, 0x32, 0x3f,
+    0xa5, 0x78, 0xdd, 0xea, 0xf5, 0xaf, 0x5f, 0xf8, 0x9e, 0x73, 0xa9, 0x00, 0x7f, 0xe7, 0x90,
+    0xff, 0x00, 0xd0, 0x9a, 0xbc, 0x92, 0xf0, 0x72, 0x6b, 0x6a, 0x5f, 0xc2, 0x41, 0x8b, 0xd2,
+    0x66, 0x2c, 0x83, 0x9a, 0x89, 0x90, 0xe7, 0x91, 0x8a, 0xb6, 0xd1, 0xe4, 0xf4, 0xad, 0x7b,
+    0x7d, 0x12, 0x5d, 0x4e, 0xc6, 0x69, 0xed, 0xd3, 0x71, 0xb7, 0x8c, 0x3c, 0x81, 0x7a, 0x85,
+    0xe9, 0x9c, 0x7a, 0x56, 0x6e, 0x17, 0x21, 0x4b, 0xa2, 0x39, 0xa2, 0x94, 0xd2, 0xb5, 0x7a,
+    0x4b, 0x66, 0x46, 0x2a, 0x46, 0x08, 0xa8, 0x4c, 0x47, 0xd2, 0xb2, 0x74, 0xca, 0x52, 0x4c,
+    0xaa, 0x56, 0x8d, 0x95, 0x60, 0xa6, 0x3b, 0x53, 0x5b, 0x00, 0x54, 0x72, 0x58, 0x77, 0x21,
+    0xda, 0x05, 0x30, 0xe0, 0x53, 0xdd, 0xaa, 0x16, 0x39, 0xa8, 0x63, 0x02, 0x69, 0x84, 0xd0,
+    0x4d, 0x34, 0x9a, 0xcd, 0xb1, 0x8b, 0x9a, 0x4a, 0x4a, 0x5a, 0x40, 0x4f, 0x11, 0xca, 0xd3,
+    0x27, 0x1c, 0xe6, 0x96, 0x23, 0xc1, 0xa5, 0x98, 0x65, 0x73, 0x57, 0xbc, 0x44, 0x57, 0xa5,
+    0x22, 0x92, 0x9c, 0xdf, 0x74, 0x1a, 0xcc, 0x62, 0x0e, 0xb4, 0xbb, 0x8d, 0x36, 0x96, 0x9a,
+    0x01, 0xe4, 0xf1, 0x4c, 0xa5, 0x27, 0x34, 0x94, 0x00, 0x54, 0x83, 0x81, 0x4d, 0x51, 0x93,
+    0x4f, 0x34, 0xd0, 0x09, 0x4d, 0x3c, 0x53, 0xa9, 0xad, 0x40, 0x86, 0xd1, 0x45, 0x2a, 0x8e,
+    0x69, 0x0c, 0x76, 0x30, 0x29, 0x0d, 0x38, 0xd3, 0x4d, 0x36, 0x03, 0x68, 0xa2, 0x8a, 0x90,
+    0x0a, 0x5a, 0x41, 0x4e, 0xc5, 0x30, 0x1b, 0x46, 0x29, 0x48, 0xa4, 0xa0, 0x02, 0x96, 0x92,
+    0x96, 0x80, 0x12, 0x92, 0x94, 0xd2, 0x52, 0x03, 0x7a, 0xe4, 0x0b, 0xbb, 0x34, 0xba, 0x8b,
+    0x97, 0x8f, 0xa8, 0xf5, 0x15, 0x02, 0x90, 0xca, 0x08, 0xe8, 0x68, 0xb3, 0x9b, 0xec, 0x97,
+    0x5e, 0x5b, 0x7f, 0xaa, 0x93, 0xa7, 0xf8, 0x53, 0xa6, 0x8b, 0xec, 0xd7, 0x1b, 0x07, 0xfa,
+    0xa9, 0x3e, 0x64, 0x3e, 0x9e, 0xd5, 0xd6, 0xf5, 0xf7, 0xbe, 0xf2, 0x36, 0xd0, 0x31, 0x45,
+    0x28, 0x19, 0xa5, 0x02, 0x9d, 0x80, 0x4c, 0x54, 0x17, 0x6d, 0xb6, 0x20, 0xbd, 0x37, 0x1c,
+    0x13, 0xed, 0x56, 0x71, 0x49, 0x24, 0x42, 0x44, 0x2a, 0x7f, 0x03, 0xe9, 0x43, 0x5a, 0x59,
+    0x0c, 0xb3, 0x26, 0xa2, 0x96, 0xf6, 0x49, 0x6f, 0x02, 0x16, 0x5c, 0x63, 0x77, 0x6a, 0xc5,
+    0x00, 0x2b, 0x16, 0x5e, 0x0a, 0x9e, 0xa3, 0xb5, 0x5f, 0xb0, 0x1b, 0xf7, 0xdb, 0x4b, 0xf7,
+    0x85, 0x53, 0x91, 0x3c, 0xb9, 0xa4, 0x46, 0xcf, 0xa5, 0x44, 0xdb, 0x69, 0x31, 0x45, 0x25,
+    0xb1, 0xd2, 0x58, 0x48, 0xb7, 0xfa, 0x64, 0x96, 0x92, 0xb7, 0xce, 0xea, 0x42, 0x13, 0xdf,
+    0x8f, 0xf1, 0xac, 0x98, 0x58, 0xbc, 0x63, 0x3f, 0x78, 0x70, 0xc3, 0xdc, 0x53, 0xb4, 0xb2,
+    0xdf, 0x66, 0xcf, 0x39, 0x0c, 0x70, 0x68, 0x2b, 0x8b, 0xe9, 0x71, 0xce, 0xec, 0x31, 0xfa,
+    0xd6, 0xbb, 0xa4, 0xc9, 0x4a, 0xcd, 0xd8, 0x76, 0x29, 0x71, 0x4e, 0x0b, 0xeb, 0x4e, 0x03,
+    0x1d, 0x05, 0x3b, 0x0c, 0x66, 0xd3, 0x4b, 0xb7, 0xde, 0x9f, 0x8a, 0x31, 0x4e, 0xc0, 0x25,
+    0x14, 0xec, 0x51, 0x8a, 0x76, 0x01, 0xb8, 0xa7, 0x28, 0xe6, 0x97, 0x14, 0xa0, 0x53, 0x48,
+    0x09, 0x7c, 0xcc, 0x2e, 0x05, 0x44, 0x49, 0x3d, 0xe9, 0x68, 0xc5, 0x53, 0xbb, 0x15, 0x84,
+    0xc5, 0x2e, 0x29, 0x71, 0x4a, 0x05, 0x3b, 0x01, 0x4a, 0x69, 0x2e, 0x34, 0xeb, 0xdb, 0x7d,
+    0x52, 0xc9, 0xcc, 0x77, 0x16, 0xee, 0x1c, 0x32, 0xf6, 0x23, 0xa1, 0xaf, 0xa5, 0x7c, 0x19,
+    0xe2, 0x9b, 0x6f, 0x16, 0xf8, 0x7a, 0x1d, 0x42, 0x26, 0x51, 0x30, 0x1b, 0x2e, 0x23, 0x07,
+    0xfd, 0x5c, 0x9d, 0xc7, 0xd3, 0xb8, 0xaf, 0x9d, 0xca, 0x06, 0x52, 0xa4, 0x02, 0x0f, 0x51,
+    0x56, 0xfc, 0x27, 0xe2, 0x4b, 0xaf, 0x02, 0x6b, 0xa2, 0xe5, 0x43, 0xc9, 0xa6, 0xce, 0x42,
+    0xcf, 0x10, 0xf4, 0xf5, 0x1e, 0xe2, 0xb9, 0x6b, 0x53, 0xb3, 0xe6, 0x46, 0x94, 0xe7, 0x66,
+    0x7b, 0xcf, 0x88, 0xf4, 0xbd, 0xe3, 0xed, 0x50, 0xaf, 0x23, 0xef, 0x62, 0xb9, 0x51, 0xc5,
+    0x77, 0xda, 0x6e, 0xa7, 0x63, 0xae, 0xe9, 0x91, 0xdd, 0xd9, 0xcc, 0x93, 0xdb, 0x4c, 0xb9,
+    0x0c, 0x0f, 0xe8, 0x7d, 0xeb, 0x9a, 0xd6, 0xb4, 0x86, 0xb4, 0x94, 0xcd, 0x10, 0xcc, 0x4d,
+    0xcf, 0x1d, 0xab, 0x38, 0xbe, 0x85, 0xce, 0x3d, 0x51, 0x92, 0x0d, 0x48, 0x1a, 0xa0, 0x07,
+    0x06, 0x9e, 0x1a, 0xac, 0xcc, 0x9c, 0x3d, 0x38, 0x3f, 0x35, 0x00, 0x6a, 0x70, 0x6a, 0x43,
+    0x2c, 0x06, 0xf7, 0xa7, 0x06, 0xaa, 0xe0, 0xfb, 0xd3, 0x83, 0x1a, 0x00, 0x9c, 0x1a, 0x78,
+    0x6a, 0xad, 0xbe, 0xa4, 0x0e, 0x3d, 0x68, 0x19, 0x38, 0x6a, 0x5d, 0xd5, 0x08, 0x60, 0x69,
+    0xd9, 0xf7, 0xa0, 0x09, 0x83, 0xe3, 0xd2, 0x9c, 0x1f, 0x9a, 0x83, 0x34, 0xec, 0xd0, 0x32,
+    0x6d, 0xe2, 0x94, 0x38, 0xa8, 0x37, 0x52, 0xee, 0x34, 0x58, 0x44, 0xfb, 0xe8, 0xdf, 0x50,
+    0x03, 0x4b, 0xba, 0x80, 0x26, 0xdf, 0x4b, 0xbf, 0xde, 0xa0, 0xcd, 0x21, 0x6e, 0xc3, 0xad,
+    0x00, 0x58, 0x0d, 0x92, 0x06, 0x6b, 0xa6, 0xf0, 0xfe, 0x9c, 0x41, 0xfb, 0x4c, 0x83, 0x81,
+    0xf7, 0x7d, 0xcd, 0x67, 0xe8, 0x7a, 0x2b, 0xdd, 0xb0, 0x9e, 0x60, 0x56, 0x11, 0xfa, 0xfb,
+    0x57, 0x27, 0xf1, 0x53, 0xe2, 0x9c, 0x3a, 0x0d, 0xbc, 0xbe, 0x1e, 0xf0, 0xfc, 0xa1, 0xb5,
+    0x26, 0x1e, 0x5c, 0xd3, 0x46, 0x72, 0x2d, 0x87, 0xa0, 0xff, 0x00, 0x6f, 0xf9, 0x7d, 0x7a,
+    0x44, 0x9f, 0x43, 0x48, 0xab, 0x7b, 0xcc, 0xcc, 0xf8, 0xbb, 0xf1, 0x28, 0x5c, 0xfd, 0xa3,
+    0xc1, 0xfa, 0x18, 0xf3, 0x24, 0x94, 0x88, 0xae, 0xae, 0x55, 0xb8, 0xeb, 0xcc, 0x6b, 0xfd,
+    0x4f, 0xd4, 0x57, 0x23, 0xa6, 0x69, 0xeb, 0xa7, 0xd8, 0x45, 0x6e, 0xbc, 0x95, 0x19, 0x63,
+    0xea, 0x7b, 0xd6, 0x3f, 0x87, 0xb4, 0x57, 0xb6, 0x6f, 0xb7, 0x5d, 0x82, 0x6e, 0x1f, 0x95,
+    0x0d, 0xc9, 0x5c, 0xf7, 0x3e, 0xf5, 0xd2, 0x29, 0xf5, 0xae, 0xcc, 0x3d, 0x2e, 0x55, 0xcc,
+    0xf7, 0x38, 0x31, 0x15, 0x79, 0xdd, 0x83, 0x6d, 0x26, 0xda, 0x92, 0x8c, 0x57, 0x55, 0xce,
+    0x72, 0x32, 0xb4, 0x62, 0xa4, 0xc5, 0x28, 0x5c, 0xd0, 0x16, 0x21, 0xc5, 0x2a, 0xae, 0x6a,
+    0x6d, 0x94, 0xa1, 0x68, 0x1d, 0x88, 0xc0, 0xa7, 0x85, 0xa7, 0x04, 0xcf, 0x6a, 0x78, 0x43,
+    0x9a, 0x03, 0x94, 0x60, 0x4f, 0x5a, 0x5d, 0x9c, 0xd4, 0x9b, 0x4f, 0xa5, 0x18, 0x23, 0xb1,
+    0xa4, 0x50, 0xaa, 0x9b, 0x79, 0xad, 0x5d, 0x1f, 0x4a, 0x9b, 0x57, 0xbc, 0x5b, 0x68, 0x70,
+    0x1b, 0x19, 0x66, 0x3d, 0x00, 0xac, 0xd1, 0x5a, 0xda, 0x1e, 0xae, 0xfa, 0x45, 0xe8, 0x9d,
+    0x17, 0x70, 0x23, 0x6b, 0x2f, 0xb5, 0x29, 0x5e, 0xda, 0x1a, 0xd3, 0xe5, 0xe6, 0x5c, 0xdb,
+    0x16, 0xb5, 0xff, 0x00, 0x0b, 0x4f, 0xa2, 0xc4, 0x92, 0xb4, 0x8b, 0x2a, 0x31, 0xc6, 0xe0,
+    0x31, 0xcd, 0x73, 0xcb, 0x1e, 0xe6, 0xc6, 0x2b, 0xaa, 0xd7, 0x7c, 0x47, 0x26, 0xbd, 0x14,
+    0x70, 0x2c, 0x46, 0x38, 0x94, 0xe7, 0x9e, 0xa4, 0xd6, 0x4a, 0x5b, 0xac, 0x4b, 0x93, 0xd6,
+    0xa6, 0x0e, 0x5c, 0xbe, 0xf6, 0xe6, 0x95, 0x21, 0x07, 0x2f, 0x73, 0x62, 0x08, 0xad, 0x82,
+    0x0c, 0x91, 0x4f, 0x76, 0x0a, 0x29, 0xce, 0xc4, 0xe7, 0x03, 0xf0, 0xa8, 0x58, 0x63, 0xad,
+    0x31, 0x6d, 0xb1, 0x1b, 0x48, 0x4d, 0x5a, 0xd3, 0xad, 0xed, 0x2e, 0x5a, 0x6f, 0xb5, 0xdc,
+    0x18, 0x42, 0xa6, 0x57, 0x1d, 0xcd, 0x53, 0x24, 0x76, 0xa2, 0x9d, 0x84, 0x9e, 0xa3, 0x48,
+    0xa8, 0x9b, 0xad, 0x48, 0xcc, 0x05, 0x44, 0xde, 0xf4, 0xcc, 0xd8, 0x84, 0x54, 0x6c, 0x47,
+    0x4a, 0x1d, 0xfb, 0x54, 0x4c, 0xd4, 0x10, 0xd9, 0x29, 0x60, 0x05, 0x3f, 0xec, 0xd7, 0x0f,
+    0x68, 0xd7, 0x4b, 0x19, 0x30, 0xa9, 0xc1, 0x6a, 0xaa, 0x4d, 0x3c, 0x5c, 0xce, 0x2d, 0xcd,
+    0xb8, 0x95, 0x84, 0x2c, 0x72, 0x53, 0x3c, 0x66, 0x86, 0x09, 0xae, 0xa4, 0x6c, 0xf5, 0x5d,
+    0xdb, 0xb5, 0x4d, 0xb4, 0x9a, 0x4f, 0x20, 0x9e, 0xc6, 0x91, 0x3a, 0xb2, 0x04, 0x6d, 0xa6,
+    0x89, 0x5f, 0x75, 0x4c, 0x6d, 0xc8, 0x1d, 0x29, 0x3c, 0x8f, 0x6a, 0x05, 0x66, 0x54, 0x22,
+    0x9a, 0x56, 0xad, 0x98, 0x40, 0xea, 0x29, 0x86, 0x3c, 0x0a, 0x02, 0xc5, 0x32, 0x9c, 0xd3,
+    0x4a, 0x55, 0xa2, 0xb4, 0xc2, 0x94, 0x0a, 0xc5, 0x72, 0x94, 0xdf, 0x2f, 0x3d, 0xaa, 0xd6,
+    0xcf, 0x6a, 0x70, 0x8a, 0x90, 0x58, 0xaa, 0x21, 0xa7, 0xac, 0x03, 0xd2, 0xad, 0x08, 0xc5,
+    0x3c, 0x47, 0x45, 0x8a, 0x48, 0xae, 0xb0, 0x81, 0xda, 0x9e, 0x10, 0x54, 0xfb, 0x29, 0xc1,
+    0x3f, 0x0a, 0x76, 0x29, 0x22, 0x10, 0x94, 0xf1, 0x1d, 0x4a, 0x17, 0xd0, 0x52, 0xed, 0xa2,
+    0xc5, 0x24, 0x45, 0xb4, 0x7a, 0x52, 0xe2, 0xa4, 0x22, 0x9a, 0x69, 0x94, 0x46, 0x69, 0x0d,
+    0x3f, 0x19, 0x34, 0x87, 0x02, 0x80, 0x23, 0x35, 0x0b, 0x0e, 0x2a, 0x56, 0x35, 0x1b, 0x1a,
+    0x04, 0x46, 0x69, 0xa6, 0x86, 0x22, 0xa3, 0x67, 0xa0, 0x57, 0x06, 0x6c, 0x54, 0x4c, 0xd4,
+    0x8c, 0xd5, 0x13, 0x35, 0x2b, 0x93, 0x70, 0x67, 0xa8, 0x99, 0xe9, 0x19, 0xaa, 0xac, 0xd7,
+    0x50, 0xc1, 0x9d, 0xf2, 0x0c, 0xfa, 0x0e, 0x4d, 0x4b, 0x92, 0x5a, 0xb2, 0xa3, 0x16, 0xc9,
+    0x58, 0x93, 0x4c, 0xc1, 0xaa, 0x0f, 0xaa, 0xb3, 0x9d, 0xb6, 0xf0, 0x96, 0x3e, 0xa6, 0x90,
+    0x47, 0xa9, 0xdc, 0x75, 0x1e, 0x58, 0xf7, 0xe2, 0xb1, 0x75, 0xa2, 0xfe, 0x1d, 0x4d, 0xb9,
+    0x2d, 0xbe, 0x85, 0xe3, 0x81, 0xd4, 0x81, 0xf5, 0x35, 0x1b, 0x4d, 0x0a, 0xf5, 0x71, 0xf8,
+    0x53, 0x13, 0x48, 0x76, 0x00, 0xcb, 0x70, 0xe4, 0xf7, 0x0a, 0x2a, 0x55, 0xd2, 0xed, 0xe3,
+    0xfb, 0xc0, 0xb7, 0xfb, 0xc6, 0x9f, 0xbe, 0xfa, 0x0b, 0x9a, 0x0b, 0xa9, 0x09, 0xbc, 0x84,
+    0x74, 0xc9, 0xa6, 0x9b, 0xc2, 0x7e, 0xec, 0x7f, 0xa1, 0xab, 0x7b, 0x2d, 0xa2, 0xe3, 0xe5,
+    0x1f, 0x4a, 0x96, 0x29, 0xad, 0x57, 0xa9, 0x50, 0x7d, 0xe9, 0xda, 0x5d, 0x58, 0xf9, 0x97,
+    0x44, 0x50, 0x59, 0x2e, 0xa4, 0xfb, 0xb1, 0xb7, 0xfd, 0xf3, 0x56, 0xa0, 0x8a, 0xf9, 0x9b,
+    0xee, 0xe3, 0xea, 0x6a, 0xd7, 0xda, 0xe0, 0xec, 0xe0, 0xd4, 0x91, 0x5e, 0x45, 0x91, 0x83,
+    0x54, 0xa3, 0xe6, 0x27, 0x27, 0xd8, 0xd8, 0xd2, 0x21, 0x9e, 0x29, 0x03, 0xca, 0x41, 0x1d,
+    0x30, 0x0d, 0x7d, 0x57, 0x61, 0x22, 0xcb, 0xa7, 0xdb, 0x48, 0xbd, 0x1a, 0x25, 0x23, 0xf2,
+    0xaf, 0x95, 0xac, 0x2e, 0xd5, 0xdd, 0x57, 0xd6, 0xbe, 0x9e, 0xf0, 0xe4, 0x9e, 0x6f, 0x87,
+    0x34, 0xf7, 0xfe, 0xf4, 0x2a, 0x6b, 0x0c, 0x62, 0xd1, 0x1d, 0x14, 0xed, 0xec, 0xf4, 0x3c,
+    0x77, 0xe2, 0x9a, 0x09, 0x35, 0x52, 0xa7, 0x20, 0x79, 0x63, 0xff, 0x00, 0x42, 0x6a, 0xf2,
+    0x2b, 0xbb, 0x48, 0xcb, 0x1f, 0xde, 0x37, 0xe7, 0x5e, 0xbd, 0xf1, 0x57, 0x8d, 0x58, 0xff,
+    0x00, 0xd7, 0x21, 0xff, 0x00, 0xa1, 0x35, 0x79, 0x1d, 0xd0, 0x39, 0x3d, 0x6b, 0x68, 0x59,
+    0xd3, 0x44, 0xe2, 0x9f, 0xef, 0x34, 0x33, 0xfe, 0xc7, 0xf3, 0x71, 0x31, 0xfc, 0xeb, 0xbd,
+    0xf8, 0x61, 0x70, 0x34, 0xff, 0x00, 0x14, 0x5a, 0xc5, 0x3b, 0x6f, 0x86, 0x72, 0x62, 0x70,
+    0x7b, 0x82, 0x38, 0x1f, 0x9e, 0x2b, 0x87, 0x40, 0x77, 0x74, 0xae, 0x9b, 0xc2, 0xae, 0xd0,
+    0xeb, 0xb6, 0x52, 0x0e, 0xa9, 0x32, 0x30, 0xff, 0x00, 0xbe, 0x85, 0x2e, 0x45, 0x66, 0x45,
+    0x39, 0xb5, 0x52, 0x26, 0xaf, 0xc4, 0xdf, 0x07, 0xbe, 0x85, 0xe2, 0x59, 0x84, 0x2a, 0xd1,
+    0xda, 0xcd, 0xfb, 0xc8, 0x1b, 0x1c, 0x10, 0x7a, 0x8f, 0xc0, 0xff, 0x00, 0x4a, 0xe0, 0x25,
+    0xb5, 0x95, 0x7a, 0x4d, 0x5f, 0x56, 0x7c, 0x43, 0xd0, 0x13, 0x5f, 0xf0, 0xa3, 0xc8, 0xa8,
+    0x1a, 0xe2, 0x05, 0xf3, 0x63, 0x38, 0xe7, 0xa7, 0x23, 0xf1, 0xaf, 0x99, 0x2f, 0x61, 0x31,
+    0x3b, 0x2e, 0x3a, 0x56, 0x74, 0xe4, 0xaa, 0x46, 0xef, 0x72, 0xaa, 0xa7, 0x17, 0x75, 0xb3,
+    0x30, 0xde, 0x29, 0xc7, 0xfc, 0xb4, 0x07, 0xf0, 0xa8, 0x4c, 0x73, 0x93, 0xc9, 0x5a, 0xb7,
+    0x29, 0xc1, 0xe7, 0x8a, 0x87, 0xcd, 0x51, 0xd4, 0xd6, 0x72, 0x8a, 0xb8, 0xd6, 0xc5, 0x66,
+    0x8e, 0x5e, 0xea, 0x3f, 0x03, 0x50, 0xb6, 0xe1, 0xc1, 0x53, 0x56, 0xda, 0x40, 0x47, 0xca,
+    0xc3, 0xf1, 0xaa, 0xce, 0xec, 0x7a, 0xed, 0xfc, 0x2b, 0x09, 0xa4, 0xb6, 0x29, 0x10, 0x93,
+    0x49, 0x4b, 0x49, 0x59, 0x0c, 0x5c, 0xd1, 0x49, 0x45, 0x00, 0x4b, 0x19, 0xe6, 0xa4, 0x90,
+    0x65, 0x2a, 0xba, 0x92, 0x0f, 0x15, 0x68, 0xf2, 0x95, 0x71, 0xd5, 0x08, 0xa9, 0x4f, 0xeb,
+    0x1d, 0x32, 0x9e, 0xbc, 0xa9, 0x15, 0x28, 0x63, 0x29, 0x71, 0x49, 0x4e, 0xa1, 0x00, 0x62,
+    0x92, 0x96, 0x8e, 0xf4, 0xc0, 0x7a, 0x8c, 0x0a, 0x5a, 0x3b, 0x51, 0x4c, 0x42, 0x1a, 0x61,
+    0xeb, 0x52, 0x62, 0x8f, 0x2c, 0x9a, 0x56, 0x6c, 0x64, 0x78, 0xa7, 0xa0, 0xa3, 0x18, 0xa7,
+    0x81, 0xc5, 0x34, 0xb5, 0x10, 0x84, 0x53, 0x1a, 0xa4, 0xc6, 0x69, 0x8c, 0x28, 0x60, 0x33,
+    0x14, 0x62, 0x96, 0x8a, 0x91, 0x80, 0xa7, 0x53, 0x41, 0xe6, 0x94, 0xd3, 0x01, 0x09, 0xa6,
+    0xd2, 0x9a, 0x4a, 0x40, 0x14, 0xb4, 0x94, 0xb4, 0x00, 0x1a, 0x6d, 0x2e, 0x68, 0xa4, 0x06,
+    0xa4, 0xa9, 0xbc, 0x18, 0x9c, 0x6c, 0x90, 0x72, 0x3f, 0xfa, 0xd5, 0x3c, 0x12, 0x0b, 0xcb,
+    0x76, 0xb7, 0x97, 0x89, 0x57, 0xa1, 0xf4, 0x3e, 0xb4, 0xd0, 0xe1, 0x71, 0x15, 0xc6, 0x4c,
+    0x7f, 0xc1, 0x27, 0x75, 0xa8, 0xae, 0x22, 0x96, 0x19, 0x55, 0xd4, 0xfe, 0xf0, 0x7d, 0xd6,
+    0x1d, 0x1c, 0x7f, 0x8d, 0x75, 0xed, 0xa9, 0x04, 0x91, 0x96, 0xc9, 0x47, 0x18, 0x91, 0x4e,
+    0x18, 0x54, 0x80, 0x53, 0x37, 0x0b, 0xb8, 0xd6, 0x68, 0x8e, 0x25, 0x5e, 0x30, 0x7b, 0xfb,
+    0x1a, 0x7c, 0x6c, 0x24, 0x5c, 0x8e, 0xbd, 0xc7, 0xa1, 0xaa, 0x40, 0x2e, 0x29, 0x71, 0x4e,
+    0x0a, 0x4d, 0x38, 0x28, 0xaa, 0x11, 0x56, 0x5c, 0xc1, 0x2a, 0x5d, 0x28, 0xc9, 0x43, 0xf3,
+    0x0f, 0x51, 0x4b, 0xaa, 0xa2, 0xb1, 0x8e, 0xe2, 0x3e, 0x8e, 0x3a, 0xd5, 0x96, 0x50, 0xca,
+    0x54, 0x8c, 0x82, 0x30, 0x6a, 0x86, 0xf0, 0xb6, 0x73, 0x5a, 0xca, 0xdf, 0x34, 0x4d, 0xb9,
+    0x33, 0xdc, 0x54, 0x4b, 0x66, 0xbb, 0x8f, 0xcc, 0x97, 0x49, 0x27, 0x64, 0x84, 0x9e, 0xfd,
+    0x2a, 0x4b, 0x63, 0xe6, 0x3c, 0xd2, 0xff, 0x00, 0x79, 0xf0, 0x3e, 0x82, 0xa8, 0xd9, 0xdc,
+    0x18, 0x63, 0x98, 0x6c, 0x24, 0x91, 0x90, 0x47, 0x6a, 0xd3, 0xb5, 0x8b, 0xcb, 0xb6, 0x45,
+    0x3d, 0x71, 0x93, 0x4e, 0x9b, 0xe6, 0x49, 0x76, 0x06, 0x3f, 0x14, 0xb4, 0xed, 0xb4, 0xaa,
+    0x85, 0x8e, 0x00, 0xad, 0x92, 0x24, 0x65, 0x2e, 0x2a, 0xe2, 0x59, 0x33, 0x2e, 0x4d, 0x46,
+    0xf6, 0xcc, 0xbd, 0x29, 0xf2, 0xb2, 0x79, 0xe2, 0x57, 0xc5, 0x3b, 0x14, 0xff, 0x00, 0x29,
+    0xbd, 0x29, 0x36, 0x1f, 0x4a, 0x39, 0x4a, 0xba, 0x1b, 0x8a, 0x5c, 0x52, 0xe2, 0x9c, 0x16,
+    0xa9, 0x20, 0xb8, 0xdc, 0x50, 0x05, 0x3c, 0x2d, 0x38, 0x0a, 0x62, 0xb8, 0xc0, 0xb9, 0xa7,
+    0x6d, 0x14, 0xec, 0x52, 0x81, 0x41, 0x37, 0x1b, 0xb4, 0x52, 0x3c, 0x6b, 0x22, 0x15, 0x75,
+    0xdc, 0xa7, 0xa8, 0x35, 0x26, 0xdf, 0x6a, 0x50, 0xb4, 0x0b, 0x98, 0x7f, 0x87, 0xfc, 0x47,
+    0xab, 0x78, 0x1e, 0xf8, 0xdc, 0x58, 0x31, 0x9e, 0xc1, 0xce, 0x66, 0xb5, 0x73, 0xc1, 0xf7,
+    0xf6, 0x3e, 0xf5, 0xee, 0x9e, 0x1b, 0xf1, 0x8e, 0x89, 0xe3, 0x2b, 0x23, 0xf6, 0x39, 0xd7,
+    0xcf, 0x0b, 0x99, 0x2d, 0xa4, 0xe1, 0xd3, 0xf0, 0xee, 0x3d, 0xc5, 0x78, 0x56, 0xd1, 0x8c,
+    0x63, 0x8a, 0xce, 0x93, 0x4f, 0x9a, 0xd6, 0xe5, 0x6f, 0x74, 0xc9, 0x9e, 0xde, 0xe5, 0x0e,
+    0xe5, 0x28, 0xc5, 0x48, 0x3e, 0xc7, 0xb5, 0x72, 0xd4, 0xa0, 0xd6, 0xb1, 0x35, 0xa7, 0x5a,
+    0xda, 0x33, 0xdf, 0x35, 0x6d, 0x11, 0xed, 0xdc, 0xc9, 0x08, 0xca, 0x1e, 0xde, 0x95, 0x88,
+    0x41, 0x07, 0x04, 0x62, 0xb9, 0xcf, 0x0d, 0xfc, 0x65, 0x96, 0xd9, 0x05, 0x87, 0x8a, 0xad,
+    0x5e, 0x4c, 0x71, 0xf6, 0xa8, 0x94, 0x6e, 0xff, 0x00, 0x81, 0x2f, 0x7f, 0xa8, 0xfc, 0xab,
+    0xb7, 0x49, 0x34, 0xbd, 0x7a, 0xd7, 0xed, 0x9a, 0x4d, 0xe4, 0x37, 0x31, 0x1e, 0xf1, 0x9e,
+    0x57, 0xd9, 0x87, 0x50, 0x7e, 0xb5, 0x8a, 0x97, 0x46, 0x6a, 0xd2, 0x7a, 0xa3, 0x2e, 0x9c,
+    0x09, 0xa6, 0xc9, 0x1b, 0x44, 0xe5, 0x58, 0x60, 0x8a, 0x68, 0x38, 0xab, 0x20, 0x98, 0x1a,
+    0x70, 0x6a, 0x8b, 0x34, 0xb9, 0xa0, 0x09, 0x37, 0x53, 0x83, 0x55, 0x39, 0x2f, 0xad, 0x61,
+    0x07, 0xcc, 0xb9, 0x85, 0x31, 0xd7, 0x73, 0x81, 0x59, 0xd3, 0xf8, 0xaf, 0x43, 0xb6, 0x04,
+    0xc9, 0xa9, 0x41, 0x91, 0xd9, 0x4e, 0xe3, 0xfa, 0x50, 0x17, 0x37, 0xc3, 0x7b, 0xd3, 0xc3,
+    0xf6, 0xcd, 0x73, 0x03, 0xc6, 0xba, 0x07, 0xfd, 0x04, 0x13, 0xfe, 0xf9, 0x3f, 0xe1, 0x4f,
+    0x4f, 0x1a, 0xf8, 0x7c, 0x9c, 0x7f, 0x68, 0xc7, 0xf8, 0x83, 0xfe, 0x14, 0xae, 0x86, 0x74,
+    0xdb, 0xbd, 0xe9, 0xc1, 0xbd, 0xc5, 0x61, 0x47, 0xe2, 0x7d, 0x16, 0x62, 0x3c, 0xbd, 0x4e,
+    0xd8, 0xfd, 0x64, 0x02, 0xaf, 0x47, 0x7b, 0x6f, 0x36, 0x3c, 0xab, 0x88, 0x9f, 0x3d, 0x36,
+    0xb8, 0x34, 0xc5, 0x72, 0xfe, 0xef, 0x7a, 0x37, 0x7b, 0xd4, 0x1b, 0xe9, 0x77, 0xfa, 0xd0,
+    0x32, 0x7d, 0xde, 0xf4, 0xbb, 0xc5, 0x57, 0xdf, 0x57, 0x2d, 0x2c, 0xde, 0x70, 0xd2, 0x48,
+    0xe9, 0x14, 0x28, 0x32, 0xf2, 0x48, 0xdb, 0x55, 0x47, 0xa9, 0x27, 0xa5, 0x00, 0x86, 0xae,
+    0xe9, 0x18, 0x2a, 0x02, 0x49, 0xae, 0x8a, 0xc3, 0x43, 0x8a, 0xd6, 0xdc, 0xdf, 0xea, 0xb2,
+    0xa4, 0x16, 0xf1, 0x8d, 0xcc, 0x64, 0x6d, 0xa0, 0x0f, 0x52, 0x4f, 0x4a, 0xe3, 0xb5, 0x5f,
+    0x8a, 0x1e, 0x11, 0xf0, 0x9c, 0x6c, 0x9a, 0x71, 0xfe, 0xda, 0xd4, 0x80, 0xe3, 0xc9, 0xe2,
+    0x25, 0x3e, 0xee, 0x7a, 0xfe, 0x19, 0xaf, 0x2a, 0xd5, 0x75, 0xbf, 0x14, 0xfc, 0x41, 0xba,
+    0x33, 0x6a, 0x57, 0x8e, 0xb6, 0x61, 0xb2, 0x91, 0x0f, 0x96, 0x24, 0x1e, 0x8a, 0xa3, 0xa9,
+    0xf7, 0x3f, 0x9d, 0x46, 0xb2, 0x76, 0x89, 0x4d, 0xc6, 0x0a, 0xec, 0xee, 0xbc, 0x7d, 0xf1,
+    0x9a, 0x4b, 0x92, 0xfa, 0x17, 0x83, 0x81, 0x48, 0x8f, 0xee, 0xda, 0xf5, 0x47, 0xcc, 0xfe,
+    0xd1, 0x8e, 0xc3, 0xfd, 0xae, 0xbf, 0x4a, 0xe1, 0x34, 0x5f, 0x0f, 0x7d, 0x9d, 0xc5, 0xdd,
+    0xef, 0xcf, 0x70, 0x4e, 0xe0, 0x09, 0xce, 0xd3, 0xea, 0x7d, 0x4d, 0x68, 0x69, 0x9a, 0x1d,
+    0xae, 0x98, 0xbb, 0xa3, 0x52, 0xf2, 0xf7, 0x91, 0xba, 0xfe, 0x1e, 0x95, 0xa6, 0x16, 0xba,
+    0xe8, 0xe1, 0xf9, 0x75, 0x96, 0xe7, 0x1d, 0x5a, 0xee, 0x7a, 0x21, 0x00, 0xa5, 0xc1, 0xa7,
+    0x05, 0xa7, 0x85, 0xae, 0xa3, 0x9e, 0xc2, 0x2e, 0x71, 0x4b, 0x4b, 0x8c, 0x51, 0x48, 0x05,
+    0xa7, 0x2a, 0x83, 0x4d, 0xa5, 0x04, 0x8e, 0x45, 0x32, 0x91, 0x26, 0xc1, 0x46, 0xda, 0x15,
+    0x89, 0xeb, 0x4f, 0xdf, 0x40, 0xc6, 0xe0, 0x8a, 0x51, 0x91, 0xd4, 0x53, 0x81, 0x06, 0x8e,
+    0x28, 0x0b, 0x00, 0xe6, 0x8a, 0x5a, 0x0f, 0x4a, 0x43, 0x1a, 0x0e, 0x0e, 0x2a, 0x58, 0x90,
+    0xbb, 0x00, 0x2a, 0x3c, 0x64, 0xd6, 0x95, 0x84, 0x40, 0x29, 0x63, 0xd6, 0x87, 0xa2, 0x2a,
+    0x11, 0xbb, 0x27, 0x82, 0x11, 0x10, 0xc9, 0xeb, 0x4d, 0x91, 0x8b, 0x1e, 0x0f, 0x14, 0xe9,
+    0x5f, 0xe6, 0xc0, 0xe2, 0xa0, 0x2c, 0x00, 0xa8, 0x46, 0xfa, 0x01, 0xc2, 0x8c, 0x9a, 0xac,
+    0xef, 0x93, 0x4b, 0x23, 0x96, 0x3e, 0xd4, 0xca, 0xa3, 0x36, 0xc4, 0x38, 0x15, 0x1b, 0x31,
+    0xa7, 0x39, 0xa8, 0x99, 0xb0, 0x29, 0x90, 0xd8, 0x13, 0xeb, 0x51, 0x3c, 0x9d, 0x85, 0x23,
+    0x31, 0x27, 0x14, 0x82, 0x26, 0x63, 0x4c, 0x92, 0x33, 0xd6, 0x80, 0x8c, 0x7a, 0x0a, 0xb9,
+    0x1d, 0xae, 0x79, 0x23, 0x35, 0x60, 0x42, 0xaa, 0x3b, 0x52, 0x1a, 0x83, 0x66, 0x72, 0xdb,
+    0xb1, 0xeb, 0x53, 0x08, 0x15, 0x6a, 0xc3, 0x60, 0x1e, 0x29, 0x8c, 0xc0, 0x50, 0x57, 0x2a,
+    0x43, 0x7c, 0xb5, 0xc5, 0x34, 0x85, 0x14, 0x16, 0x27, 0xda, 0x98, 0x73, 0x40, 0x9b, 0x42,
+    0x1f, 0xa5, 0x44, 0xed, 0xe9, 0x52, 0x11, 0x4d, 0x29, 0x9e, 0xd9, 0xa0, 0x92, 0xbb, 0x73,
+    0x4c, 0x22, 0xac, 0x18, 0xe8, 0xf2, 0xa8, 0xb0, 0xac, 0x54, 0xd9, 0x4b, 0xe5, 0x8a, 0xb3,
+    0xe4, 0xd3, 0x84, 0x6a, 0x28, 0x15, 0x8a, 0xa2, 0x3a, 0x78, 0x8a, 0xa7, 0xc0, 0x1d, 0xa8,
+    0xdb, 0x41, 0x49, 0x11, 0x08, 0x87, 0x7a, 0x5d, 0xa2, 0xa5, 0xc5, 0x1b, 0x79, 0xa0, 0x76,
+    0x23, 0xdb, 0xed, 0x46, 0xda, 0x97, 0x68, 0xa3, 0x68, 0xc5, 0x03, 0xb1, 0x16, 0x29, 0x08,
+    0xa9, 0x0a, 0xd3, 0x4d, 0x03, 0x18, 0x69, 0x98, 0xcf, 0xd2, 0x9e, 0x71, 0x4c, 0x26, 0x81,
+    0x5c, 0x43, 0xc0, 0xe2, 0xa2, 0x66, 0xa5, 0x66, 0xa8, 0x98, 0xd0, 0x2b, 0x88, 0xc7, 0x35,
+    0x13, 0xb6, 0x29, 0x59, 0xaa, 0x26, 0x34, 0x0a, 0xe3, 0x19, 0xb2, 0x6a, 0x26, 0x63, 0x9a,
+    0x65, 0xd5, 0xd4, 0x36, 0xcb, 0xba, 0x59, 0x02, 0xfa, 0x0e, 0xe6, 0xb3, 0x7e, 0xd7, 0x7b,
+    0x7c, 0x71, 0x65, 0x06, 0xc4, 0x3f, 0xf2, 0xd1, 0xea, 0x25, 0x34, 0xb4, 0xea, 0x0a, 0x2d,
+    0xea, 0x5f, 0x92, 0x44, 0x8d, 0x4b, 0x3b, 0x05, 0x1e, 0xa4, 0xd6, 0x74, 0x9a, 0xa2, 0x3b,
+    0xf9, 0x76, 0xd1, 0xb4, 0xcf, 0xec, 0x38, 0xab, 0x11, 0x68, 0x1e, 0x63, 0x6f, 0xbd, 0x9d,
+    0xe5, 0x6f, 0x40, 0x78, 0xad, 0x38, 0xad, 0x61, 0xb6, 0x4d, 0xb1, 0x46, 0xa8, 0xbf, 0xec,
+    0x8a, 0x9b, 0x54, 0x97, 0x91, 0x56, 0x8c, 0x7c, 0xcc, 0x23, 0x65, 0xa9, 0xdd, 0x63, 0xcc,
+    0x61, 0x0a, 0x1e, 0xc0, 0xd5, 0x88, 0x34, 0x2b, 0x78, 0xf9, 0x94, 0x99, 0x1b, 0xde, 0xb6,
+    0x08, 0xa8, 0x64, 0x95, 0x63, 0xeb, 0xd6, 0x85, 0x4a, 0x37, 0xbb, 0xd7, 0xd4, 0x6e, 0xa4,
+    0xb6, 0x44, 0x69, 0x6b, 0x14, 0x43, 0x08, 0x80, 0x52, 0xb0, 0x45, 0xf4, 0x15, 0x1b, 0x4d,
+    0x23, 0x8f, 0x94, 0x60, 0x55, 0x39, 0x9e, 0x44, 0xe5, 0xce, 0x33, 0x57, 0x74, 0x84, 0xa2,
+    0xe4, 0xcb, 0x32, 0xce, 0x91, 0xae, 0x7a, 0xd6, 0x7c, 0xf7, 0x2d, 0x27, 0x45, 0xc0, 0xa6,
+    0x16, 0x69, 0x38, 0x55, 0x2d, 0x4e, 0x16, 0x93, 0x3f, 0x51, 0x8f, 0xad, 0x67, 0x29, 0x37,
+    0xb1, 0xac, 0x63, 0x18, 0xee, 0x57, 0x27, 0xd4, 0xd2, 0x6e, 0x15, 0x70, 0x58, 0x0f, 0xe2,
+    0x7f, 0xc0, 0x53, 0x64, 0xb5, 0x8d, 0x47, 0x1b, 0xb3, 0x59, 0x72, 0x48, 0xbe, 0x78, 0x95,
+    0x77, 0x0a, 0xb1, 0x6e, 0xc3, 0x70, 0xcd, 0x46, 0x62, 0x40, 0x3a, 0xd4, 0x6b, 0x20, 0x46,
+    0xa1, 0x7b, 0xaf, 0x52, 0x9a, 0xba, 0x3a, 0x9d, 0x3d, 0x82, 0xba, 0x9f, 0x4a, 0xfa, 0x6f,
+    0xc0, 0x77, 0x26, 0xe7, 0xc1, 0xd6, 0x0c, 0x4e, 0x76, 0x2e, 0xcf, 0xcb, 0x8a, 0xf9, 0x46,
+    0xca, 0xe5, 0xc9, 0x00, 0x2f, 0xe7, 0x5f, 0x47, 0xfc, 0x22, 0xbe, 0x17, 0x3e, 0x1c, 0x9a,
+    0x02, 0xf9, 0x68, 0xe5, 0xc8, 0x5f, 0x40, 0x47, 0xf8, 0xd3, 0xc4, 0xfb, 0xd4, 0xee, 0x2a,
+    0x3a, 0x27, 0x16, 0x72, 0x9f, 0x15, 0xe3, 0x29, 0xaa, 0x87, 0x6e, 0x17, 0xca, 0xc6, 0x7e,
+    0x8c, 0x4f, 0xf5, 0xaf, 0x1e, 0xbd, 0xb9, 0x8d, 0x58, 0x81, 0x93, 0x5e, 0xef, 0xf1, 0x76,
+    0xd8, 0xba, 0xdb, 0xbe, 0xde, 0x0e, 0xe1, 0x9f, 0xa8, 0x18, 0xfe, 0x46, 0xbc, 0x3a, 0xe6,
+    0xc5, 0x77, 0x7c, 0xc4, 0x7e, 0x15, 0x54, 0x5b, 0x74, 0x95, 0x87, 0x89, 0xf8, 0xd3, 0x7d,
+    0x91, 0x96, 0xb7, 0x59, 0x6f, 0x95, 0x2b, 0xa7, 0xf0, 0x9a, 0xbc, 0xfa, 0xd5, 0xaa, 0xe0,
+    0x73, 0x22, 0xe3, 0xfe, 0xfa, 0x15, 0x8b, 0x15, 0xac, 0x4a, 0xdd, 0x01, 0xfa, 0xd7, 0x65,
+    0xe0, 0xb8, 0xd7, 0xfe, 0x12, 0x2b, 0x1c, 0x00, 0x31, 0x2a, 0x9e, 0x3d, 0x8d, 0x56, 0xa9,
+    0x36, 0xcc, 0xe9, 0xda, 0x55, 0x12, 0x47, 0xd3, 0x0b, 0x18, 0x92, 0xcd, 0x63, 0x6e, 0x8d,
+    0x18, 0x07, 0xf2, 0xaf, 0x96, 0xbc, 0x7f, 0xa3, 0x3e, 0x9b, 0xe2, 0x3b, 0xbb, 0x74, 0x1b,
+    0x50, 0x39, 0x2a, 0x01, 0xec, 0x79, 0x1f, 0xce, 0xbe, 0xa9, 0x41, 0xb6, 0x35, 0x1e, 0x80,
+    0x0a, 0xf0, 0xbf, 0x8c, 0xb6, 0x1e, 0x56, 0xaf, 0x15, 0xc8, 0x40, 0x03, 0x82, 0x09, 0xf5,
+    0x3d, 0x7f, 0xa8, 0xae, 0x2c, 0x33, 0xf7, 0xad, 0xdc, 0xe8, 0x9a, 0xe6, 0x84, 0xbc, 0xb5,
+    0x3c, 0x36, 0xe2, 0xd9, 0xc1, 0x39, 0x35, 0x51, 0xa1, 0x23, 0xf8, 0xab, 0x56, 0xf3, 0xef,
+    0x1a, 0xce, 0x73, 0xcd, 0x5d, 0x48, 0xa4, 0xcc, 0xa0, 0xdb, 0x45, 0x73, 0x0f, 0x7d, 0xc6,
+    0x9a, 0x63, 0x3e, 0xb5, 0x31, 0x34, 0xd2, 0xdc, 0x56, 0x2d, 0x22, 0xc8, 0x0a, 0x11, 0x4d,
+    0xc1, 0xa9, 0x8b, 0x0a, 0x69, 0x61, 0x50, 0xd2, 0x19, 0x15, 0x14, 0xf2, 0x73, 0x49, 0x81,
+    0x4a, 0xc0, 0x34, 0x75, 0xab, 0x68, 0x72, 0x95, 0x57, 0x15, 0x62, 0x13, 0x91, 0x55, 0x1d,
+    0xc4, 0xc8, 0x1c, 0x61, 0xc8, 0xa5, 0x4e, 0xa6, 0x9d, 0x30, 0xc3, 0xfd, 0x69, 0x89, 0xf7,
+    0x85, 0x4e, 0xcc, 0x63, 0x4f, 0x5a, 0x29, 0x5b, 0xef, 0x1a, 0x4c, 0x52, 0x00, 0xcd, 0x28,
+    0x34, 0x98, 0x34, 0x50, 0x04, 0xc1, 0x94, 0x8e, 0xb4, 0xa0, 0x8e, 0xd5, 0x05, 0x14, 0xee,
+    0x05, 0xa5, 0xc6, 0x45, 0x58, 0x0a, 0x31, 0xc5, 0x67, 0x06, 0x61, 0xd0, 0xd4, 0xcb, 0x74,
+    0xe0, 0x60, 0x80, 0x6b, 0x48, 0xcd, 0x2d, 0xc9, 0x92, 0x6c, 0x92, 0x44, 0x1b, 0xa9, 0x3b,
+    0x53, 0x3c, 0xd0, 0xed, 0xcd, 0x38, 0x9e, 0x29, 0xdd, 0x6e, 0x02, 0x53, 0x1c, 0xd3, 0x89,
+    0xe2, 0xa2, 0x3d, 0x6a, 0x24, 0xc6, 0x19, 0xa4, 0xa2, 0x8a, 0x91, 0x8e, 0x5a, 0x09, 0xa6,
+    0xee, 0x3d, 0xa8, 0xda, 0x4d, 0x00, 0x04, 0xd2, 0x53, 0xb6, 0xd2, 0xe2, 0x8b, 0x00, 0xde,
+    0x68, 0xc5, 0x3b, 0x14, 0x62, 0x8b, 0x00, 0xdc, 0x52, 0x53, 0xa8, 0xa0, 0x0d, 0xe1, 0x18,
+    0x93, 0xe5, 0x61, 0x90, 0x7b, 0x52, 0xb4, 0x06, 0x14, 0x10, 0xcf, 0x93, 0x03, 0xfd, 0xc7,
+    0xfe, 0xe1, 0xf4, 0xa7, 0xa0, 0xda, 0x6a, 0xf0, 0x92, 0x39, 0x20, 0x31, 0xc8, 0x01, 0x56,
+    0x18, 0x20, 0xd7, 0xa0, 0xa2, 0x99, 0x8c, 0x9b, 0x47, 0x3e, 0xf1, 0xcb, 0x6f, 0x33, 0xed,
+    0x1f, 0xbc, 0x51, 0x96, 0x5f, 0xef, 0x8f, 0x51, 0x4b, 0x0d, 0xd7, 0x98, 0xfb, 0xd4, 0x62,
+    0x4f, 0xe2, 0x5f, 0xef, 0x0f, 0xf1, 0xab, 0x77, 0x09, 0x22, 0x9d, 0xaa, 0x73, 0x34, 0x3f,
+    0x34, 0x4f, 0xfd, 0xe5, 0xf4, 0xaa, 0xf7, 0x56, 0x42, 0x7b, 0x55, 0xd4, 0x6c, 0xd7, 0x0b,
+    0xff, 0x00, 0x2d, 0x63, 0x1f, 0xc0, 0xde, 0xde, 0xd5, 0x84, 0x93, 0x8b, 0xd0, 0xbb, 0xae,
+    0xa6, 0x8c, 0x69, 0xe6, 0xc6, 0x24, 0x4e, 0x54, 0xd0, 0x63, 0x2b, 0xd4, 0x56, 0x3e, 0x9f,
+    0xa9, 0xcb, 0x65, 0x3e, 0xf3, 0xf3, 0xc6, 0xdf, 0x7d, 0x0f, 0x7f, 0x7f, 0xad, 0x75, 0xd0,
+    0x1b, 0x6b, 0xf8, 0x04, 0xb0, 0x30, 0x65, 0x3d, 0x47, 0x70, 0x7d, 0xeb, 0x6a, 0x53, 0x8c,
+    0xd7, 0x99, 0x9c, 0xe4, 0xe0, 0xf5, 0xd8, 0xc5, 0x99, 0xfc, 0x98, 0x5a, 0x42, 0x3a, 0x0c,
+    0xd3, 0x1e, 0x7b, 0x7b, 0x5d, 0x2c, 0xe6, 0x3d, 0xd7, 0x57, 0x03, 0x97, 0x23, 0x80, 0x0d,
+    0x6d, 0xcb, 0xa7, 0x24, 0x8a, 0x50, 0x8c, 0x82, 0x30, 0x45, 0x63, 0x5e, 0x59, 0xfd, 0x9a,
+    0x2f, 0x22, 0xe4, 0xfe, 0xec, 0xff, 0x00, 0xab, 0x93, 0xfa, 0x7d, 0x69, 0xce, 0x2d, 0x6a,
+    0x82, 0x33, 0x8c, 0xb4, 0x2d, 0x68, 0x13, 0xda, 0x47, 0x67, 0x34, 0x17, 0x0a, 0x0e, 0xf6,
+    0xc1, 0x6c, 0x64, 0x74, 0xa2, 0x1b, 0x77, 0x69, 0x26, 0x86, 0x21, 0xe6, 0x79, 0x27, 0xaa,
+    0xff, 0x00, 0x77, 0xb1, 0xac, 0xbd, 0x36, 0x48, 0xd5, 0x1a, 0x32, 0xc0, 0x10, 0x49, 0xcf,
+    0xa8, 0xad, 0xcd, 0x24, 0xcd, 0xf6, 0x69, 0x6e, 0x50, 0x81, 0xe7, 0x36, 0x07, 0x1d, 0x87,
+    0x03, 0xfa, 0xd2, 0xa4, 0xee, 0x90, 0x4f, 0xdd, 0xbb, 0x2b, 0x6d, 0xab, 0x76, 0xd1, 0x83,
+    0x8f, 0x5a, 0x89, 0x94, 0xa9, 0xc1, 0xeb, 0x4f, 0x86, 0x4f, 0x2d, 0xeb, 0x72, 0x65, 0x76,
+    0xb4, 0x34, 0x40, 0xc0, 0xc5, 0x21, 0x40, 0xdd, 0xa9, 0x52, 0x45, 0x71, 0xc5, 0x3f, 0x6e,
+    0x68, 0x39, 0x75, 0x45, 0x76, 0x8c, 0x0a, 0x8d, 0xa2, 0x5c, 0x74, 0xab, 0x45, 0x73, 0x50,
+    0x4b, 0xf2, 0x8a, 0x65, 0x46, 0x4c, 0xa4, 0xeb, 0x86, 0xa6, 0x81, 0x9a, 0x90, 0x8c, 0x9a,
+    0x5d, 0xb4, 0x8d, 0xee, 0x30, 0x2d, 0x38, 0x2d, 0x3b, 0x14, 0xa0, 0x50, 0x2b, 0x8d, 0x02,
+    0x94, 0x0f, 0x6a, 0x78, 0x5a, 0x5c, 0x53, 0x15, 0xc6, 0xe2, 0x8c, 0x54, 0x8b, 0x19, 0x63,
+    0x53, 0x08, 0x80, 0xeb, 0x41, 0x2e, 0x49, 0x15, 0xc2, 0x1a, 0x78, 0x4a, 0xb2, 0xaa, 0x3d,
+    0x29, 0xdb, 0x46, 0x3a, 0x53, 0x21, 0xcc, 0xce, 0xb8, 0xb2, 0x82, 0xe9, 0x76, 0xcd, 0x18,
+    0x6f, 0x43, 0xdc, 0x56, 0x74, 0x7a, 0x6e, 0xa1, 0xa5, 0x5c, 0x8b, 0xad, 0x22, 0xf6, 0x48,
+    0x65, 0x1d, 0x36, 0xb6, 0xd3, 0xf4, 0xcf, 0x7f, 0xc6, 0xb7, 0x19, 0x70, 0x68, 0x0a, 0x4d,
+    0x44, 0xe9, 0x42, 0x7b, 0x97, 0x1a, 0xad, 0x6c, 0x47, 0x17, 0xc4, 0x2d, 0x6a, 0xd2, 0x40,
+    0xba, 0xbd, 0x9a, 0xdc, 0x63, 0xac, 0x80, 0x6c, 0x63, 0xf8, 0x8e, 0x0d, 0x6a, 0xcf, 0xf1,
+    0x1b, 0x4a, 0x16, 0xaa, 0xf0, 0xc1, 0x71, 0x24, 0xe7, 0xfe, 0x59, 0x15, 0xc6, 0x0f, 0xd6,
+    0xb3, 0x9a, 0x25, 0x90, 0x6d, 0x61, 0x91, 0xe9, 0x5c, 0xbd, 0x85, 0xbc, 0x6f, 0x73, 0x76,
+    0xe5, 0x07, 0xee, 0xdf, 0x8f, 0x6e, 0x6b, 0x9a, 0x54, 0x9c, 0x5a, 0x49, 0xee, 0x6f, 0x0a,
+    0xaa, 0x68, 0xdf, 0xb9, 0xf1, 0x9e, 0xbb, 0x7d, 0xc5, 0xb4, 0x51, 0x5a, 0x21, 0xef, 0xd4,
+    0xfe, 0xb5, 0x8b, 0x75, 0x7f, 0xaa, 0xcd, 0x71, 0x1c, 0x57, 0x3a, 0xa5, 0xc3, 0xb4, 0x9d,
+    0x95, 0x88, 0x15, 0x6e, 0xb3, 0x64, 0xf9, 0xb5, 0xa8, 0xc6, 0x78, 0x51, 0x44, 0xe9, 0xa8,
+    0xa4, 0x68, 0x49, 0xfd, 0x99, 0x13, 0x1c, 0xbb, 0xc8, 0xe7, 0xb9, 0x26, 0xa3, 0xbc, 0xb2,
+    0xb7, 0x82, 0xcd, 0xdd, 0x13, 0xe6, 0x18, 0xe4, 0x9f, 0x7a, 0xd3, 0x35, 0x4f, 0x53, 0x38,
+    0xb1, 0x6f, 0x72, 0x05, 0x69, 0x3a, 0x70, 0x8c, 0x5d, 0x90, 0x93, 0x77, 0x16, 0xde, 0xca,
+    0xd6, 0x5b, 0x78, 0xdc, 0xc6, 0x32, 0xca, 0x09, 0xa9, 0x3f, 0xb3, 0x6d, 0x0f, 0xfc, 0xb3,
+    0x1f, 0x9d, 0x47, 0xa7, 0xb9, 0x6b, 0x28, 0xfd, 0xb8, 0xab, 0x2a, 0xd9, 0xe9, 0x4e, 0x2a,
+    0x0e, 0x2b, 0x41, 0x3b, 0x99, 0xd7, 0xb6, 0x76, 0xf6, 0xa8, 0xa6, 0x35, 0xc3, 0xb1, 0xc7,
+    0x26, 0xab, 0x49, 0x00, 0x82, 0x3f, 0x36, 0x29, 0x5d, 0x48, 0x61, 0xd0, 0xd5, 0x9d, 0x5d,
+    0x89, 0x78, 0x47, 0xa5, 0x42, 0x33, 0x24, 0x2f, 0x19, 0xea, 0x05, 0x73, 0xd4, 0x4b, 0x99,
+    0xa4, 0x8b, 0x5b, 0x1a, 0x76, 0xf7, 0xfa, 0xed, 0x96, 0x05, 0xae, 0xad, 0x29, 0x1d, 0x42,
+    0xb3, 0x12, 0x3f, 0x5c, 0xd6, 0xc5, 0xb7, 0x8e, 0xbc, 0x41, 0x65, 0x8f, 0xb6, 0x5b, 0xc5,
+    0x73, 0x18, 0xee, 0x06, 0x0f, 0xe9, 0x5c, 0xa4, 0x53, 0x36, 0xc5, 0x39, 0xe5, 0x78, 0xad,
+    0x6b, 0x79, 0x84, 0xd1, 0x71, 0xd7, 0xb8, 0xaa, 0x84, 0x23, 0x3d, 0x9d, 0x84, 0xf4, 0x3a,
+    0x1b, 0x8f, 0x8a, 0x44, 0xc2, 0x05, 0x9e, 0x9b, 0xfb, 0xf3, 0xde, 0x57, 0xca, 0x83, 0xf4,
+    0x1d, 0x6b, 0x26, 0xf2, 0xe7, 0xc5, 0x9e, 0x27, 0x8c, 0x47, 0x7f, 0x76, 0xf1, 0xda, 0x13,
+    0x91, 0x09, 0x3b, 0x13, 0xfe, 0xf9, 0x1d, 0x7f, 0x1a, 0xc5, 0xbd, 0xb7, 0x96, 0x09, 0xfe,
+    0xd7, 0x02, 0xf0, 0x0e, 0x5b, 0x03, 0xa1, 0xae, 0xd3, 0x4d, 0xbc, 0x4b, 0xfb, 0x38, 0xe7,
+    0x43, 0x9c, 0x8f, 0x98, 0x7a, 0x1e, 0xe2, 0x9c, 0x29, 0x73, 0x49, 0xc6, 0x6c, 0xce, 0xad,
+    0x47, 0x14, 0x9c, 0x4c, 0xed, 0x3f, 0xc2, 0xd6, 0x96, 0x84, 0x3c, 0xe4, 0xcf, 0x27, 0xb8,
+    0xc2, 0x8f, 0xc2, 0xb7, 0x51, 0x02, 0x80, 0x00, 0x00, 0x0e, 0x30, 0x29, 0x71, 0x4e, 0x51,
+    0x5d, 0x91, 0x84, 0x62, 0xad, 0x14, 0x72, 0x4a, 0x4e, 0x5a, 0xb1, 0xd8, 0xcd, 0x26, 0x39,
+    0xa5, 0x14, 0xf5, 0x19, 0x35, 0x40, 0x86, 0x81, 0x52, 0x98, 0x5d, 0x40, 0x2c, 0x8c, 0xb9,
+    0x19, 0x19, 0x1d, 0x69, 0x54, 0x6d, 0x60, 0xde, 0x87, 0x35, 0x7a, 0xf6, 0xf8, 0x5d, 0xc4,
+    0x88, 0x23, 0xda, 0x41, 0xc9, 0x34, 0x16, 0x92, 0xb1, 0x9a, 0x56, 0x93, 0x15, 0x29, 0x18,
+    0x04, 0xfa, 0xd4, 0x74, 0xc9, 0x0a, 0x50, 0x29, 0x29, 0x45, 0x03, 0x17, 0x34, 0xbd, 0x69,
+    0x28, 0xa0, 0x05, 0xa7, 0x64, 0xd2, 0x01, 0x9a, 0x7e, 0xd3, 0x40, 0x08, 0x1a, 0x8d, 0xf4,
+    0xe0, 0x83, 0xbd, 0x1e, 0x58, 0xc5, 0x00, 0x34, 0x31, 0xcf, 0xb5, 0x69, 0xda, 0x49, 0x84,
+    0xc5, 0x67, 0xec, 0x15, 0x24, 0x6f, 0xb4, 0xe2, 0x93, 0x57, 0x2e, 0x0e, 0xcc, 0xbc, 0xe7,
+    0xde, 0xab, 0x48, 0xf4, 0x17, 0x24, 0x7a, 0x54, 0x24, 0xe4, 0xd0, 0x91, 0x72, 0x63, 0x81,
+    0xe2, 0x9a, 0xcf, 0x8e, 0x29, 0x09, 0xc0, 0xa6, 0xd3, 0x22, 0xe2, 0x13, 0x9a, 0x66, 0x09,
+    0xa9, 0x02, 0x92, 0x78, 0xab, 0x51, 0x5b, 0xe3, 0x96, 0xa0, 0x4a, 0x2d, 0x95, 0xa3, 0x80,
+    0xb7, 0x6a, 0xb2, 0xb0, 0xaa, 0x0e, 0x6a, 0x7c, 0x05, 0x15, 0x1b, 0x1c, 0x9a, 0x93, 0x45,
+    0x14, 0x84, 0x26, 0xa2, 0x77, 0xc5, 0x2b, 0x93, 0xdb, 0xa5, 0x30, 0x21, 0x6a, 0x61, 0x72,
+    0x26, 0x24, 0xf4, 0xa6, 0xec, 0x26, 0xac, 0x88, 0xb1, 0x4d, 0x20, 0x0e, 0xd4, 0x5c, 0x56,
+    0xee, 0x44, 0x23, 0x1d, 0xf9, 0xa6, 0x15, 0xe7, 0x8a, 0x97, 0x04, 0xd2, 0x05, 0xc5, 0x31,
+    0x58, 0x8b, 0x61, 0xa4, 0xd9, 0x53, 0xed, 0xa0, 0x8c, 0x52, 0xb8, 0x58, 0x83, 0x60, 0xa4,
+    0xda, 0x2a, 0x43, 0x93, 0x4d, 0xda, 0x69, 0x85, 0x86, 0x6d, 0xa5, 0xdb, 0x4f, 0xdb, 0x8a,
+    0x5a, 0x02, 0xc4, 0x7b, 0x29, 0x36, 0xd4, 0x84, 0x52, 0x52, 0x0b, 0x0c, 0xdb, 0x49, 0x8c,
+    0x53, 0xcd, 0x25, 0x03, 0x19, 0x41, 0x34, 0xa4, 0x53, 0x0f, 0x1d, 0x68, 0x10, 0x13, 0x4c,
+    0x6a, 0x52, 0x69, 0x8c, 0x70, 0x28, 0x13, 0x63, 0x58, 0xe0, 0x54, 0x0c, 0xd9, 0xa7, 0x33,
+    0x66, 0xa3, 0x34, 0x5c, 0x96, 0xc6, 0x93, 0x4c, 0x6a, 0x7e, 0x2a, 0x37, 0x74, 0x40, 0x77,
+    0x30, 0x1f, 0x53, 0x41, 0x24, 0x6d, 0x59, 0x17, 0xba, 0xb0, 0x49, 0x0d, 0xbd, 0xa8, 0xf3,
+    0x25, 0xe8, 0x4f, 0x61, 0x4d, 0xd6, 0x75, 0x78, 0xe3, 0x80, 0xc3, 0x6e, 0xf9, 0x91, 0xf8,
+    0xc8, 0xec, 0x29, 0x9a, 0x15, 0x92, 0x04, 0x6b, 0x89, 0x39, 0x72, 0x78, 0xcf, 0x6f, 0x7a,
+    0xc2, 0x53, 0x72, 0x97, 0x24, 0x4d, 0x63, 0x14, 0x97, 0x34, 0x8b, 0x36, 0x9a, 0x42, 0x36,
+    0x27, 0xbb, 0xcc, 0xb3, 0x1e, 0x4e, 0xee, 0xdf, 0x85, 0x6a, 0xaa, 0x2a, 0x00, 0x15, 0x40,
+    0x03, 0xa6, 0x2a, 0xac, 0xb7, 0xaa, 0x8e, 0x22, 0x41, 0xb9, 0xf3, 0xcf, 0xb5, 0x2b, 0xca,
+    0xe0, 0x7d, 0xfe, 0x7d, 0xab, 0x58, 0xa4, 0xb6, 0x22, 0x4d, 0xbd, 0xcb, 0x8b, 0x1b, 0xc8,
+    0x4e, 0xc4, 0x2d, 0x81, 0x93, 0x8e, 0xd5, 0x03, 0xba, 0xf6, 0x20, 0x9a, 0xae, 0x9a, 0x93,
+    0x5a, 0x16, 0x64, 0x97, 0xe6, 0x61, 0x82, 0x3a, 0xd5, 0x27, 0xbe, 0xc9, 0xf9, 0x53, 0xf3,
+    0xa7, 0xcc, 0x90, 0xd4, 0x5b, 0x5a, 0x17, 0xdd, 0x98, 0xf4, 0xc6, 0x2a, 0xb3, 0x34, 0x68,
+    0x4e, 0xe6, 0x00, 0xfb, 0x9a, 0xa3, 0x25, 0xdc, 0x8d, 0xc7, 0x1f, 0x85, 0x42, 0x03, 0xb9,
+    0xe9, 0x50, 0xe7, 0xd8, 0xb5, 0x49, 0xf5, 0x66, 0x98, 0x91, 0x24, 0x6d, 0xa8, 0x73, 0x9f,
+    0x4a, 0x5f, 0xb2, 0xab, 0x10, 0x58, 0x67, 0xeb, 0x54, 0x61, 0x0d, 0x1c, 0x80, 0xe7, 0x07,
+    0xd6, 0xad, 0xdc, 0x6a, 0x31, 0x42, 0xbf, 0x2f, 0xcc, 0x7f, 0x4a, 0x77, 0x56, 0xbb, 0x13,
+    0x83, 0x4e, 0xd1, 0x27, 0xf2, 0x95, 0x45, 0x56, 0xb8, 0xba, 0x86, 0x00, 0x77, 0x30, 0xcf,
+    0xa0, 0xac, 0x7b, 0xad, 0x5a, 0x69, 0x32, 0x03, 0x60, 0x7a, 0x0a, 0xce, 0x79, 0x19, 0xce,
+    0x58, 0x93, 0xed, 0x5c, 0xf3, 0xc4, 0xa5, 0xa4, 0x4b, 0x8d, 0x1f, 0xe6, 0x35, 0xc6, 0xaf,
+    0x1c, 0x65, 0xbe, 0x42, 0x73, 0xd3, 0x9a, 0xa5, 0x3e, 0xa7, 0x34, 0xdd, 0x15, 0x54, 0x55,
+    0x50, 0xb8, 0x5c, 0x9c, 0x0a, 0x3c, 0xc3, 0xd0, 0x57, 0x3c, 0xab, 0x4d, 0xab, 0x36, 0x6c,
+    0xa1, 0x14, 0xee, 0x3c, 0xdd, 0xc8, 0x7a, 0x9c, 0x1f, 0xa5, 0x3e, 0x06, 0xdd, 0x26, 0x49,
+    0xcd, 0x57, 0x62, 0x5b, 0xa9, 0x26, 0x9d, 0x18, 0x3b, 0xab, 0x35, 0x27, 0x7d, 0x4a, 0x3a,
+    0x3b, 0x06, 0x40, 0x46, 0x79, 0x35, 0xed, 0x7f, 0x06, 0x35, 0x1d, 0x9a, 0xad, 0xc5, 0x99,
+    0xc6, 0x26, 0x87, 0x23, 0x9e, 0xea, 0x7f, 0xfa, 0xe6, 0xbc, 0x06, 0xd9, 0xd9, 0x58, 0x72,
+    0x41, 0xaf, 0x48, 0xf8, 0x6d, 0xab, 0x1b, 0x1f, 0x14, 0x58, 0xc8, 0xc7, 0x8f, 0x30, 0x03,
+    0x93, 0xc6, 0x0f, 0x07, 0xf9, 0xd7, 0x75, 0xf9, 0xe9, 0xb4, 0x44, 0x57, 0x2d, 0x45, 0xe6,
+    0x7b, 0x1f, 0xc5, 0x3b, 0x63, 0x26, 0x84, 0x92, 0x01, 0x90, 0x92, 0x02, 0xde, 0xdd, 0x47,
+    0xf5, 0xaf, 0x9e, 0x2f, 0x01, 0xde, 0xdc, 0x9e, 0x0d, 0x7d, 0x43, 0xe3, 0xab, 0x33, 0x7b,
+    0xe1, 0x3b, 0xb5, 0x42, 0x32, 0xab, 0xbf, 0xea, 0x07, 0x3f, 0xd2, 0xbe, 0x61, 0xd4, 0xd1,
+    0xa3, 0xb9, 0x91, 0x7d, 0xf2, 0x2a, 0x70, 0xce, 0xf4, 0xec, 0x3c, 0x4e, 0xb1, 0x8b, 0x33,
+    0xe3, 0x3f, 0xbc, 0xaf, 0x42, 0xf8, 0x6b, 0x6b, 0xf6, 0x9f, 0x12, 0xc0, 0x08, 0xe1, 0x72,
+    0x7f, 0x1c, 0x71, 0x5e, 0x7d, 0x0a, 0x7c, 0xf5, 0xec, 0x1f, 0x07, 0xb4, 0xff, 0x00, 0x33,
+    0x57, 0x7b, 0x86, 0x53, 0x84, 0x5c, 0x83, 0xe8, 0x6b, 0x4a, 0x8e, 0xd0, 0x6c, 0x8c, 0x3f,
+    0xf1, 0x13, 0xec, 0x7b, 0x8d, 0x79, 0x07, 0xc6, 0xb8, 0xb3, 0x6b, 0x6e, 0xfe, 0x8f, 0x9f,
+    0xcc, 0x63, 0xfa, 0x57, 0xaf, 0xd7, 0x94, 0x7c, 0x6c, 0x20, 0x69, 0x36, 0xc3, 0xbb, 0x30,
+    0xfe, 0xb5, 0xc1, 0x43, 0xf8, 0x88, 0xe8, 0x5f, 0x0c, 0xbd, 0x0f, 0x9c, 0xef, 0xf7, 0x07,
+    0x38, 0x6a, 0xca, 0x79, 0x18, 0x1e, 0xb5, 0xa9, 0x7d, 0xf7, 0xcd, 0x65, 0x49, 0x83, 0xd6,
+    0xb4, 0xad, 0xb9, 0x94, 0x36, 0x1b, 0xe6, 0x13, 0x48, 0x4f, 0xbd, 0x34, 0xd2, 0x57, 0x3d,
+    0xcb, 0x1d, 0x9a, 0x4c, 0xd2, 0x66, 0x96, 0x8b, 0x80, 0x66, 0x8c, 0xd2, 0x52, 0xe2, 0x98,
+    0x05, 0x4b, 0x03, 0x7c, 0xf8, 0xa8, 0xf1, 0x4a, 0x9c, 0x48, 0xa6, 0x85, 0xb8, 0x12, 0xdc,
+    0x0e, 0x86, 0xa0, 0x5f, 0xbc, 0x2a, 0xd4, 0xc3, 0x31, 0xe6, 0xaa, 0xf7, 0xa2, 0x5b, 0x89,
+    0x0a, 0xff, 0x00, 0x7a, 0x85, 0x34, 0xaf, 0xd8, 0xd3, 0x07, 0x5a, 0x5d, 0x46, 0x3e, 0x8a,
+    0x28, 0xa6, 0x21, 0xa4, 0x52, 0x53, 0xe9, 0x30, 0x29, 0x58, 0x06, 0xd1, 0x4e, 0xdb, 0x49,
+    0xb6, 0x95, 0x86, 0x25, 0x28, 0x62, 0x29, 0x28, 0xa0, 0x07, 0xef, 0xcd, 0x34, 0x9a, 0x02,
+    0x96, 0xe8, 0x2a, 0x55, 0x88, 0x0e, 0xb5, 0x56, 0x6c, 0x08, 0x80, 0x26, 0x9c, 0x13, 0xd6,
+    0xa5, 0xe0, 0x52, 0x1a, 0x39, 0x44, 0x37, 0x00, 0x51, 0x4b, 0x49, 0x40, 0xc4, 0xc5, 0x18,
+    0xa5, 0x24, 0x0e, 0xa6, 0x9a, 0x5c, 0x76, 0xa0, 0x05, 0xa4, 0xa6, 0x96, 0x26, 0x93, 0x26,
+    0x95, 0xc0, 0x7d, 0x25, 0x36, 0x8a, 0x00, 0xea, 0x64, 0x5d, 0xac, 0x45, 0x33, 0x9a, 0x79,
+    0x25, 0x8e, 0x69, 0x31, 0x5e, 0x91, 0x91, 0x14, 0xe1, 0x9a, 0x2d, 0xcb, 0xf7, 0xd3, 0xe6,
+    0x5f, 0xf0, 0xa6, 0x69, 0x97, 0xa9, 0x6b, 0x7e, 0x54, 0x11, 0xe4, 0x5c, 0x8c, 0x95, 0x3d,
+    0x9a, 0xac, 0x62, 0xb0, 0xee, 0x21, 0x78, 0xef, 0xca, 0xc6, 0x09, 0x39, 0xdc, 0xa0, 0x56,
+    0x55, 0x1b, 0x8b, 0x52, 0x43, 0xb2, 0x6a, 0xcc, 0xb9, 0xac, 0xd8, 0xc3, 0x0b, 0xfd, 0xa2,
+    0xd8, 0x80, 0xac, 0x79, 0x4f, 0x43, 0xed, 0x51, 0xd9, 0x49, 0x35, 0xbe, 0x2e, 0x6c, 0x9f,
+    0x0c, 0x3e, 0xfc, 0x67, 0xa1, 0xa9, 0x6f, 0x18, 0xce, 0x91, 0xed, 0xe9, 0xb3, 0x79, 0xa6,
+    0xad, 0x9c, 0x91, 0xc4, 0x97, 0x16, 0xc7, 0x12, 0x6d, 0xcb, 0x2f, 0xf7, 0xab, 0x37, 0x1f,
+    0x7d, 0xb8, 0xa1, 0xad, 0xac, 0xcd, 0xeb, 0x2d, 0x6e, 0x1b, 0xc0, 0x01, 0xf9, 0x25, 0x1d,
+    0x50, 0xff, 0x00, 0x4a, 0xb5, 0x79, 0x14, 0x5a, 0x85, 0x8c, 0x90, 0x36, 0x3e, 0x61, 0x95,
+    0x3e, 0x87, 0xb5, 0x72, 0xc1, 0x21, 0xbd, 0x39, 0x04, 0xc3, 0x70, 0x3b, 0x7b, 0xd5, 0x94,
+    0xbf, 0xbc, 0xd3, 0xc8, 0x4b, 0xc8, 0xd9, 0x93, 0xb4, 0x8b, 0x5b, 0x2a, 0x9a, 0x5a, 0x7b,
+    0x77, 0x31, 0x74, 0xac, 0xef, 0x12, 0x0d, 0x3a, 0xd5, 0x6e, 0x51, 0xed, 0x9f, 0x86, 0xce,
+    0x09, 0xf4, 0xae, 0x8b, 0x41, 0x6c, 0xe9, 0xc6, 0xdd, 0xbe, 0xf4, 0x0e, 0x50, 0xd6, 0x1e,
+    0x9d, 0x71, 0x1f, 0xf6, 0xd1, 0x31, 0xb0, 0x29, 0x23, 0x64, 0x7e, 0x3d, 0x6b, 0x56, 0xde,
+    0x5f, 0xb1, 0x6b, 0x93, 0xc6, 0x78, 0x49, 0x93, 0x77, 0xe2, 0x29, 0x53, 0x49, 0x24, 0xd7,
+    0xa0, 0xea, 0xdd, 0xe9, 0xf3, 0x2d, 0x5d, 0x44, 0x32, 0x4d, 0x53, 0xda, 0x6a, 0xdc, 0xf3,
+    0x79, 0x87, 0x02, 0xab, 0xe2, 0xba, 0x0c, 0xe0, 0xda, 0x5a, 0x82, 0x31, 0x5e, 0xf5, 0x66,
+    0x3b, 0xa2, 0x3a, 0xd5, 0x7a, 0x5c, 0x50, 0x0d, 0x26, 0x5d, 0xfb, 0x4a, 0x91, 0x55, 0xe4,
+    0x93, 0x79, 0xa6, 0x62, 0x94, 0x2d, 0x04, 0xa8, 0xa4, 0x37, 0x14, 0xbb, 0x79, 0xa7, 0x85,
+    0xa5, 0x02, 0x98, 0xee, 0x34, 0x2d, 0x28, 0x5a, 0x7e, 0x28, 0xc5, 0x02, 0xb8, 0xd0, 0xb5,
+    0x22, 0xa6, 0x7e, 0x94, 0xaa, 0x99, 0xa9, 0x55, 0x7b, 0x0a, 0x64, 0x39, 0x00, 0x01, 0x46,
+    0x05, 0x28, 0x19, 0xa7, 0xaa, 0x53, 0xf6, 0xe2, 0x82, 0x06, 0x05, 0xa7, 0x6d, 0xa5, 0xa4,
+    0x2d, 0x4c, 0x43, 0x18, 0x53, 0x69, 0x4f, 0x34, 0xa0, 0x52, 0x01, 0xad, 0xc2, 0x93, 0xe8,
+    0x2b, 0x9b, 0xd1, 0xc6, 0xfb, 0x5b, 0xe9, 0x3b, 0x99, 0x07, 0xf5, 0xae, 0x8e, 0xe0, 0x88,
+    0xed, 0x65, 0x63, 0xd0, 0x21, 0x3f, 0xa5, 0x61, 0xe8, 0x11, 0x6e, 0xd1, 0xae, 0x1f, 0xd6,
+    0x4f, 0xcf, 0x8f, 0xfe, 0xbd, 0x65, 0x2f, 0x8e, 0x3f, 0x33, 0x7a, 0x4e, 0xd1, 0x6f, 0xd0,
+    0x4a, 0xcd, 0xb5, 0xfd, 0xee, 0xa7, 0x3c, 0xbd, 0x97, 0x8a, 0xd1, 0x95, 0xbc, 0xb8, 0xd9,
+    0x8f, 0x40, 0x33, 0x59, 0xfa, 0x70, 0x2b, 0x6b, 0x2c, 0xc7, 0xab, 0xb6, 0x2b, 0x39, 0xfc,
+    0x49, 0x1d, 0x4b, 0x63, 0x4c, 0x11, 0x8c, 0xf5, 0xaa, 0x1a, 0xb3, 0xff, 0x00, 0xa3, 0x2a,
+    0xfa, 0xb5, 0x5a, 0x8f, 0xee, 0x0a, 0xa3, 0xa9, 0x1d, 0xd3, 0x5b, 0xc7, 0xea, 0xd9, 0xa7,
+    0x56, 0x5e, 0xe0, 0x25, 0xa8, 0xed, 0x2d, 0xcf, 0xd9, 0x1d, 0x4f, 0xf0, 0xb1, 0xab, 0x71,
+    0xb0, 0xdd, 0xf8, 0x55, 0x0d, 0x3c, 0xe0, 0x5c, 0x2f, 0xfb, 0x55, 0x72, 0x3f, 0xbd, 0x53,
+    0x4d, 0xfb, 0xa8, 0x1e, 0xe5, 0x3d, 0x50, 0xe6, 0x54, 0x19, 0xea, 0xa7, 0x9a, 0x86, 0x19,
+    0x36, 0xba, 0xb7, 0x50, 0x78, 0x35, 0x36, 0xa4, 0xb9, 0x92, 0x23, 0xe9, 0xd6, 0xaa, 0x28,
+    0xf9, 0x8a, 0xfa, 0xf2, 0x2b, 0x19, 0xdd, 0x4d, 0x94, 0xb6, 0x24, 0x95, 0x7c, 0x9b, 0x8f,
+    0xf6, 0x5a, 0xa7, 0x86, 0x53, 0x0b, 0x86, 0x1d, 0x3b, 0xd3, 0x40, 0x17, 0x10, 0x6c, 0x3f,
+    0x7d, 0x7a, 0x7d, 0x2a, 0x35, 0xca, 0x36, 0xc7, 0xa3, 0x67, 0x74, 0x07, 0x41, 0x69, 0x72,
+    0xa0, 0xee, 0xc0, 0x64, 0x61, 0x86, 0x53, 0xdc, 0x54, 0xf1, 0xdb, 0xc9, 0xa4, 0x4a, 0x6f,
+    0x6c, 0x01, 0x9a, 0xce, 0x4e, 0x65, 0x84, 0x75, 0x5f, 0x71, 0x58, 0x56, 0xf2, 0xb4, 0x2f,
+    0xea, 0xa6, 0xb5, 0xed, 0x6f, 0xe4, 0xb7, 0x60, 0xf1, 0x1c, 0xa9, 0xea, 0xa7, 0xa1, 0xae,
+    0xb8, 0xc9, 0x4d, 0x6b, 0xb9, 0x8c, 0xe0, 0xfa, 0x1d, 0x25, 0xad, 0xcc, 0x37, 0x90, 0xac,
+    0xb0, 0x38, 0x64, 0x3f, 0xa7, 0xd6, 0xac, 0x81, 0x58, 0xb6, 0xf6, 0xf1, 0xdd, 0xb9, 0xb8,
+    0xd3, 0x67, 0x16, 0xb7, 0x47, 0x96, 0x89, 0xb9, 0x47, 0x3e, 0xe3, 0xfa, 0xd4, 0xab, 0xad,
+    0x7d, 0x9a, 0x71, 0x6d, 0xaa, 0x40, 0xd6, 0x93, 0x74, 0x0c, 0x79, 0x8d, 0xbe, 0x86, 0xb5,
+    0xe6, 0xb6, 0xe7, 0x3b, 0x87, 0x63, 0x5b, 0x14, 0xa0, 0xe0, 0xd2, 0x23, 0x2c, 0x8a, 0x19,
+    0x18, 0x30, 0x3d, 0x08, 0x39, 0xa5, 0xaa, 0x24, 0x99, 0x5c, 0x11, 0xcd, 0x3b, 0x2b, 0x55,
+    0xc1, 0x22, 0xa6, 0x04, 0x30, 0xe4, 0x50, 0x55, 0xc4, 0x76, 0x0d, 0x4d, 0xda, 0x7b, 0x53,
+    0xfc, 0xbf, 0x6a, 0x6c, 0xb3, 0x5b, 0xda, 0xa6, 0xf9, 0xe5, 0x8e, 0x25, 0xf5, 0x76, 0x00,
+    0x7e, 0xb4, 0xc0, 0x6e, 0x08, 0xeb, 0x4a, 0x06, 0x6b, 0x16, 0xef, 0xc5, 0x56, 0x68, 0xfe,
+    0x4d, 0x84, 0x72, 0x5e, 0xce, 0x4e, 0x02, 0xc6, 0x3e, 0x5c, 0xfd, 0x7f, 0xc2, 0x9b, 0x07,
+    0x87, 0xbc, 0x51, 0xe2, 0x12, 0x1a, 0xee, 0x75, 0xd3, 0xed, 0x9b, 0xf8, 0x06, 0x73, 0x8f,
+    0xa0, 0xe7, 0xf3, 0x35, 0x9b, 0xaa, 0xbe, 0xce, 0xa5, 0xaa, 0x6d, 0x97, 0xef, 0x35, 0x7d,
+    0x3e, 0xc3, 0x3f, 0x68, 0xba, 0x45, 0x61, 0xfc, 0x20, 0xe4, 0xfe, 0x42, 0xb3, 0x06, 0xbb,
+    0x7f, 0xa8, 0xbf, 0x97, 0xa3, 0xe9, 0x72, 0xcd, 0x9e, 0x92, 0x4a, 0x30, 0x3f, 0x21, 0xfe,
+    0x35, 0xd4, 0x69, 0x7e, 0x00, 0xd0, 0x74, 0xcd, 0xb2, 0x5c, 0x2b, 0xde, 0x4c, 0x3a, 0xb4,
+    0xc7, 0xe5, 0xcf, 0xd2, 0xb7, 0x5f, 0x52, 0xb0, 0xd3, 0xe3, 0x08, 0x9e, 0x54, 0x6a, 0x07,
+    0x0a, 0x82, 0xa6, 0xf3, 0x97, 0x91, 0xaf, 0xb3, 0x8c, 0x75, 0x6c, 0xe3, 0x2d, 0xbc, 0x27,
+    0xe2, 0xbd, 0x49, 0x77, 0x5d, 0xea, 0x91, 0xd9, 0x46, 0xdf, 0xc1, 0x10, 0xe4, 0x7e, 0x5f,
+    0xe3, 0x56, 0xd7, 0xe1, 0x65, 0xb3, 0x36, 0xfb, 0xdd, 0x76, 0xea, 0x56, 0x3d, 0x70, 0x00,
+    0xfe, 0x79, 0xad, 0x3b, 0x8f, 0x14, 0x31, 0x6c, 0x41, 0x16, 0x47, 0xab, 0x9a, 0xa4, 0xda,
+    0xe5, 0xf3, 0x9c, 0xf9, 0x81, 0x3d, 0x82, 0x8a, 0x5e, 0xc6, 0xfb, 0x8b, 0xdb, 0x53, 0x8e,
+    0xc0, 0x3e, 0x17, 0xe8, 0x2b, 0xd7, 0x52, 0xbe, 0xcf, 0xb3, 0x0f, 0xf0, 0xa7, 0x8f, 0x87,
+    0x3a, 0x7c, 0x23, 0xfd, 0x13, 0x5d, 0xd4, 0xa1, 0x3d, 0xb0, 0xdf, 0xfe, 0xaa, 0x88, 0x6a,
+    0xb7, 0x67, 0xad, 0xd3, 0x7e, 0x55, 0x66, 0x1d, 0x41, 0xdb, 0x05, 0xef, 0xd9, 0x7e, 0xab,
+    0x9a, 0x15, 0x14, 0xb6, 0x1f, 0xb7, 0x84, 0xb4, 0xb1, 0x4a, 0x5f, 0x06, 0xf8, 0x86, 0xd4,
+    0xe6, 0xc3, 0xc4, 0x51, 0xdc, 0x0f, 0xee, 0xdd, 0x45, 0x8c, 0xfe, 0x3c, 0xd5, 0x69, 0x0f,
+    0x89, 0xb4, 0xdc, 0x9b, 0xfd, 0x17, 0xed, 0x31, 0x8f, 0xf9, 0x6b, 0x66, 0xfb, 0xbf, 0x1d,
+    0xbd, 0x7f, 0x95, 0x75, 0x76, 0xb7, 0x45, 0x88, 0x23, 0x52, 0x8d, 0xbd, 0x9b, 0x8f, 0xeb,
+    0x5b, 0x70, 0xc9, 0xb9, 0x46, 0x59, 0x18, 0xfb, 0x51, 0x67, 0x1d, 0x99, 0x6a, 0x31, 0x99,
+    0xe7, 0x36, 0x9e, 0x23, 0xd3, 0x6f, 0x1f, 0xcb, 0x17, 0x1e, 0x54, 0xdd, 0x0c, 0x73, 0x0d,
+    0x8c, 0x0f, 0xa7, 0x3c, 0x56, 0xae, 0x46, 0xde, 0x2b, 0xa2, 0xd5, 0xfc, 0x29, 0xa2, 0x78,
+    0x81, 0x08, 0xbe, 0xb5, 0x1e, 0x6e, 0x3e, 0x59, 0xa3, 0xf9, 0x64, 0x5f, 0xc7, 0xbf, 0xe3,
+    0x9a, 0xe2, 0xaf, 0x3c, 0x23, 0xe2, 0x1f, 0x0b, 0x06, 0x9b, 0x4a, 0x98, 0xea, 0xba, 0x72,
+    0xf2, 0x60, 0x6e, 0x24, 0x41, 0xec, 0x3b, 0xfe, 0x1f, 0x95, 0x0a, 0xab, 0x5f, 0x12, 0x26,
+    0x54, 0x5a, 0xd5, 0x1a, 0x46, 0x85, 0x42, 0xc7, 0x8a, 0xa9, 0xa4, 0x6a, 0x16, 0xfa, 0xc4,
+    0x25, 0xe1, 0x25, 0x64, 0x43, 0x89, 0x22, 0x6e, 0x19, 0x0f, 0xa1, 0x15, 0xb6, 0x90, 0x84,
+    0x5c, 0xe2, 0xb6, 0xba, 0x6a, 0xe8, 0xcd, 0x40, 0x48, 0x20, 0x0a, 0xb9, 0x3d, 0xa9, 0xed,
+    0xed, 0x41, 0x27, 0x14, 0x94, 0x8b, 0xd8, 0x6f, 0xd6, 0xa2, 0x76, 0x02, 0xa4, 0x63, 0xda,
+    0xa1, 0x61, 0x9a, 0x62, 0x60, 0xa3, 0x75, 0x3c, 0x0c, 0x53, 0x41, 0x00, 0x52, 0xe4, 0xd0,
+    0x02, 0x9a, 0x84, 0xa1, 0xce, 0x47, 0x4a, 0x94, 0x67, 0xbd, 0x31, 0x9f, 0x07, 0x14, 0x00,
+    0xd0, 0x83, 0xbd, 0x18, 0x02, 0x93, 0x24, 0xd1, 0x82, 0x4d, 0x02, 0xb0, 0x84, 0xe7, 0xa5,
+    0x37, 0x04, 0xd4, 0xcb, 0x11, 0xef, 0x52, 0x08, 0x80, 0xa0, 0x76, 0x2a, 0xed, 0x3d, 0x85,
+    0x1b, 0x0d, 0x59, 0x28, 0x29, 0x8f, 0xc5, 0x17, 0x0b, 0x10, 0x6d, 0xa3, 0x68, 0xa7, 0x1a,
+    0x09, 0xa0, 0x43, 0x71, 0x4c, 0x23, 0x9a, 0x71, 0x6a, 0x6e, 0x71, 0x48, 0x63, 0x71, 0x48,
+    0x69, 0xd4, 0xc2, 0x69, 0x92, 0x35, 0x8d, 0x46, 0x4d, 0x38, 0xf2, 0x6a, 0x36, 0x3e, 0x94,
+    0x09, 0xb1, 0xac, 0xd8, 0xe2, 0xa2, 0x62, 0x4d, 0x29, 0x04, 0x9e, 0x94, 0xa1, 0x3d, 0xa8,
+    0x24, 0x8f, 0x6e, 0x6a, 0x29, 0xa4, 0x8a, 0x08, 0xcc, 0x92, 0xb8, 0x45, 0x1d, 0x49, 0xa8,
+    0x75, 0x3d, 0x52, 0x0d, 0x32, 0x2c, 0xb9, 0xdd, 0x29, 0xfb, 0xb1, 0x8e, 0xa6, 0xb1, 0x23,
+    0x82, 0xe7, 0x57, 0x94, 0x4f, 0x78, 0xc7, 0x6f, 0x55, 0x88, 0x7d, 0xd5, 0xa8, 0x72, 0xd6,
+    0xcb, 0x71, 0xa8, 0xe9, 0x77, 0xb1, 0x62, 0xe3, 0x55, 0xb8, 0xb8, 0xf9, 0x2c, 0x23, 0xc2,
+    0x9f, 0xf9, 0x6a, 0xff, 0x00, 0xd0, 0x55, 0x5f, 0xec, 0x6b, 0xcb, 0xaf, 0x9a, 0xe2, 0xed,
+    0xfe, 0x80, 0x56, 0xf4, 0x36, 0xb1, 0xc2, 0x83, 0x00, 0x67, 0xd6, 0xa1, 0xbc, 0xd4, 0x2d,
+    0xec, 0xc6, 0x1d, 0xc6, 0xef, 0xee, 0x8e, 0x4d, 0x4c, 0xa0, 0x9e, 0xb2, 0x60, 0xa4, 0xf6,
+    0x8a, 0x39, 0xdb, 0x8d, 0x09, 0x21, 0x53, 0x96, 0x70, 0x47, 0xf1, 0x7a, 0xd4, 0x11, 0x4f,
+    0x34, 0x2d, 0xb0, 0x48, 0xc3, 0xb7, 0x06, 0xa7, 0xd4, 0x75, 0x83, 0x70, 0xbb, 0x55, 0x4a,
+    0xa0, 0x39, 0xf7, 0x35, 0x8e, 0x93, 0xb3, 0xcd, 0xd3, 0xa9, 0xfc, 0xab, 0x92, 0x73, 0x84,
+    0x65, 0xee, 0x1d, 0x10, 0x52, 0x6b, 0xde, 0x3a, 0x3b, 0x79, 0x51, 0x63, 0x19, 0xc9, 0x73,
+    0xd7, 0xde, 0xa3, 0x9a, 0x49, 0x1b, 0xf8, 0xb0, 0x3d, 0x05, 0x56, 0x89, 0x89, 0x4f, 0x4c,
+    0x77, 0xa7, 0xf9, 0x84, 0x1e, 0x39, 0x23, 0xf4, 0xae, 0x95, 0x2b, 0xa2, 0x79, 0x2c, 0xee,
+    0x18, 0xc0, 0xc9, 0xa8, 0xa4, 0x97, 0xb0, 0xa5, 0x96, 0x42, 0xdd, 0x6a, 0xb7, 0x7f, 0x7a,
+    0xce, 0x73, 0xe8, 0x8b, 0x48, 0x91, 0x65, 0x23, 0x8c, 0x66, 0xa5, 0x8e, 0x62, 0xbd, 0x86,
+    0x2a, 0x10, 0x31, 0x48, 0xcd, 0x81, 0x9a, 0x95, 0x26, 0x87, 0x6b, 0x93, 0x4b, 0x74, 0x15,
+    0x73, 0x59, 0x93, 0x4e, 0xf2, 0xb7, 0x5f, 0xfe, 0xb5, 0x12, 0xc8, 0x64, 0x6c, 0x0e, 0x82,
+    0xa1, 0x27, 0xb0, 0xe9, 0x58, 0xd4, 0xa8, 0xe5, 0xa0, 0xd2, 0xb0, 0xe0, 0x40, 0xe9, 0xd7,
+    0xd6, 0x9b, 0x9c, 0x74, 0xe2, 0x95, 0x54, 0xb1, 0xe2, 0xa7, 0x5b, 0x72, 0x00, 0x2d, 0xc6,
+    0x6b, 0x34, 0x9b, 0xd8, 0xa2, 0xb8, 0x04, 0xd3, 0xf0, 0x14, 0x73, 0x52, 0x48, 0xca, 0x9f,
+    0x2a, 0x01, 0x50, 0x8f, 0x98, 0xd1, 0x6b, 0x08, 0x53, 0x93, 0xd0, 0x60, 0x52, 0xa8, 0x6c,
+    0xf4, 0x35, 0x3c, 0x70, 0x33, 0x0c, 0x9e, 0x16, 0xa5, 0x2a, 0x14, 0x60, 0x0a, 0xa5, 0x07,
+    0xb8, 0x5c, 0x6c, 0x4c, 0x77, 0x0c, 0xf5, 0xae, 0x8f, 0x44, 0xb8, 0x30, 0xdd, 0xc4, 0xe0,
+    0xe0, 0x86, 0x1c, 0xd7, 0x2e, 0xac, 0x7c, 0xc3, 0x9a, 0xd7, 0xb1, 0x93, 0x6b, 0x83, 0x5d,
+    0x14, 0x25, 0xad, 0x8c, 0xe6, 0xb4, 0xb9, 0xf6, 0x1e, 0x95, 0x79, 0x1e, 0xb7, 0xe1, 0x78,
+    0x27, 0x5d, 0xad, 0xe6, 0xc2, 0x03, 0x01, 0xce, 0x18, 0x0e, 0x47, 0xe7, 0x5f, 0x37, 0xf8,
+    0xab, 0x4e, 0xfb, 0x1e, 0xa5, 0x2c, 0x5d, 0x76, 0x48, 0xc8, 0x4f, 0xae, 0x0f, 0x06, 0xbd,
+    0x77, 0xe1, 0x16, 0xb3, 0xf6, 0x9d, 0x2e, 0x6b, 0x07, 0x6c, 0xec, 0x22, 0x44, 0x04, 0xf6,
+    0x3d, 0x40, 0x1f, 0x50, 0x7f, 0x3a, 0xe6, 0xbe, 0x29, 0x68, 0xc6, 0x0d, 0x5a, 0x49, 0xd5,
+    0x4e, 0xd9, 0x46, 0xf1, 0xf5, 0x1c, 0x1f, 0xd3, 0x14, 0xa9, 0x7b, 0x95, 0x1c, 0x0d, 0xaa,
+    0x2e, 0x7a, 0x6d, 0xaf, 0x53, 0xca, 0xe0, 0x87, 0xe6, 0x15, 0xf4, 0x0f, 0xc2, 0x6d, 0x34,
+    0x5a, 0xe8, 0xf2, 0xdc, 0x77, 0x7c, 0x2f, 0x4f, 0xc7, 0xfc, 0x6b, 0xc4, 0x6d, 0x2d, 0x4b,
+    0xce, 0x8b, 0x8e, 0x49, 0x02, 0xbe, 0x94, 0xf0, 0x75, 0xa0, 0xb4, 0xf0, 0xe5, 0xba, 0x63,
+    0x04, 0x8d, 0xdf, 0x9d, 0x56, 0x25, 0xda, 0x16, 0x33, 0xc3, 0xc6, 0xd1, 0x94, 0x8d, 0xea,
+    0xf2, 0x1f, 0x8e, 0x0d, 0xfe, 0x8b, 0x60, 0xbe, 0xb9, 0x3f, 0x97, 0xff, 0x00, 0xae, 0xbd,
+    0x7a, 0xbc, 0x67, 0xe3, 0x74, 0x87, 0xcc, 0xb2, 0x4f, 0x40, 0x7f, 0xa5, 0x73, 0x50, 0xfe,
+    0x22, 0x2d, 0xfc, 0x12, 0xf4, 0x3c, 0x06, 0xfb, 0xef, 0x9a, 0xca, 0x97, 0xad, 0x6a, 0x5f,
+    0x7f, 0xac, 0x6a, 0xcb, 0x93, 0xad, 0x5d, 0x6d, 0xc8, 0x86, 0xc4, 0x54, 0x51, 0x45, 0x73,
+    0x16, 0x25, 0x14, 0xb8, 0xa5, 0xc1, 0xa2, 0xc0, 0x25, 0x03, 0x34, 0xb8, 0x34, 0xa1, 0x69,
+    0x80, 0x0a, 0x18, 0x8e, 0x08, 0xec, 0x68, 0xe9, 0xda, 0x90, 0xf4, 0xa6, 0x05, 0xaf, 0xbd,
+    0x11, 0xfa, 0x55, 0x43, 0x56, 0xa0, 0x39, 0x5c, 0x7b, 0x55, 0x67, 0x18, 0x62, 0x29, 0xcb,
+    0x54, 0x98, 0x90, 0xa4, 0x65, 0x05, 0x32, 0xa4, 0x8f, 0x95, 0x34, 0xc3, 0xd6, 0xa4, 0x60,
+    0x0e, 0x05, 0x1b, 0xa9, 0x29, 0xc1, 0x18, 0xf6, 0xa0, 0x04, 0xc9, 0xa3, 0x26, 0x9d, 0xe5,
+    0x91, 0xd4, 0x8a, 0x61, 0xf6, 0x34, 0x00, 0x51, 0x45, 0x4b, 0x14, 0x0f, 0x29, 0xe0, 0x71,
+    0xeb, 0x42, 0x4d, 0xec, 0x04, 0x5d, 0x6a, 0x75, 0x83, 0x1c, 0xbf, 0x1e, 0xd5, 0x37, 0x97,
+    0x1c, 0x3d, 0x39, 0x6f, 0x5f, 0x4a, 0x63, 0x31, 0x35, 0x6a, 0x36, 0xdc, 0x57, 0xb8, 0x12,
+    0x17, 0x81, 0x4d, 0xc9, 0x34, 0x51, 0xd3, 0xad, 0x36, 0xc0, 0x29, 0x3e, 0xb4, 0xd6, 0x90,
+    0x76, 0xe6, 0xa3, 0x2c, 0x4f, 0x5a, 0x96, 0xc0, 0x79, 0x70, 0x3a, 0x73, 0x4d, 0x2c, 0x4d,
+    0x36, 0x8a, 0x9b, 0x8c, 0x28, 0xa2, 0x8a, 0x40, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45,
+    0x00, 0x74, 0x11, 0xac, 0xb0, 0xae, 0xf4, 0x6f, 0x3a, 0x0e, 0xbc, 0x7d, 0xe1, 0x56, 0x11,
+    0x83, 0xa8, 0x65, 0x20, 0x83, 0xde, 0x90, 0xc2, 0xf0, 0x93, 0x24, 0x1d, 0x7f, 0x89, 0x3b,
+    0x37, 0xff, 0x00, 0x5e, 0xa2, 0xdc, 0x81, 0x4d, 0xd4, 0x19, 0xd9, 0xff, 0x00, 0x2d, 0x63,
+    0xf4, 0xf7, 0xfa, 0xd7, 0xa2, 0xbd, 0xdd, 0x0c, 0xae, 0x58, 0xc5, 0x53, 0xb8, 0x1b, 0x35,
+    0x0b, 0x69, 0x3f, 0xbd, 0x95, 0x35, 0x7d, 0x70, 0xea, 0x19, 0x4e, 0x54, 0x8c, 0x8a, 0xa5,
+    0xaa, 0x30, 0x84, 0x5b, 0xc8, 0x47, 0x0b, 0x26, 0x69, 0xd4, 0xb7, 0x2d, 0xc1, 0x3d, 0x4a,
+    0xb2, 0x02, 0xb1, 0xce, 0x3d, 0x18, 0x46, 0xbf, 0x9f, 0xff, 0x00, 0x5e, 0xb4, 0x9e, 0x48,
+    0xed, 0x60, 0x53, 0x21, 0xc0, 0x03, 0x18, 0xac, 0xf9, 0xdd, 0x7c, 0xd8, 0x77, 0x0c, 0x02,
+    0x4c, 0xac, 0x3f, 0x95, 0x56, 0x17, 0x4f, 0x73, 0x75, 0xbb, 0x67, 0x99, 0x21, 0x38, 0x8d,
+    0x4f, 0x41, 0x58, 0xa9, 0xa8, 0x32, 0xad, 0x71, 0xd7, 0xd2, 0xf9, 0xd8, 0x99, 0x20, 0xf2,
+    0xc0, 0xe8, 0xe4, 0xe0, 0x9f, 0xc2, 0xa4, 0x8e, 0xf0, 0xca, 0xa2, 0x36, 0xbc, 0x93, 0x27,
+    0x8c, 0x3a, 0xfc, 0xa6, 0xb4, 0x60, 0xd3, 0x17, 0xef, 0xdd, 0x1f, 0x36, 0x43, 0xeb, 0xd0,
+    0x51, 0x73, 0xa5, 0x5b, 0xce, 0x84, 0x22, 0x08, 0xdf, 0xb1, 0x14, 0xfd, 0x9c, 0xfe, 0x22,
+    0x79, 0xe3, 0xb1, 0x8b, 0x87, 0xb4, 0xd4, 0x11, 0x99, 0x42, 0xfc, 0xc0, 0xf1, 0xd0, 0x8f,
+    0x6a, 0xe8, 0x35, 0x73, 0xb6, 0xf2, 0xce, 0xe4, 0x74, 0x63, 0x83, 0xf8, 0x8a, 0xe7, 0xa7,
+    0x8e, 0xe0, 0x06, 0x86, 0x4c, 0x1f, 0x23, 0xf3, 0xc5, 0x6e, 0xdd, 0xb8, 0xb8, 0xd0, 0x20,
+    0x9b, 0xf8, 0x93, 0x07, 0x3f, 0x43, 0xff, 0x00, 0xd7, 0xa9, 0xa7, 0xa2, 0x92, 0xf9, 0x84,
+    0xf7, 0x4c, 0xbd, 0x83, 0x4a, 0x16, 0x9f, 0x18, 0xdd, 0x1a, 0xb7, 0xa8, 0x06, 0x9d, 0xb6,
+    0xbb, 0x0e, 0x76, 0xc8, 0xc0, 0xa7, 0x62, 0x9d, 0xb6, 0x97, 0x14, 0xc4, 0xd8, 0xdd, 0xb4,
+    0xe0, 0x29, 0x71, 0x4e, 0xc5, 0x02, 0xb8, 0xdc, 0x52, 0xe2, 0x9c, 0x17, 0xd6, 0x9d, 0xb7,
+    0x8a, 0x09, 0x6c, 0x60, 0x14, 0xe0, 0xb4, 0xec, 0x53, 0x95, 0x72, 0x68, 0x26, 0xe2, 0xaa,
+    0xe4, 0xd4, 0xea, 0x98, 0xa5, 0x44, 0x0a, 0x29, 0xd4, 0x05, 0x84, 0xc5, 0x18, 0xa7, 0x62,
+    0x97, 0xa5, 0x00, 0x30, 0xa8, 0x02, 0xa1, 0x23, 0x9a, 0x95, 0x9b, 0x34, 0xdc, 0x0a, 0x62,
+    0x63, 0x42, 0x93, 0x4e, 0x0b, 0x4f, 0x02, 0x9c, 0x05, 0x02, 0xb1, 0x97, 0xae, 0xc9, 0xe4,
+    0x68, 0xf3, 0xb7, 0x42, 0xc3, 0x68, 0xfc, 0x6a, 0x0d, 0x2a, 0x2f, 0x23, 0xc3, 0xd0, 0x29,
+    0x18, 0x69, 0x09, 0x73, 0x50, 0xf8, 0xa5, 0xcc, 0x86, 0xd2, 0xc9, 0x39, 0x69, 0x5f, 0x24,
+    0x0f, 0xca, 0xb5, 0xae, 0xa1, 0x10, 0x45, 0x0c, 0x23, 0xee, 0xa2, 0x05, 0x15, 0x9a, 0xd6,
+    0xa3, 0x7d, 0x8d, 0xd6, 0x90, 0x4b, 0xb9, 0xcc, 0xeb, 0x2f, 0xe5, 0xdb, 0xec, 0x1f, 0x79,
+    0xce, 0x05, 0x46, 0x57, 0xc8, 0xb5, 0x86, 0x1e, 0xe0, 0x64, 0xd2, 0xdd, 0xff, 0x00, 0xa5,
+    0x6b, 0x2a, 0x83, 0x94, 0x84, 0x73, 0xf5, 0xa4, 0x99, 0xbc, 0xc9, 0xf0, 0x3d, 0x71, 0x58,
+    0xc9, 0xde, 0x4d, 0xfc, 0x8e, 0xa8, 0xec, 0x8b, 0x11, 0xe4, 0x46, 0xbf, 0x4a, 0xcf, 0x91,
+    0xbc, 0xed, 0x54, 0x7a, 0x46, 0x2b, 0x45, 0x88, 0x44, 0x24, 0xf4, 0x03, 0x35, 0x99, 0x67,
+    0xf3, 0x09, 0xa7, 0x3d, 0x5c, 0xe0, 0x52, 0xa9, 0xd2, 0x23, 0x41, 0x60, 0x7e, 0x7b, 0x8f,
+    0xa8, 0xfe, 0x75, 0x7a, 0x23, 0x96, 0x26, 0xa8, 0x58, 0xf2, 0x67, 0x3d, 0x89, 0x15, 0x7e,
+    0x1e, 0xf4, 0xa9, 0x6c, 0x81, 0x95, 0x2f, 0xdb, 0x6c, 0xf1, 0xfa, 0x32, 0x90, 0x6a, 0xbc,
+    0x8b, 0x83, 0x91, 0xd4, 0x72, 0x2a, 0x5d, 0x50, 0xe1, 0xe2, 0x3f, 0x5a, 0x6e, 0x77, 0xc2,
+    0x1c, 0x7f, 0x09, 0xcd, 0x67, 0x3f, 0x89, 0xa1, 0xa1, 0x51, 0x88, 0xc4, 0xab, 0xf8, 0xd5,
+    0x89, 0x22, 0x17, 0x11, 0x06, 0x4e, 0x1b, 0xa8, 0xff, 0x00, 0x0a, 0xab, 0x11, 0xf2, 0xe4,
+    0x2b, 0xfc, 0x0d, 0xd2, 0xac, 0x44, 0xe6, 0x19, 0x30, 0x7e, 0xe9, 0xa7, 0x1b, 0x6c, 0xc0,
+    0x8a, 0x27, 0xe7, 0x63, 0x70, 0x47, 0xe9, 0x56, 0x12, 0x56, 0x43, 0xed, 0x53, 0x5c, 0xda,
+    0x0b, 0x88, 0xfc, 0xc8, 0xb0, 0x25, 0x5f, 0xd6, 0xa9, 0x47, 0x21, 0x3f, 0x23, 0x0c, 0x30,
+    0xea, 0x0d, 0x53, 0x4e, 0x0c, 0x5b, 0x9a, 0x71, 0x5c, 0x10, 0x43, 0x23, 0x15, 0x6f, 0x6a,
+    0xdc, 0xb6, 0xd6, 0xa2, 0xb9, 0x84, 0x5a, 0xea, 0x70, 0xac, 0xf1, 0x1e, 0x32, 0xc3, 0x26,
+    0xb9, 0x55, 0x6f, 0x4a, 0x9d, 0x66, 0x23, 0xef, 0x56, 0xd1, 0xa9, 0xdc, 0x89, 0x42, 0xe7,
+    0x4a, 0xde, 0x1b, 0x56, 0x53, 0x36, 0x87, 0xa8, 0xc9, 0x06, 0x79, 0xf2, 0xf7, 0x65, 0x6b,
+    0x3e, 0xe1, 0xfc, 0x59, 0xa7, 0x64, 0xc8, 0x82, 0x74, 0x1f, 0xc4, 0x10, 0x37, 0xf2, 0xa8,
+    0x6d, 0x35, 0x09, 0x20, 0x60, 0xc8, 0xe7, 0x8f, 0x43, 0x83, 0x5d, 0x1d, 0x97, 0x88, 0x4b,
+    0x00, 0x24, 0xc3, 0x7b, 0x8e, 0x0d, 0x5f, 0x22, 0x7f, 0x0b, 0xb1, 0x9b, 0xba, 0xf8, 0x95,
+    0xce, 0x57, 0xfe, 0x13, 0x0d, 0x4e, 0x33, 0x87, 0x82, 0x1c, 0xff, 0x00, 0xb4, 0xa4, 0x7f,
+    0x5a, 0x67, 0xfc, 0x25, 0x3a, 0xc4, 0xed, 0x88, 0xde, 0x18, 0xbe, 0x8a, 0x3f, 0xad, 0x77,
+    0x8c, 0xfa, 0x7e, 0xa1, 0xcc, 0xd6, 0xf0, 0x4a, 0x7d, 0x1d, 0x06, 0x6a, 0xb4, 0x9a, 0x0f,
+    0x87, 0x65, 0x3f, 0xbd, 0xb2, 0xd8, 0x4f, 0x74, 0x72, 0x2a, 0x1d, 0x2a, 0xbd, 0x24, 0x11,
+    0x95, 0x3e, 0xc7, 0x16, 0xb7, 0xda, 0xcd, 0xd3, 0x62, 0x6d, 0x61, 0x61, 0x53, 0xdc, 0x3e,
+    0x3f, 0xf4, 0x11, 0x5a, 0x7a, 0x7f, 0x87, 0xb4, 0x4b, 0x83, 0xe7, 0xea, 0x9a, 0xec, 0x92,
+    0x9f, 0x44, 0x53, 0xcf, 0xe2, 0x73, 0x5b, 0xcb, 0xe0, 0xef, 0x0d, 0xca, 0x7e, 0x53, 0x30,
+    0xfa, 0x48, 0x6a, 0x65, 0xf0, 0x3e, 0x89, 0xb7, 0x11, 0xbc, 0xc3, 0x3d, 0xf7, 0xd2, 0x54,
+    0x9f, 0xda, 0xd7, 0xe6, 0xcb, 0xe6, 0x5f, 0x64, 0xbd, 0xa6, 0x6a, 0x3e, 0x0e, 0xd1, 0xa2,
+    0xf2, 0xec, 0xde, 0x25, 0x6f, 0xef, 0x32, 0x9d, 0xc7, 0xf1, 0x34, 0xcb, 0xcf, 0x1d, 0x69,
+    0xc8, 0x4a, 0xc7, 0x73, 0x1f, 0xf4, 0xfd, 0x2a, 0xac, 0x3e, 0x04, 0xd2, 0x62, 0xfe, 0x29,
+    0x24, 0xc9, 0xcf, 0xcc, 0x41, 0xab, 0xb1, 0x78, 0x53, 0x49, 0x87, 0xee, 0xd9, 0xa3, 0x1f,
+    0xf6, 0xb1, 0x5a, 0xa5, 0x2f, 0x20, 0x6d, 0xec, 0x8c, 0x0b, 0x9f, 0x19, 0x5b, 0xce, 0x48,
+    0x37, 0x12, 0xb8, 0xf4, 0x8d, 0x08, 0xa8, 0x23, 0xbf, 0xbc, 0xbb, 0x60, 0x6d, 0x74, 0x8b,
+    0xb9, 0x14, 0xf4, 0x77, 0x1b, 0x47, 0xeb, 0x5d, 0x84, 0x5a, 0x3c, 0x16, 0xed, 0xba, 0x2b,
+    0x68, 0x23, 0xab, 0x5e, 0x4c, 0x8a, 0x32, 0x1d, 0x00, 0xf6, 0x15, 0x5e, 0xf7, 0x73, 0x37,
+    0x4d, 0x3d, 0xd1, 0xc5, 0x98, 0x35, 0xf7, 0xfb, 0x9a, 0x52, 0xaf, 0xfb, 0xd2, 0x83, 0x4c,
+    0x36, 0x9e, 0x25, 0xed, 0xa7, 0x43, 0xff, 0x00, 0x7d, 0xff, 0x00, 0xf5, 0xeb, 0xad, 0x9c,
+    0xdc, 0x03, 0xf2, 0xcb, 0xc5, 0x52, 0x6b, 0x99, 0x94, 0x90, 0x65, 0x3f, 0x9d, 0x3e, 0x56,
+    0xfa, 0x92, 0xf9, 0x23, 0xd0, 0xe7, 0x4d, 0xaf, 0x89, 0xb1, 0xc6, 0x9b, 0x11, 0xfa, 0x37,
+    0xff, 0x00, 0x5e, 0xa1, 0x92, 0x6d, 0x76, 0xd7, 0xfe, 0x3e, 0x34, 0x57, 0x23, 0xd5, 0x09,
+    0xff, 0x00, 0xeb, 0xd5, 0x8d, 0x47, 0xc6, 0x82, 0xcd, 0x9a, 0x2b, 0x57, 0x69, 0xa7, 0x1d,
+    0x31, 0xd3, 0xf3, 0xac, 0xf4, 0xf1, 0xb6, 0xbe, 0x79, 0xf2, 0x60, 0xdb, 0xe8, 0xc0, 0xff,
+    0x00, 0x8d, 0x63, 0x2a, 0x89, 0x3b, 0x73, 0x3f, 0xeb, 0xe4, 0x52, 0xa6, 0xa4, 0xbe, 0x12,
+    0x48, 0xbc, 0x51, 0x6d, 0x13, 0xec, 0xbb, 0x82, 0x78, 0x5b, 0xb8, 0x65, 0xcd, 0x5f, 0xb7,
+    0xf1, 0x4c, 0xd8, 0xdd, 0x61, 0x65, 0x73, 0x38, 0x07, 0x86, 0x8d, 0x19, 0x87, 0xe8, 0x2b,
+    0x02, 0xe7, 0x58, 0xd4, 0xfc, 0x46, 0xaf, 0x6c, 0x34, 0xcb, 0x79, 0x9c, 0x75, 0x68, 0xd0,
+    0xe5, 0x7f, 0x1c, 0xd6, 0x9f, 0x84, 0x86, 0xaf, 0x61, 0x79, 0xf6, 0x2b, 0x8b, 0x39, 0x52,
+    0xd1, 0xb2, 0xd9, 0x75, 0xfb, 0x87, 0xeb, 0x4a, 0x35, 0x65, 0x27, 0x65, 0xb7, 0x7b, 0x0f,
+    0xd9, 0xc6, 0x3a, 0xfe, 0xa6, 0xfc, 0x5e, 0x36, 0xd7, 0xe2, 0x8b, 0x78, 0xd1, 0x27, 0x72,
+    0x0f, 0x46, 0x42, 0x09, 0xab, 0x11, 0x7c, 0x54, 0x96, 0xdd, 0xf6, 0xea, 0x5a, 0x3c, 0xf6,
+    0xc3, 0xd7, 0x69, 0xfe, 0xb5, 0x78, 0x0c, 0xd4, 0xc2, 0xdd, 0x1e, 0x32, 0xb2, 0x22, 0xba,
+    0x9e, 0xa1, 0x86, 0x45, 0x6a, 0xe9, 0xbe, 0xe5, 0xc6, 0x6c, 0xce, 0xd4, 0x66, 0xd0, 0xf5,
+    0xf8, 0xdb, 0x5a, 0xd0, 0xae, 0xe3, 0xb6, 0xd5, 0xe3, 0x19, 0x6c, 0x0d, 0xa2, 0x61, 0xfd,
+    0xd7, 0x1d, 0xfe, 0xb5, 0x3e, 0x91, 0xad, 0xc5, 0xad, 0xd8, 0x2c, 0xc9, 0x85, 0x91, 0x4e,
+    0xd9, 0x63, 0xcf, 0x28, 0xd5, 0x56, 0x7f, 0x0a, 0x69, 0x33, 0x39, 0x92, 0x28, 0x1a, 0xd6,
+    0x5f, 0xef, 0xdb, 0xb6, 0xc3, 0xf9, 0x74, 0xfd, 0x2b, 0x3b, 0x49, 0xf0, 0xad, 0xde, 0x87,
+    0xae, 0x9b, 0x8b, 0x6b, 0xdf, 0x32, 0xcd, 0xc6, 0x24, 0x57, 0x1f, 0x31, 0xfe, 0x9f, 0x8d,
+    0x4a, 0x52, 0x8b, 0x5a, 0x03, 0x77, 0xd4, 0xea, 0x71, 0x8a, 0x0f, 0x02, 0x9d, 0x4d, 0xef,
+    0x5b, 0x08, 0x69, 0x03, 0xb8, 0xa6, 0x15, 0xc9, 0xe9, 0x52, 0x10, 0x49, 0xa3, 0x00, 0x50,
+    0x04, 0x7b, 0x31, 0xd8, 0x51, 0x8a, 0x79, 0x34, 0xca, 0x04, 0x34, 0xd3, 0x76, 0x67, 0xad,
+    0x48, 0x17, 0x26, 0xa6, 0x48, 0x0f, 0x53, 0xc5, 0x17, 0x0b, 0x15, 0xc4, 0x75, 0x2a, 0xc7,
+    0x81, 0x9c, 0x71, 0x56, 0x42, 0x2a, 0xf4, 0x14, 0xd9, 0x08, 0x03, 0x03, 0xad, 0x2b, 0x95,
+    0x62, 0x12, 0x00, 0xa4, 0xa7, 0x88, 0xc9, 0xef, 0x8a, 0x46, 0x40, 0x3a, 0x1a, 0x2e, 0x04,
+    0x47, 0xde, 0xa3, 0x65, 0x18, 0xa9, 0x18, 0xd4, 0x64, 0x50, 0x21, 0xb8, 0x1d, 0x6a, 0x27,
+    0x07, 0x3c, 0x77, 0xa9, 0x69, 0x0f, 0x14, 0x08, 0x84, 0xae, 0xdf, 0xad, 0x37, 0xad, 0x48,
+    0xc3, 0x8f, 0x7a, 0x8c, 0xe4, 0x53, 0x01, 0xa6, 0x98, 0x69, 0xc7, 0x34, 0x98, 0xa0, 0x96,
+    0x47, 0xde, 0x9a, 0xcb, 0x9a, 0x93, 0x14, 0x6d, 0xa0, 0x9b, 0x11, 0x00, 0x05, 0x66, 0x6b,
+    0x3a, 0xc4, 0x5a, 0x64, 0x3b, 0x40, 0xdf, 0x70, 0xe3, 0xe4, 0x8c, 0x7f, 0x33, 0x4f, 0xd6,
+    0x35, 0x78, 0xf4, 0xc8, 0x82, 0x20, 0xf3, 0x2e, 0x64, 0xe2, 0x38, 0xc7, 0x5f, 0xa9, 0xac,
+    0x7b, 0x0d, 0x26, 0x59, 0x27, 0x37, 0x97, 0xed, 0xbe, 0x77, 0xe7, 0x07, 0xb7, 0xb5, 0x67,
+    0x29, 0x36, 0xf9, 0x63, 0xb9, 0x5a, 0x25, 0x76, 0x54, 0xb0, 0xd3, 0x2e, 0x2f, 0x6e, 0x0d,
+    0xe5, 0xe9, 0x2d, 0x23, 0x1c, 0x80, 0x7b, 0x56, 0xef, 0x96, 0x96, 0xd1, 0x12, 0x48, 0x00,
+    0x75, 0xa7, 0xcd, 0x3c, 0x76, 0xd1, 0xf3, 0x81, 0xe8, 0x2b, 0x9d, 0xd4, 0xf5, 0x56, 0x98,
+    0x63, 0xa2, 0x0e, 0xc3, 0xbd, 0x2f, 0x76, 0x9a, 0x26, 0xd2, 0xa8, 0xc9, 0x35, 0x0d, 0x6d,
+    0x80, 0x31, 0xc4, 0x76, 0xaf, 0xaf, 0x7a, 0xe7, 0xe5, 0x9c, 0xbb, 0x12, 0x33, 0x93, 0xdc,
+    0xd2, 0x48, 0xed, 0x33, 0x64, 0xf0, 0x3b, 0x0a, 0x5d, 0x81, 0x06, 0x7a, 0x9a, 0xe2, 0x9d,
+    0x47, 0x36, 0x75, 0x46, 0x0a, 0x2b, 0x42, 0x16, 0x3c, 0x60, 0xd3, 0x11, 0x8a, 0x38, 0x6f,
+    0x4a, 0x7b, 0x72, 0x49, 0xa6, 0xf5, 0xac, 0x19, 0x46, 0x9c, 0x37, 0x1b, 0x93, 0x09, 0xd2,
+    0xa7, 0x2c, 0x00, 0xaa, 0x96, 0xc5, 0x76, 0x85, 0x5e, 0xdd, 0x6a, 0xcf, 0x00, 0x67, 0xbd,
+    0x75, 0xc1, 0xbb, 0x12, 0xc4, 0x7e, 0x06, 0x4d, 0x46, 0x83, 0x1c, 0x9a, 0x56, 0x6d, 0xcd,
+    0xcf, 0x6a, 0x42, 0xde, 0xbd, 0x29, 0x5c, 0x62, 0x93, 0xdc, 0xd5, 0x49, 0xa5, 0x2c, 0x76,
+    0xad, 0x2c, 0xd3, 0x67, 0x81, 0x55, 0xc9, 0xda, 0x08, 0xfe, 0x23, 0xd6, 0xb2, 0x9c, 0xba,
+    0x21, 0xa1, 0x18, 0xe3, 0xe5, 0x1f, 0x89, 0xa5, 0x8e, 0x32, 0xe7, 0xda, 0x9a, 0x8b, 0x93,
+    0x5b, 0x76, 0x36, 0x62, 0x34, 0x13, 0x4a, 0x3d, 0xc0, 0xf4, 0xa5, 0x4e, 0x0e, 0x6c, 0x52,
+    0x95, 0x91, 0x02, 0x5b, 0x8b, 0x78, 0x83, 0xb8, 0x05, 0xcf, 0xdd, 0x5f, 0xeb, 0x4d, 0x96,
+    0x37, 0xf2, 0x8b, 0xf7, 0x35, 0x64, 0x0f, 0x3e, 0x66, 0x91, 0xfe, 0xe8, 0xa8, 0xee, 0xe5,
+    0x2a, 0x9c, 0x75, 0x6e, 0x05, 0x74, 0x38, 0xa5, 0x1f, 0x22, 0x53, 0x32, 0xb6, 0x12, 0x6a,
+    0xd5, 0xb4, 0x20, 0x36, 0xf3, 0x83, 0x8e, 0xd4, 0xc5, 0x5c, 0xf2, 0x6a, 0xe4, 0x48, 0x14,
+    0x7b, 0x9a, 0xc6, 0x11, 0xd4, 0xa6, 0xc5, 0xfb, 0xdd, 0xaa, 0x27, 0x43, 0x8a, 0xb0, 0xa3,
+    0x9a, 0x6c, 0xab, 0xc5, 0x6c, 0xe3, 0x74, 0x22, 0x8c, 0x83, 0x6b, 0x8a, 0xb9, 0x6a, 0xf8,
+    0x22, 0xa9, 0x5c, 0xb7, 0xef, 0x17, 0xe9, 0x53, 0x5b, 0x37, 0xcc, 0x2b, 0x28, 0x3b, 0x48,
+    0x6f, 0x63, 0xd7, 0xbe, 0x19, 0x6b, 0x47, 0x4f, 0xd6, 0x2d, 0x9b, 0x3f, 0x2b, 0x37, 0x94,
+    0xdf, 0x46, 0xe9, 0xfa, 0xe2, 0xbd, 0x6b, 0xc7, 0xda, 0x7a, 0x6a, 0x3a, 0x2a, 0x5d, 0xa2,
+    0xee, 0x29, 0xf3, 0x70, 0x33, 0xc7, 0x71, 0xf9, 0x1f, 0xd2, 0xbe, 0x75, 0xd0, 0x2e, 0xbc,
+    0xa9, 0xc0, 0xc9, 0x01, 0xb8, 0xfa, 0x1a, 0xfa, 0x4b, 0xc3, 0xfa, 0x82, 0x6b, 0xfe, 0x16,
+    0xc3, 0xed, 0x67, 0x29, 0xf3, 0xa9, 0xfe, 0xf0, 0xfb, 0xc3, 0xfc, 0xf6, 0x35, 0xa5, 0x7f,
+    0x76, 0x4a, 0xa2, 0x35, 0xc3, 0x34, 0xe3, 0xca, 0xfa, 0x7e, 0x47, 0x8d, 0xe9, 0x7a, 0x71,
+    0x1a, 0xb2, 0xc6, 0x47, 0xdd, 0x6c, 0xff, 0x00, 0x85, 0x7d, 0x0b, 0xa5, 0xc5, 0xe4, 0xe9,
+    0xb0, 0x27, 0xa2, 0xd7, 0x94, 0xdb, 0xe9, 0xdf, 0x64, 0xf1, 0x0a, 0xa3, 0x0e, 0x8d, 0xb7,
+    0x91, 0xd4, 0x64, 0x60, 0xfe, 0x22, 0xbd, 0x76, 0xd8, 0x6d, 0xb5, 0x88, 0x7a, 0x20, 0xfe,
+    0x55, 0x18, 0x99, 0x5e, 0xc5, 0x38, 0x72, 0x42, 0xde, 0x63, 0xd5, 0xb2, 0xcc, 0x33, 0xd0,
+    0xd7, 0x88, 0xfc, 0x6c, 0x93, 0x3a, 0x9d, 0xac, 0x7f, 0xdd, 0x8c, 0x9f, 0xe5, 0x5e, 0xcd,
+    0x6e, 0xdb, 0xe7, 0x90, 0xff, 0x00, 0x9e, 0xb5, 0xe1, 0xbf, 0x18, 0xe7, 0x13, 0x78, 0x88,
+    0x20, 0x3f, 0xea, 0xe3, 0xda, 0x7e, 0xb5, 0x18, 0x7f, 0x8c, 0xce, 0xaa, 0xe5, 0x84, 0xbd,
+    0x0f, 0x16, 0xbd, 0xfb, 0xe6, 0xb3, 0x1c, 0x73, 0x5a, 0x97, 0x8b, 0xf3, 0x9a, 0xce, 0x2b,
+    0xcf, 0x22, 0xaa, 0xaa, 0xd4, 0xce, 0x1b, 0x10, 0x63, 0x34, 0xe0, 0xb5, 0x30, 0x8f, 0x34,
+    0xed, 0x98, 0xac, 0xb9, 0x4a, 0xb9, 0x00, 0x5a, 0x08, 0xa9, 0x4a, 0xd3, 0x36, 0xd2, 0xb0,
+    0x0c, 0x1c, 0x9a, 0x5a, 0x08, 0xa0, 0x7a, 0x1a, 0x00, 0x43, 0x4c, 0x2b, 0x52, 0x91, 0x4d,
+    0x3c, 0x52, 0x18, 0xeb, 0x73, 0xce, 0x29, 0xb3, 0x8c, 0x49, 0x9a, 0x22, 0x38, 0x97, 0x15,
+    0x24, 0xeb, 0x90, 0x0d, 0x3d, 0xe2, 0x22, 0x28, 0xfe, 0xf1, 0x14, 0xc7, 0xe1, 0x8d, 0x2a,
+    0x1c, 0x38, 0xa5, 0x94, 0x61, 0xea, 0x7a, 0x0c, 0x7a, 0x63, 0x68, 0xa1, 0x9c, 0x2f, 0xb9,
+    0xa8, 0x68, 0xa2, 0xe0, 0x29, 0x62, 0xdd, 0x68, 0x00, 0x93, 0x81, 0x4e, 0x44, 0x2c, 0x6a,
+    0xf4, 0x16, 0xe0, 0x0d, 0xc4, 0x62, 0xaa, 0x31, 0x72, 0x13, 0x76, 0x20, 0x86, 0xd4, 0x9e,
+    0x5a, 0xac, 0x3b, 0x80, 0x36, 0xa0, 0xe3, 0xd6, 0xa5, 0x6f, 0x41, 0xd2, 0x98, 0x45, 0x6c,
+    0xa2, 0x96, 0x88, 0x8b, 0xdf, 0x72, 0xbb, 0x29, 0x34, 0xca, 0x99, 0x9b, 0x07, 0x02, 0xa0,
+    0x62, 0x49, 0xc5, 0x44, 0xac, 0x5a, 0x10, 0xb6, 0x3a, 0x73, 0x4c, 0xd8, 0xcd, 0xd4, 0xd4,
+    0x81, 0x3d, 0x6a, 0x45, 0x8d, 0x9b, 0xa0, 0xe2, 0xa6, 0xd7, 0x02, 0x0f, 0x28, 0x7a, 0xd3,
+    0x19, 0x71, 0x56, 0x24, 0x42, 0x9d, 0x6a, 0xbb, 0x1a, 0x99, 0x2b, 0x02, 0x1b, 0x45, 0x14,
+    0x54, 0x8c, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x94, 0x0a, 0x00, 0x00, 0xa5, 0xc6, 0x28,
+    0xcd, 0x26, 0x69, 0x81, 0xd8, 0x01, 0x59, 0xb7, 0x8a, 0x6c, 0xae, 0x44, 0xeb, 0xfe, 0xa6,
+    0x4f, 0x96, 0x41, 0xfd, 0x6b, 0x58, 0x27, 0xb5, 0x41, 0x7d, 0x07, 0x99, 0x63, 0x30, 0x61,
+    0xfc, 0x39, 0xaf, 0x4a, 0x6a, 0xeb, 0x43, 0x9d, 0x4b, 0x52, 0x96, 0x9b, 0x32, 0x2c, 0xf2,
+    0xda, 0x86, 0x0c, 0xab, 0xf3, 0x21, 0xf6, 0x34, 0xeb, 0xf5, 0x59, 0x67, 0x45, 0x7e, 0x22,
+    0x88, 0x6f, 0x62, 0x7f, 0x95, 0x62, 0x59, 0xc9, 0x2c, 0x37, 0x6a, 0xd1, 0x29, 0x67, 0x1f,
+    0xc2, 0x3b, 0xd5, 0xf0, 0x97, 0x3a, 0x8d, 0xc0, 0xb6, 0x2b, 0xb0, 0x29, 0xcc, 0xad, 0x9a,
+    0xe7, 0x8d, 0x4e, 0x68, 0xda, 0xc6, 0x8d, 0x59, 0xdc, 0xa5, 0x71, 0x39, 0x95, 0x9e, 0x53,
+    0xc6, 0xf3, 0x80, 0x3d, 0x05, 0x69, 0x68, 0x56, 0x9c, 0x35, 0xcb, 0x0f, 0xf6, 0x56, 0xb2,
+    0xae, 0x70, 0xf7, 0x25, 0x10, 0x7c, 0xa0, 0xed, 0x51, 0x5d, 0x75, 0xac, 0x02, 0xde, 0xda,
+    0x38, 0x87, 0xf0, 0xae, 0x29, 0x51, 0x8f, 0x34, 0xdb, 0x7d, 0x05, 0x52, 0x56, 0x88, 0x93,
+    0xca, 0x96, 0xf0, 0xb4, 0xb2, 0x9c, 0x2a, 0xfe, 0xb5, 0x4e, 0xc7, 0x54, 0x4b, 0xc9, 0xcc,
+    0x42, 0x36, 0x53, 0x8c, 0x8c, 0xf7, 0xa8, 0x75, 0xf9, 0x31, 0xf6, 0x78, 0xdb, 0xee, 0x16,
+    0xcb, 0x53, 0xe3, 0xbe, 0xb5, 0x5b, 0x95, 0x65, 0x70, 0x42, 0x21, 0xfb, 0xa3, 0xd7, 0xb5,
+    0x6e, 0xe7, 0xef, 0xda, 0xf6, 0xb1, 0x0a, 0x3e, 0xed, 0xca, 0x1a, 0xac, 0xa1, 0x35, 0x19,
+    0x97, 0x19, 0xdd, 0x18, 0x5f, 0xc6, 0xae, 0x58, 0xb7, 0x9d, 0xe1, 0xdb, 0x88, 0xfb, 0xa1,
+    0xac, 0xfb, 0xc4, 0x79, 0xe6, 0xde, 0x63, 0x22, 0x49, 0x9f, 0x20, 0x1e, 0xc2, 0xad, 0x68,
+    0xac, 0x05, 0x9d, 0xea, 0x9e, 0x85, 0x0d, 0x63, 0x16, 0xfd, 0xa3, 0xf3, 0xb9, 0x72, 0x5e,
+    0xea, 0x3a, 0x4d, 0x3e, 0x18, 0xe6, 0xd2, 0xe3, 0x94, 0xbe, 0x1b, 0x60, 0xa5, 0x09, 0xc7,
+    0x35, 0x5b, 0x4a, 0xc3, 0xe9, 0x96, 0xe4, 0x7f, 0x77, 0x15, 0x74, 0x8a, 0xeb, 0x8e, 0xc8,
+    0xe4, 0x9b, 0xf7, 0x99, 0x11, 0x50, 0x29, 0x40, 0xa7, 0xe2, 0x94, 0x0a, 0xab, 0x93, 0x71,
+    0x81, 0x45, 0x38, 0x0a, 0x70, 0x5a, 0x5c, 0x52, 0x26, 0xe3, 0x71, 0x4b, 0x8a, 0x76, 0x29,
+    0x40, 0xa6, 0x03, 0x76, 0xd4, 0xd1, 0xa6, 0x39, 0xa6, 0xe2, 0xa5, 0x5e, 0x94, 0x00, 0xb4,
+    0xa0, 0x53, 0x7a, 0x9a, 0x91, 0x47, 0x14, 0x14, 0x28, 0x18, 0xa8, 0xdc, 0xf3, 0x52, 0x37,
+    0x02, 0xa3, 0xa6, 0x0c, 0x66, 0x29, 0x40, 0xa7, 0x01, 0x4e, 0x55, 0x24, 0xd0, 0x21, 0x02,
+    0xe4, 0xd4, 0xaa, 0xb8, 0xa7, 0x2a, 0x00, 0x2a, 0xa6, 0xab, 0x76, 0x2c, 0x74, 0xd9, 0xa7,
+    0x27, 0x05, 0x57, 0x0b, 0xf5, 0x3d, 0x29, 0x3d, 0x15, 0xd8, 0xd2, 0xbb, 0xb1, 0x87, 0x68,
+    0xbf, 0xda, 0xfe, 0x33, 0x69, 0x3a, 0xc5, 0x6a, 0x38, 0xfc, 0x3f, 0xfa, 0xf5, 0xa1, 0xad,
+    0xde, 0x2d, 0xba, 0x4b, 0x21, 0x3f, 0x70, 0x71, 0xee, 0x69, 0x3c, 0x25, 0x68, 0x6d, 0x34,
+    0x69, 0xaf, 0xa5, 0xfb, 0xf3, 0x92, 0x72, 0x7d, 0x07, 0xf9, 0x35, 0x9b, 0x7b, 0xfe, 0x9d,
+    0x72, 0xfb, 0xbf, 0xd4, 0x43, 0xf3, 0x3f, 0xbb, 0x76, 0x15, 0x94, 0x2e, 0xa1, 0x7e, 0xac,
+    0xdd, 0xa4, 0xe4, 0x97, 0x44, 0x65, 0xdb, 0x83, 0x05, 0xb3, 0x4c, 0xff, 0x00, 0xeb, 0x65,
+    0x39, 0xa4, 0x87, 0x06, 0x4d, 0xcd, 0xd0, 0x52, 0x5c, 0x4b, 0xbd, 0xf8, 0xe8, 0x38, 0x15,
+    0x18, 0x3d, 0x05, 0x60, 0xdd, 0x9d, 0x97, 0x43, 0xa0, 0x7d, 0xe4, 0xcd, 0xf6, 0x62, 0x07,
+    0xde, 0x90, 0xed, 0x02, 0x92, 0x55, 0x16, 0xb6, 0x89, 0x18, 0xea, 0x06, 0x4f, 0xd6, 0x96,
+    0x15, 0xf3, 0xae, 0xf7, 0x1f, 0xb9, 0x0f, 0x4f, 0xf7, 0xaa, 0x0d, 0x42, 0x5d, 0xce, 0x47,
+    0x61, 0xc5, 0x4c, 0x9e, 0x8e, 0x43, 0x1d, 0x63, 0xc5, 0xb3, 0x13, 0xdd, 0xaa, 0xec, 0x27,
+    0x35, 0x4e, 0x21, 0xb2, 0xdd, 0x17, 0xdb, 0x35, 0x6a, 0x0e, 0xf5, 0x54, 0xf4, 0xb2, 0x13,
+    0x2a, 0x6a, 0x7f, 0x34, 0xd1, 0x28, 0xeb, 0x8a, 0x86, 0xd2, 0x4e, 0xb1, 0x9e, 0xfd, 0x2a,
+    0x4b, 0xe3, 0xfe, 0x9b, 0x1f, 0xb0, 0x15, 0x5b, 0x05, 0x59, 0xb6, 0xfd, 0xe5, 0x39, 0x15,
+    0x94, 0xdf, 0xbe, 0xd8, 0xd6, 0xc4, 0xec, 0x9d, 0x53, 0xb8, 0xe4, 0x54, 0xa8, 0xc2, 0x58,
+    0xf0, 0x7a, 0x8a, 0x38, 0x95, 0x15, 0xc7, 0x5e, 0xb5, 0x1e, 0x76, 0x3e, 0xf1, 0xd0, 0xf5,
+    0x14, 0xf6, 0x02, 0xfd, 0xa4, 0xcc, 0xa7, 0x61, 0xea, 0x3a, 0x54, 0xf7, 0x16, 0x71, 0xde,
+    0x2e, 0xf8, 0xce, 0xc9, 0x87, 0xeb, 0x54, 0x46, 0x0e, 0x18, 0x7e, 0x75, 0x6e, 0x29, 0x73,
+    0x83, 0x9c, 0x30, 0xae, 0x88, 0x34, 0xd7, 0x2c, 0x89, 0x6b, 0xaa, 0x28, 0x1d, 0xf1, 0x3f,
+    0x97, 0x2a, 0xec, 0x71, 0xfa, 0xd4, 0xaa, 0xfe, 0xb5, 0xa8, 0xc2, 0x1b, 0xb4, 0xf2, 0xe7,
+    0x51, 0x9e, 0xcd, 0x54, 0x27, 0xd3, 0x27, 0x83, 0x98, 0x4f, 0x9a, 0x9e, 0x9d, 0xc5, 0x4c,
+    0xa9, 0xca, 0x3a, 0xad, 0x50, 0x94, 0x96, 0xcc, 0x06, 0x0f, 0xdd, 0x38, 0xfa, 0xd3, 0xc4,
+    0x8e, 0x9e, 0xe2, 0xaa, 0x09, 0x31, 0xc3, 0x02, 0x0f, 0xa1, 0xa7, 0xac, 0x9e, 0x86, 0xa5,
+    0x48, 0xa3, 0x4a, 0x1d, 0x46, 0x48, 0xc8, 0xc3, 0x91, 0xf5, 0xad, 0x38, 0x35, 0xe7, 0x03,
+    0x12, 0x00, 0xe3, 0xf3, 0xae, 0x74, 0x37, 0xa8, 0x06, 0x9c, 0x0a, 0xfa, 0x91, 0x5a, 0xc6,
+    0xac, 0x91, 0x0e, 0x9c, 0x5f, 0x43, 0xaa, 0x5d, 0x4a, 0xc6, 0x5e, 0xa8, 0xd1, 0xb7, 0xaa,
+    0x9c, 0x53, 0xd6, 0xf1, 0x83, 0x7e, 0xea, 0xe6, 0x40, 0xbd, 0xb9, 0xcd, 0x72, 0xf1, 0xb7,
+    0x6d, 0xc4, 0xd4, 0xa1, 0xc8, 0xe8, 0x6b, 0x55, 0x54, 0xc9, 0xd1, 0x5d, 0x19, 0xd6, 0xc7,
+    0x7d, 0x3f, 0x04, 0x5e, 0x2e, 0x7d, 0x19, 0x6a, 0xec, 0x77, 0x57, 0x6e, 0x38, 0xbb, 0xb7,
+    0xcf, 0xd7, 0x15, 0xc4, 0xad, 0xc4, 0x83, 0xa3, 0xb7, 0xe7, 0x52, 0x0b, 0xc9, 0x7f, 0xbd,
+    0x9f, 0xad, 0x5f, 0x3a, 0x17, 0xb2, 0x92, 0xea, 0x77, 0x0b, 0xf6, 0xe9, 0x3f, 0xe5, 0xe6,
+    0x03, 0xf4, 0x6a, 0x74, 0x76, 0xb7, 0x4c, 0xdc, 0xdd, 0xa2, 0x81, 0xfd, 0xd6, 0xae, 0x21,
+    0x2e, 0xdc, 0x38, 0x2c, 0x72, 0x2b, 0x46, 0xdf, 0x53, 0x8e, 0x21, 0xf2, 0xc4, 0xd9, 0xfa,
+    0xd5, 0x26, 0x99, 0x2e, 0x2d, 0x79, 0x9d, 0x9f, 0x95, 0x18, 0x41, 0xbe, 0x53, 0x21, 0xc5,
+    0x54, 0xbb, 0xb5, 0x8a, 0xe2, 0x23, 0x1f, 0x97, 0x85, 0x60, 0x41, 0x22, 0xb0, 0x3f, 0xb7,
+    0x25, 0x03, 0x22, 0x06, 0xc7, 0xfb, 0xd5, 0x34, 0x5e, 0x20, 0xdf, 0xc1, 0x63, 0x19, 0xff,
+    0x00, 0x68, 0x64, 0x50, 0x36, 0xf4, 0xd8, 0xe6, 0x6f, 0x3c, 0x39, 0x3e, 0x8a, 0xec, 0xec,
+    0xbe, 0x64, 0x2c, 0x72, 0xb2, 0xa8, 0xe0, 0x0f, 0x43, 0xe8, 0x6a, 0x8c, 0xdb, 0x84, 0x0e,
+    0x57, 0xae, 0x38, 0xaf, 0x4d, 0xd3, 0xef, 0x1a, 0x73, 0x9d, 0xf0, 0xc9, 0x19, 0xe0, 0x82,
+    0x47, 0x35, 0x6e, 0x5f, 0x0a, 0x78, 0x7f, 0x50, 0x1b, 0x9e, 0x04, 0x86, 0x43, 0xd4, 0xc4,
+    0xdb, 0x7f, 0x95, 0x61, 0x2a, 0x49, 0x2b, 0x44, 0xda, 0x13, 0xe6, 0x47, 0x27, 0xe0, 0x83,
+    0x69, 0xfd, 0x8b, 0xb6, 0x26, 0x53, 0x70, 0x5c, 0x99, 0x47, 0xf1, 0x7b, 0x7e, 0x18, 0xae,
+    0x92, 0x59, 0xa2, 0xb7, 0x42, 0xf3, 0x4a, 0x91, 0xa0, 0xea, 0xce, 0xc0, 0x0a, 0xa8, 0xff,
+    0x00, 0x0d, 0xf4, 0x28, 0xa5, 0xf3, 0x22, 0xd5, 0x6e, 0x6d, 0xdb, 0xd5, 0x64, 0x00, 0x8a,
+    0xa5, 0x77, 0xe1, 0x3f, 0x08, 0xda, 0x13, 0x25, 0xf6, 0xb3, 0x75, 0x73, 0x20, 0xe7, 0x6f,
+    0x99, 0x92, 0xdf, 0x90, 0xa7, 0x09, 0x4a, 0x31, 0x4a, 0xc0, 0xe1, 0xad, 0xee, 0x57, 0xbf,
+    0xf1, 0xb6, 0x9d, 0x65, 0xc5, 0xb6, 0x6e, 0xe4, 0x07, 0x9d, 0xbc, 0x28, 0xfc, 0x6b, 0xa9,
+    0xb2, 0xb9, 0x5b, 0xdb, 0x18, 0x2e, 0x51, 0x4a, 0xac, 0xa8, 0x1c, 0x03, 0xdb, 0x35, 0xe5,
+    0x7a, 0xe5, 0xde, 0x9a, 0x84, 0x59, 0x69, 0x96, 0x4b, 0x14, 0x59, 0xcb, 0x48, 0x79, 0x72,
+    0x2b, 0xa8, 0xb7, 0xf1, 0xee, 0x93, 0x6d, 0x69, 0x14, 0x29, 0x6d, 0x73, 0x88, 0xd0, 0x20,
+    0x18, 0x1d, 0x87, 0xd6, 0xa6, 0x35, 0x7d, 0xe6, 0xa4, 0xd0, 0x72, 0xd9, 0x68, 0x76, 0x74,
+    0xe0, 0xa5, 0xba, 0x0e, 0x2b, 0x82, 0xbb, 0xf8, 0x8e, 0xbb, 0x4f, 0xd9, 0x2c, 0x18, 0xff,
+    0x00, 0xb5, 0x2b, 0x77, 0xfa, 0x0a, 0xe9, 0xfc, 0x33, 0xa9, 0xde, 0x6a, 0x9a, 0x30, 0xba,
+    0xbd, 0x89, 0x23, 0x67, 0x73, 0xb0, 0x20, 0xc6, 0x57, 0xd7, 0xf9, 0xd6, 0x91, 0xab, 0x19,
+    0x3b, 0x45, 0x8e, 0xcd, 0x1a, 0x67, 0xad, 0x26, 0x29, 0xe3, 0xad, 0x26, 0x6a, 0xc4, 0x37,
+    0x07, 0xbd, 0x37, 0x04, 0xd3, 0xf3, 0x4d, 0x39, 0xa6, 0x21, 0xa4, 0x1c, 0xe0, 0x53, 0x92,
+    0x12, 0x4d, 0x4b, 0x1c, 0x44, 0x8c, 0x9a, 0x9f, 0x01, 0x46, 0x05, 0x2b, 0x8d, 0x44, 0x8d,
+    0x50, 0x2f, 0x41, 0x4b, 0xf5, 0xa5, 0xc9, 0x34, 0x62, 0x91, 0x43, 0x4f, 0x5a, 0x4c, 0x2a,
+    0x8a, 0x71, 0xc0, 0xe6, 0xa1, 0x62, 0x4f, 0x6e, 0x28, 0x48, 0x01, 0x9f, 0xd2, 0xa3, 0x39,
+    0x20, 0xd3, 0xb6, 0x9f, 0x43, 0x48, 0x46, 0x29, 0x88, 0x12, 0x23, 0x21, 0xe0, 0x53, 0x64,
+    0x88, 0xa1, 0xf9, 0x86, 0x2b, 0x43, 0x4e, 0x9a, 0x28, 0xe4, 0xcc, 0x9d, 0x29, 0xba, 0x9c,
+    0xd1, 0x4b, 0x26, 0x63, 0xe9, 0x53, 0x7d, 0x6c, 0x3e, 0x55, 0x6b, 0x99, 0x3b, 0x4f, 0xa5,
+    0x31, 0xba, 0xd4, 0xc4, 0xd3, 0x36, 0x8c, 0xe6, 0xa8, 0x8b, 0x11, 0x1a, 0x61, 0x15, 0x33,
+    0x28, 0x34, 0xc2, 0x87, 0x34, 0x05, 0x88, 0xb1, 0x48, 0x56, 0xa4, 0x22, 0x9b, 0x8a, 0x57,
+    0x15, 0x88, 0xf1, 0x59, 0x9a, 0xb6, 0xaa, 0x9a, 0x7a, 0x2c, 0x71, 0x8f, 0x32, 0xea, 0x4e,
+    0x12, 0x31, 0xfc, 0xcf, 0xb5, 0x4d, 0xac, 0x6a, 0x51, 0xe9, 0x96, 0x66, 0x43, 0x86, 0x95,
+    0xbe, 0x58, 0xd3, 0xd4, 0xd6, 0x36, 0x97, 0x63, 0x23, 0xc8, 0xd7, 0xd7, 0x67, 0x7d, 0xc4,
+    0x9c, 0xf3, 0xfc, 0x3e, 0xd5, 0x2e, 0x4e, 0xf6, 0x42, 0x76, 0x4a, 0xe3, 0xf4, 0xfd, 0x33,
+    0x12, 0x9b, 0xcb, 0xb3, 0xe6, 0xdd, 0x3f, 0x25, 0x8f, 0x6f, 0x61, 0x57, 0xe6, 0x75, 0x89,
+    0x0b, 0x31, 0xc0, 0x03, 0x35, 0x21, 0x21, 0x54, 0x92, 0x70, 0x05, 0x72, 0xba, 0xd6, 0xae,
+    0x25, 0x7f, 0x2a, 0x23, 0xf2, 0xfb, 0x77, 0xa4, 0xe4, 0xa0, 0xae, 0x42, 0x8b, 0x9b, 0x20,
+    0xd4, 0x75, 0x0f, 0x32, 0x46, 0x6c, 0xf0, 0x4f, 0x02, 0xb2, 0x5d, 0x9a, 0x47, 0xcb, 0x7e,
+    0x54, 0x8c, 0xe5, 0xdb, 0x26, 0x8e, 0xa7, 0x03, 0xa9, 0xae, 0x19, 0xcd, 0xcd, 0x9d, 0x71,
+    0x8a, 0x4a, 0xc8, 0x07, 0x5c, 0x2f, 0x27, 0xd6, 0x9d, 0x3d, 0xbc, 0xb0, 0x28, 0x67, 0x18,
+    0x0c, 0x32, 0x01, 0xad, 0xad, 0x37, 0x4e, 0x58, 0x94, 0x4d, 0x38, 0x1b, 0xfa, 0xaa, 0x9e,
+    0xd5, 0x9f, 0xad, 0x4c, 0x1e, 0xf3, 0x68, 0xe8, 0xa3, 0x15, 0x4e, 0x9f, 0x2c, 0x39, 0x99,
+    0x0a, 0x77, 0x95, 0x91, 0x06, 0x97, 0x6a, 0x2e, 0xae, 0xf0, 0xdf, 0x75, 0x46, 0xe2, 0x3d,
+    0x6a, 0x6d, 0x62, 0xd6, 0x2b, 0x79, 0x11, 0xe3, 0x5d, 0xa0, 0xf5, 0x02, 0xad, 0x68, 0x31,
+    0x85, 0x8a, 0x59, 0x88, 0xe5, 0x88, 0x50, 0x6a, 0x0d, 0x71, 0xbe, 0x65, 0x1e, 0xa6, 0xab,
+    0x95, 0x2a, 0x37, 0x62, 0xe6, 0x6e, 0xa5, 0x8a, 0x56, 0xe7, 0xf7, 0xa3, 0x15, 0x70, 0xf3,
+    0x59, 0xd6, 0xe4, 0x89, 0x3a, 0xf6, 0xab, 0x9e, 0x6e, 0xd5, 0x24, 0xf6, 0xa8, 0xa6, 0xf4,
+    0x34, 0x62, 0x93, 0x82, 0x4f, 0x6a, 0xae, 0xf2, 0xef, 0xce, 0x3e, 0xed, 0x46, 0xd2, 0xb4,
+    0xa7, 0x6f, 0x41, 0x4f, 0x09, 0x93, 0xd3, 0x81, 0x52, 0xe5, 0x7d, 0x80, 0x84, 0x02, 0x7e,
+    0x63, 0xd7, 0xb5, 0x37, 0x69, 0xcd, 0x5c, 0x10, 0x93, 0x52, 0x45, 0x68, 0xd2, 0xb8, 0x55,
+    0x14, 0x95, 0x36, 0xf6, 0x0b, 0x86, 0x99, 0x6c, 0x24, 0x97, 0x73, 0x8e, 0x17, 0x90, 0x3d,
+    0x6b, 0x56, 0xe4, 0x91, 0x18, 0x51, 0xd5, 0xaa, 0x48, 0x2d, 0x96, 0x05, 0xd8, 0x07, 0x38,
+    0xc9, 0xaa, 0xf2, 0xb6, 0xf9, 0x09, 0xed, 0xda, 0xbb, 0x63, 0x0e, 0x48, 0x58, 0xca, 0xfc,
+    0xd2, 0xb9, 0x1f, 0x0a, 0xa1, 0x45, 0x50, 0xba, 0x39, 0x97, 0x1e, 0x82, 0xaf, 0x8e, 0x49,
+    0x3f, 0x85, 0x67, 0x4d, 0xcc, 0xcd, 0xf5, 0xac, 0xaa, 0xbf, 0x74, 0xd1, 0x0b, 0x0a, 0xee,
+    0x6f, 0x61, 0x56, 0x76, 0x9c, 0xd3, 0x21, 0x01, 0x54, 0x67, 0xab, 0x55, 0x85, 0x5e, 0x33,
+    0x4a, 0x11, 0xe8, 0x0c, 0x54, 0x18, 0x27, 0x34, 0xc9, 0x06, 0x45, 0x58, 0x8d, 0x33, 0x93,
+    0x51, 0xcc, 0xbb, 0x57, 0x3d, 0x2b, 0x66, 0xb4, 0x26, 0xfa, 0x98, 0xb7, 0x07, 0xf7, 0xc4,
+    0x7a, 0x53, 0xe0, 0x7d, 0xac, 0x0d, 0x57, 0x76, 0xdd, 0x23, 0x37, 0xa9, 0xa7, 0xa1, 0xc1,
+    0xae, 0x05, 0x2f, 0x7a, 0xe6, 0x87, 0x4b, 0xa7, 0xcb, 0xca, 0x90, 0x6b, 0xd9, 0xfe, 0x1b,
+    0x6b, 0x6d, 0x1c, 0xe6, 0xd5, 0x9c, 0xed, 0x98, 0x65, 0x47, 0xa3, 0x0e, 0xbf, 0x98, 0xfe,
+    0x42, 0xbc, 0x16, 0xce, 0x73, 0x1b, 0x0c, 0x57, 0x77, 0xe1, 0x6d, 0x58, 0xc1, 0x77, 0x13,
+    0x21, 0xdb, 0x22, 0xb0, 0x75, 0xcf, 0x4c, 0x8a, 0xed, 0x56, 0xa9, 0x0b, 0x11, 0x4e, 0x5e,
+    0xce, 0xaa, 0x97, 0x43, 0xdc, 0x75, 0x6b, 0x30, 0x97, 0xb0, 0xde, 0x20, 0xf9, 0x72, 0x32,
+    0x40, 0xfc, 0x8f, 0xf4, 0xfc, 0xab, 0xb4, 0x85, 0xff, 0x00, 0xd0, 0x51, 0xfb, 0x88, 0xc1,
+    0xfd, 0x2b, 0x98, 0xb3, 0x9e, 0x2d, 0x5b, 0x49, 0x49, 0x17, 0xee, 0xc8, 0x99, 0x03, 0xd0,
+    0xf7, 0x1f, 0x81, 0xad, 0xdb, 0x26, 0x63, 0xa3, 0x28, 0x63, 0x97, 0x0a, 0x43, 0x7d, 0x6b,
+    0x86, 0x4d, 0xda, 0xcf, 0xa1, 0xe8, 0xd7, 0x57, 0x49, 0xae, 0xe3, 0xec, 0x0e, 0x5d, 0xbe,
+    0x95, 0xe0, 0x1f, 0x12, 0x25, 0x7b, 0xad, 0x7a, 0x79, 0x5b, 0xa9, 0x76, 0xfd, 0x38, 0xaf,
+    0x7e, 0xb0, 0xff, 0x00, 0x58, 0xdf, 0x4a, 0xf0, 0x4f, 0x1d, 0x47, 0x9d, 0x62, 0xe3, 0x3d,
+    0xa4, 0x6f, 0xe7, 0x5a, 0xe1, 0xbe, 0x26, 0x73, 0x62, 0x17, 0xbb, 0x2f, 0x91, 0xe5, 0xd7,
+    0x91, 0x9d, 0xc4, 0x01, 0xcf, 0x7a, 0xcf, 0x68, 0xb0, 0x79, 0x15, 0xbd, 0x75, 0x19, 0xde,
+    0x70, 0x2a, 0x84, 0x88, 0x01, 0xae, 0x99, 0xc2, 0xe7, 0x1d, 0x39, 0xe9, 0x63, 0x3b, 0x61,
+    0xa4, 0x23, 0x15, 0x6d, 0xaa, 0xab, 0xe3, 0x71, 0xac, 0x65, 0x1b, 0x1b, 0x26, 0x46, 0x45,
+    0x34, 0xad, 0x3f, 0x14, 0x1c, 0x01, 0x93, 0x59, 0xd8, 0x08, 0x8a, 0xd3, 0x1b, 0x03, 0xad,
+    0x5b, 0x5b, 0x79, 0x65, 0x80, 0xc9, 0x1e, 0x31, 0xdb, 0x3d, 0xeb, 0x3d, 0xb3, 0x9e, 0x6a,
+    0x64, 0xac, 0x34, 0xee, 0x3c, 0x49, 0xda, 0x94, 0x8a, 0x88, 0xd3, 0x91, 0xf1, 0xc1, 0xe9,
+    0x50, 0x9f, 0x71, 0x81, 0xf9, 0x5c, 0x1a, 0xb4, 0xe3, 0x31, 0xd5, 0x79, 0x30, 0x57, 0x22,
+    0xac, 0x27, 0xcd, 0x18, 0xfa, 0x55, 0x47, 0xaa, 0x13, 0x29, 0xf4, 0x6a, 0x92, 0x51, 0xd0,
+    0xd3, 0x1c, 0x61, 0x8d, 0x3d, 0xb9, 0x84, 0x1f, 0x4a, 0x8e, 0xe3, 0x22, 0xa7, 0xa4, 0x65,
+    0x8d, 0x3a, 0x15, 0x0d, 0x91, 0xe9, 0x5a, 0x56, 0xd6, 0xbc, 0x06, 0x61, 0xf4, 0x15, 0x70,
+    0x87, 0x30, 0x9b, 0x48, 0x6d, 0xb5, 0xb0, 0x0b, 0xb9, 0x87, 0x35, 0x24, 0x8d, 0x93, 0x81,
+    0xd0, 0x54, 0xb2, 0x1c, 0x7c, 0x83, 0xaf, 0x7a, 0x88, 0x83, 0xf7, 0x40, 0xc9, 0x3f, 0xa5,
+    0x74, 0x59, 0x25, 0x64, 0x64, 0xb5, 0x77, 0x64, 0x64, 0xe0, 0x73, 0x51, 0x3c, 0x99, 0xe0,
+    0x74, 0xa5, 0x95, 0x5c, 0x36, 0x1a, 0x95, 0x2d, 0x9d, 0xfa, 0xf0, 0x2a, 0x1d, 0xde, 0x88,
+    0xbd, 0x11, 0x07, 0x53, 0x81, 0xc9, 0xa9, 0x63, 0xb6, 0x76, 0xe7, 0x18, 0xf7, 0x35, 0x76,
+    0x3b, 0x64, 0x8c, 0x67, 0x1c, 0xfa, 0x9a, 0x79, 0x60, 0x3a, 0x50, 0xa9, 0xf7, 0x25, 0xcf,
+    0xb1, 0x5d, 0x6d, 0x91, 0x39, 0x6e, 0x4d, 0x32, 0x69, 0x96, 0x31, 0x81, 0xd6, 0x9b, 0x75,
+    0x39, 0x4e, 0x09, 0xfc, 0x05, 0x67, 0x33, 0xb3, 0x36, 0x49, 0xa9, 0x9c, 0xd4, 0x74, 0x43,
+    0x8c, 0x5b, 0xd5, 0x8f, 0x96, 0x42, 0xe7, 0x9a, 0x8a, 0x82, 0x73, 0x45, 0x62, 0xdd, 0xcd,
+    0x02, 0x8a, 0x28, 0xa4, 0x01, 0x45, 0x14, 0xa0, 0x13, 0xd2, 0x80, 0x12, 0x8a, 0x78, 0x4f,
+    0x5a, 0x5c, 0x0a, 0x76, 0x02, 0x3a, 0x76, 0x31, 0x4b, 0x49, 0x45, 0x80, 0xe9, 0xdf, 0x54,
+    0xbb, 0x89, 0x32, 0x6c, 0xe2, 0x3f, 0x47, 0xac, 0xb9, 0x75, 0xbb, 0x8b, 0xa7, 0xd9, 0x23,
+    0x08, 0xa2, 0x3f, 0x78, 0x46, 0x39, 0xa9, 0xac, 0x9a, 0xc1, 0xdf, 0xcb, 0xbc, 0x88, 0xf3,
+    0xd1, 0xc3, 0x1c, 0x7e, 0x35, 0xb9, 0x15, 0x8d, 0x94, 0x44, 0x18, 0x2d, 0xe3, 0xcf, 0x66,
+    0xc6, 0x6b, 0xb6, 0xd3, 0x9e, 0xcf, 0x43, 0x9d, 0xb8, 0xc1, 0xec, 0x63, 0x41, 0x04, 0xd2,
+    0xa0, 0x5b, 0x3b, 0x7f, 0x2a, 0x36, 0xeb, 0x34, 0x9d, 0x4d, 0x6a, 0x08, 0x63, 0xb2, 0xb1,
+    0x91, 0x63, 0xe3, 0x0a, 0x49, 0x63, 0xd4, 0x9c, 0x75, 0xad, 0x24, 0xb7, 0x66, 0xeb, 0x55,
+    0xb5, 0x8b, 0x63, 0x16, 0x93, 0x70, 0xe3, 0xb2, 0xff, 0x00, 0x5a, 0xd5, 0x45, 0x45, 0x5c,
+    0x8e, 0x77, 0x26, 0x91, 0xc8, 0x69, 0xb1, 0xf9, 0xfa, 0xa4, 0x20, 0xf2, 0x37, 0x6e, 0x3f,
+    0x87, 0x35, 0xd8, 0xe2, 0xb9, 0xbd, 0x0e, 0x10, 0x2f, 0xa1, 0x6e, 0xec, 0x8c, 0x6b, 0xa9,
+    0x0a, 0x2b, 0x3c, 0x32, 0xb4, 0x47, 0x5e, 0x5a, 0xd8, 0xcd, 0xd4, 0xf4, 0xef, 0xb7, 0xc0,
+    0x15, 0x48, 0x12, 0x29, 0xca, 0x93, 0x58, 0x70, 0xda, 0xea, 0x16, 0x32, 0x32, 0xad, 0xae,
+    0xf6, 0x3d, 0xf1, 0x9a, 0xec, 0x00, 0xa7, 0x01, 0x57, 0x3a, 0x4a, 0x4f, 0x9b, 0x66, 0x67,
+    0x1a, 0xce, 0x2a, 0xc6, 0x26, 0x9f, 0xa6, 0xcf, 0xb9, 0xae, 0xaf, 0x0e, 0x65, 0x2a, 0x42,
+    0xa7, 0xf7, 0x45, 0x65, 0x69, 0x9c, 0x43, 0x74, 0xbe, 0xc4, 0x57, 0x63, 0x8a, 0xe4, 0x74,
+    0xf1, 0x83, 0x74, 0x3f, 0xda, 0x35, 0x12, 0x8a, 0x8c, 0xa2, 0xbd, 0x4d, 0x69, 0x4d, 0xca,
+    0xed, 0x9b, 0x7a, 0x0b, 0x6e, 0xd2, 0x63, 0xf6, 0x24, 0x56, 0x99, 0x19, 0xac, 0xcf, 0x0f,
+    0x0f, 0xf8, 0x95, 0xe3, 0xd2, 0x46, 0xfe, 0x75, 0xac, 0x05, 0x6d, 0x4f, 0xe0, 0x46, 0x15,
+    0x17, 0xbe, 0xc6, 0x62, 0x97, 0x14, 0xfd, 0xb4, 0x6d, 0xaa, 0x33, 0xb0, 0xb0, 0xc2, 0xf3,
+    0x48, 0x11, 0x46, 0x49, 0xab, 0xd7, 0x3a, 0x45, 0xc5, 0xb4, 0x42, 0x49, 0x10, 0x80, 0x69,
+    0x9a, 0x7d, 0xc2, 0xdb, 0x5c, 0xab, 0x91, 0x90, 0x0d, 0x6e, 0x6b, 0x1a, 0xec, 0x77, 0xb6,
+    0x8b, 0x12, 0x28, 0x18, 0x14, 0x36, 0xee, 0x6b, 0x18, 0xc5, 0xc5, 0xb6, 0xf5, 0x39, 0x7d,
+    0xb8, 0xa7, 0x01, 0x9a, 0x5c, 0x64, 0xd3, 0x80, 0xa2, 0xe6, 0x76, 0x1b, 0xb6, 0x9c, 0x07,
+    0x14, 0xa0, 0x53, 0xb1, 0x40, 0xec, 0x35, 0x47, 0x35, 0x30, 0x18, 0x14, 0xd4, 0xe0, 0xd4,
+    0x87, 0x81, 0x4c, 0x69, 0x10, 0xb1, 0xe6, 0x93, 0x14, 0xa7, 0x93, 0x40, 0x14, 0x12, 0x20,
+    0x15, 0x34, 0x6b, 0x4c, 0x55, 0xe6, 0xa7, 0x51, 0x81, 0x40, 0xd2, 0x02, 0x2b, 0x98, 0xd7,
+    0xdd, 0xb5, 0x3d, 0x4e, 0xd7, 0x48, 0x84, 0xe7, 0xe6, 0x0d, 0x2e, 0x3b, 0x7f, 0x91, 0x5b,
+    0x9a, 0x9e, 0xa1, 0x16, 0x9b, 0x64, 0xf7, 0x12, 0x1e, 0x47, 0x0a, 0xbf, 0xde, 0x3e, 0x95,
+    0x8f, 0xe1, 0xc0, 0x90, 0xdb, 0x4f, 0xac, 0x5c, 0xe5, 0xa6, 0x98, 0x9d, 0xbe, 0xa7, 0xd8,
+    0x56, 0x73, 0xd5, 0xf2, 0x7f, 0x56, 0x35, 0x82, 0xb7, 0xbc, 0x6a, 0xeb, 0x13, 0xfd, 0x92,
+    0xda, 0x0d, 0x32, 0xd0, 0x03, 0x33, 0x80, 0x88, 0xa3, 0xb0, 0x1d, 0xcf, 0xb5, 0x73, 0x7a,
+    0x9c, 0x89, 0x67, 0x12, 0xd8, 0x42, 0xdb, 0xb6, 0xf3, 0x23, 0xff, 0x00, 0x79, 0xab, 0x56,
+    0xf6, 0x73, 0xa6, 0xc5, 0x25, 0xdd, 0xc1, 0x0d, 0xa8, 0xdc, 0x8e, 0x07, 0xfc, 0xf3, 0x5f,
+    0x4a, 0xe4, 0xdd, 0xcc, 0x8e, 0x59, 0x89, 0x24, 0xf3, 0xcd, 0x45, 0x59, 0xdb, 0x43, 0x58,
+    0x46, 0xee, 0xe2, 0x67, 0x27, 0x34, 0x85, 0x88, 0xfb, 0xbf, 0x78, 0xf0, 0xa2, 0x8a, 0xb1,
+    0x67, 0x09, 0x63, 0xe7, 0xb8, 0xe3, 0xf8, 0x07, 0xf5, 0xae, 0x74, 0xae, 0xec, 0x8d, 0x89,
+    0xa3, 0x41, 0x6d, 0x6f, 0xb4, 0x75, 0x03, 0x24, 0xfa, 0x9a, 0xc9, 0x93, 0x32, 0xce, 0xab,
+    0xea, 0x6b, 0x4a, 0xf6, 0x5d, 0x91, 0x63, 0xb9, 0xac, 0xfb, 0x55, 0xdd, 0x23, 0x48, 0x7b,
+    0x74, 0xfa, 0xd1, 0x53, 0x75, 0x14, 0x0b, 0xb9, 0x6f, 0x23, 0x20, 0x55, 0x98, 0x07, 0xca,
+    0x4d, 0x54, 0x1d, 0x6a, 0xf4, 0x63, 0x6a, 0x01, 0x57, 0x1d, 0xc4, 0xcc, 0xcb, 0x93, 0xbe,
+    0xfc, 0x8f, 0xee, 0x8a, 0x86, 0x4f, 0x95, 0xd5, 0xfd, 0x78, 0xa9, 0x41, 0xdf, 0x79, 0x3b,
+    0x7a, 0x52, 0x48, 0xbb, 0xa2, 0x23, 0xbf, 0x51, 0x58, 0xbd, 0x6e, 0xca, 0x08, 0x64, 0xf2,
+    0xdf, 0x69, 0xfb, 0xad, 0xd3, 0xda, 0xa7, 0x75, 0xda, 0x77, 0x63, 0x2a, 0x7a, 0xd5, 0x25,
+    0xf9, 0xd3, 0xde, 0xac, 0xdb, 0x4d, 0x9f, 0xdd, 0x3f, 0x5e, 0xd9, 0xef, 0x4e, 0x2f, 0xa3,
+    0x13, 0x25, 0x4f, 0xdd, 0x91, 0x9e, 0x63, 0x3f, 0xa5, 0x58, 0xda, 0x57, 0xe6, 0x1c, 0x8f,
+    0x51, 0x55, 0xc8, 0xf2, 0xcf, 0x4c, 0xa1, 0xfd, 0x2a, 0x48, 0xa4, 0x31, 0x1f, 0x58, 0xcf,
+    0xe9, 0x5a, 0x27, 0x6d, 0xc4, 0x59, 0x47, 0xcd, 0x5b, 0x8a, 0xe5, 0x97, 0x83, 0xc8, 0xaa,
+    0x65, 0x41, 0xf9, 0xd7, 0x9a, 0x54, 0x6c, 0xf4, 0x3f, 0x81, 0xad, 0xa3, 0x26, 0x84, 0xd2,
+    0x66, 0x83, 0xc5, 0x6f, 0x74, 0x3e, 0x75, 0x19, 0xfd, 0x6a, 0xa4, 0x9a, 0x38, 0xeb, 0x14,
+    0x84, 0x7b, 0x1a, 0x15, 0x88, 0xa9, 0x92, 0xe1, 0x87, 0x73, 0x57, 0x68, 0x4b, 0x74, 0x45,
+    0xa4, 0xb6, 0x66, 0x7b, 0xe9, 0xd7, 0x71, 0xf4, 0x5d, 0xdf, 0x4a, 0x8f, 0xc8, 0xbc, 0x1f,
+    0xf2, 0xee, 0xe7, 0xf0, 0xad, 0xc5, 0xb9, 0xcf, 0x51, 0xf9, 0x54, 0xab, 0x38, 0xea, 0x0e,
+    0x29, 0x7b, 0x08, 0xf4, 0x62, 0xe7, 0x92, 0xe8, 0x60, 0x2c, 0x57, 0xc0, 0xfc, 0xb6, 0x92,
+    0xfe, 0x0b, 0x4f, 0xfb, 0x3e, 0xaa, 0xdf, 0x76, 0xc6, 0x73, 0xf8, 0x1a, 0xdf, 0x17, 0x12,
+    0x0f, 0xba, 0xed, 0xf8, 0x35, 0x3c, 0x5f, 0xce, 0xbd, 0x1d, 0xc7, 0xe3, 0x9a, 0x3d, 0x82,
+    0xee, 0xc9, 0xf6, 0x92, 0xec, 0x61, 0xc5, 0xa5, 0xeb, 0xd3, 0x60, 0x25, 0x93, 0x28, 0xf5,
+    0x61, 0x8f, 0xe7, 0x57, 0xd3, 0xc2, 0xda, 0xd4, 0xaa, 0x0b, 0x4d, 0x0c, 0x5f, 0xef, 0x1f,
+    0xf0, 0xab, 0x8d, 0xa8, 0x4e, 0xdd, 0x66, 0x7f, 0xfb, 0xe8, 0x8a, 0x89, 0xee, 0x64, 0x3c,
+    0x92, 0x5b, 0xfe, 0x05, 0x4d, 0x51, 0x8a, 0xdd, 0xb1, 0xf3, 0xcd, 0xf4, 0x16, 0x2f, 0x05,
+    0x5d, 0xbf, 0xfc, 0x7c, 0x6a, 0xc8, 0xbe, 0xc8, 0x09, 0xab, 0xb1, 0x78, 0x0e, 0xdb, 0xf8,
+    0xf5, 0x99, 0xb3, 0xec, 0x95, 0x4e, 0x1d, 0x49, 0xa1, 0x60, 0x5a, 0x36, 0x23, 0xd3, 0x35,
+    0x6b, 0xfe, 0x12, 0x47, 0x5f, 0xb9, 0x0a, 0x83, 0xef, 0xcd, 0x3f, 0x67, 0x4d, 0x0b, 0x9a,
+    0xa7, 0x62, 0xd0, 0xf0, 0x0d, 0xb1, 0x1f, 0x2e, 0xb7, 0x70, 0x0f, 0xae, 0xdf, 0xfe, 0xbd,
+    0x30, 0xf8, 0x16, 0x64, 0xff, 0x00, 0x53, 0xad, 0x96, 0x3d, 0xb7, 0xa5, 0x43, 0xff, 0x00,
+    0x09, 0x45, 0xc8, 0xfe, 0x18, 0xff, 0x00, 0x2a, 0x72, 0x78, 0xba, 0xe5, 0x48, 0x3b, 0x63,
+    0x23, 0xd3, 0x1f, 0xfd, 0x7a, 0x7c, 0xb0, 0x2a, 0xf2, 0xec, 0x51, 0xba, 0xd0, 0xb5, 0xfb,
+    0x06, 0xf9, 0x22, 0x4b, 0x94, 0xfe, 0xf4, 0x6d, 0x83, 0xf9, 0x56, 0x7c, 0x97, 0xf7, 0x96,
+    0xbc, 0x5c, 0xc3, 0x71, 0x6e, 0x4f, 0xf7, 0xc1, 0x02, 0xba, 0x45, 0xf1, 0x9c, 0x9d, 0x1e,
+    0xdd, 0x08, 0xf6, 0x35, 0x6d, 0x75, 0xed, 0x1f, 0x52, 0x88, 0xc3, 0x7b, 0x16, 0xd0, 0xdc,
+    0x1c, 0x8a, 0x2d, 0xfc, 0xb2, 0x13, 0xf3, 0x47, 0x26, 0x9a, 0xa5, 0xc9, 0x19, 0x49, 0xce,
+    0x3d, 0x8d, 0x50, 0xbd, 0xd4, 0xde, 0x46, 0xda, 0xa7, 0xcc, 0x97, 0xa0, 0xc0, 0xe9, 0x5d,
+    0x35, 0xef, 0x82, 0x21, 0xb8, 0x8d, 0xa6, 0xd0, 0xef, 0x41, 0x0c, 0x39, 0x88, 0x9c, 0x8f,
+    0xfe, 0xb5, 0x72, 0xb7, 0x11, 0x4b, 0xa4, 0x1f, 0x26, 0x7b, 0x16, 0x8e, 0x7c, 0xf2, 0xc4,
+    0xf0, 0x7e, 0x86, 0xb0, 0xa9, 0x2a, 0x89, 0x5a, 0x5a, 0x17, 0x15, 0x1e, 0x88, 0x8e, 0xde,
+    0x02, 0x84, 0xc9, 0x21, 0xcc, 0x8d, 0xd7, 0xda, 0xa4, 0x96, 0x48, 0xe2, 0x1b, 0x9f, 0x1f,
+    0x97, 0x5a, 0xb7, 0x6b, 0xa2, 0x6b, 0xba, 0x8e, 0x0c, 0x36, 0x86, 0x24, 0x3f, 0xc6, 0xff,
+    0x00, 0x28, 0xfd, 0x6b, 0xa5, 0xd2, 0x3c, 0x05, 0x14, 0x52, 0x2c, 0xfa, 0xa4, 0xdf, 0x68,
+    0x71, 0xcf, 0x96, 0xbf, 0x77, 0xf1, 0xf5, 0xa9, 0x8c, 0x24, 0xf4, 0x8a, 0xfb, 0xca, 0x72,
+    0x46, 0x17, 0x87, 0x7c, 0x3b, 0x3f, 0x88, 0x2e, 0x56, 0xe2, 0xe1, 0x4c, 0x56, 0x11, 0xb7,
+    0xe2, 0xfe, 0xc3, 0xfc, 0x6b, 0xd4, 0x23, 0x89, 0x21, 0x89, 0x62, 0x8d, 0x42, 0xa2, 0x00,
+    0xaa, 0xa3, 0xa0, 0x14, 0xe8, 0x62, 0x8e, 0x08, 0xd6, 0x38, 0xe3, 0x55, 0x45, 0x18, 0x55,
+    0x1c, 0x01, 0x4e, 0xc5, 0x75, 0x53, 0xa6, 0xa0, 0x89, 0x6d, 0xb1, 0x87, 0x8a, 0x4a, 0x71,
+    0x1c, 0xd1, 0x8c, 0xe0, 0x62, 0xac, 0x43, 0x40, 0xc9, 0xa9, 0xd2, 0x20, 0x39, 0x3d, 0x69,
+    0xf1, 0x45, 0x52, 0xb0, 0x0a, 0x30, 0x29, 0x5c, 0xa4, 0x88, 0xc9, 0xc0, 0xa6, 0x72, 0x69,
+    0xe4, 0x52, 0x52, 0x18, 0x80, 0x52, 0x1e, 0x2b, 0x67, 0x48, 0xd2, 0xc5, 0xeb, 0xe0, 0x9a,
+    0x76, 0xb3, 0xa5, 0x2d, 0x91, 0xe0, 0x8a, 0x9e, 0x75, 0x7b, 0x17, 0xc8, 0xf9, 0x79, 0x8c,
+    0x23, 0x4d, 0x34, 0xe2, 0x29, 0x09, 0xc5, 0x51, 0x90, 0xc2, 0xd8, 0xfa, 0xd3, 0x0f, 0x27,
+    0x9a, 0x52, 0x39, 0xe4, 0xf3, 0x4d, 0xe6, 0x9a, 0x18, 0x87, 0x8e, 0x86, 0x98, 0x41, 0x3d,
+    0xea, 0x4d, 0x87, 0x19, 0xe9, 0x51, 0x9a, 0x04, 0x34, 0xaf, 0x14, 0xcc, 0x54, 0x94, 0x9b,
+    0x73, 0xcd, 0x01, 0x62, 0x3c, 0x52, 0x62, 0xa4, 0x22, 0x98, 0x69, 0x08, 0x61, 0x19, 0xa8,
+    0xa7, 0x74, 0x82, 0x27, 0x96, 0x46, 0x0a, 0x8a, 0x32, 0x49, 0xa9, 0xeb, 0x90, 0xd7, 0xef,
+    0x9f, 0x54, 0xd4, 0x06, 0x91, 0x6c, 0xdf, 0xba, 0x53, 0x99, 0xd8, 0x7f, 0x2a, 0x99, 0x4a,
+    0xc0, 0xca, 0xf0, 0x79, 0x9a, 0xe6, 0xa6, 0xd7, 0xf3, 0x02, 0x2d, 0xe3, 0x3b, 0x61, 0x53,
+    0xe9, 0xeb, 0x5b, 0x9c, 0x2a, 0xfa, 0x01, 0x4d, 0xb7, 0x81, 0x2d, 0xe1, 0x58, 0x90, 0x61,
+    0x54, 0x62, 0xb2, 0xb5, 0x8b, 0xfd, 0x83, 0xec, 0xd1, 0x1f, 0x9b, 0xf8, 0xcf, 0xa7, 0xb5,
+    0x25, 0xee, 0xad, 0x4c, 0xb5, 0x93, 0xd0, 0xa1, 0xae, 0xeb, 0x58, 0x53, 0x04, 0x27, 0xe5,
+    0xe8, 0x48, 0xef, 0xff, 0x00, 0xd6, 0xae, 0x60, 0x12, 0xec, 0x5d, 0x8e, 0x4d, 0x3a, 0xe5,
+    0xb7, 0xdc, 0x31, 0xce, 0x40, 0xe0, 0x53, 0xe2, 0x8f, 0x73, 0x05, 0x15, 0xc5, 0x52, 0x6e,
+    0x72, 0x3a, 0x63, 0x15, 0x15, 0x61, 0x44, 0x4d, 0xe5, 0x97, 0xec, 0x2b, 0x53, 0x4a, 0xb0,
+    0xc8, 0xfb, 0x54, 0xa3, 0xe5, 0x1f, 0x74, 0x1e, 0xe7, 0xd6, 0x99, 0x14, 0x22, 0xe2, 0x45,
+    0x85, 0x7e, 0xe2, 0xf2, 0xe6, 0xb6, 0x4e, 0x16, 0xd8, 0x28, 0xc0, 0x1e, 0x95, 0xbd, 0x2a,
+    0x4a, 0xf7, 0x33, 0xab, 0x36, 0x95, 0x91, 0x11, 0x63, 0x82, 0x49, 0xae, 0x62, 0xe4, 0xb3,
+    0xdc, 0x48, 0xc4, 0x72, 0x4e, 0x6b, 0xa3, 0xb8, 0x3b, 0x6d, 0xdc, 0xfb, 0x56, 0x23, 0xa9,
+    0x75, 0x91, 0xb1, 0xc2, 0xf1, 0x45, 0x7d, 0x6c, 0x82, 0x92, 0x34, 0xb4, 0xce, 0x34, 0xd1,
+    0x8f, 0xef, 0x56, 0x6e, 0xb0, 0x49, 0x9e, 0x35, 0x27, 0xa0, 0xcd, 0x68, 0xe9, 0x67, 0x3a,
+    0x78, 0x1f, 0xed, 0x9a, 0xcb, 0xd5, 0x8e, 0x6f, 0xb1, 0xe8, 0xa2, 0xa6, 0xa3, 0xfd, 0xca,
+    0x1c, 0x7e, 0x36, 0x52, 0xdc, 0x54, 0x82, 0x3a, 0xd3, 0x9a, 0x66, 0x71, 0x83, 0xd3, 0xda,
+    0xa3, 0x34, 0xab, 0x5c, 0x97, 0x66, 0xc4, 0xf0, 0xa6, 0x4f, 0xb9, 0xad, 0x5d, 0x3a, 0xc8,
+    0xdd, 0xdf, 0x5b, 0xdb, 0xaa, 0x93, 0xe6, 0x48, 0xa9, 0x81, 0xdf, 0x26, 0xa8, 0xc0, 0xa1,
+    0x57, 0xdc, 0xd7, 0x5d, 0xe0, 0x78, 0x52, 0x4f, 0x16, 0xe9, 0x61, 0xfe, 0xef, 0xda, 0x16,
+    0xba, 0x69, 0x44, 0x97, 0xae, 0x86, 0xff, 0x00, 0x8b, 0x3e, 0x1e, 0x45, 0xa5, 0xdf, 0x69,
+    0x96, 0xfa, 0x5f, 0x98, 0xe6, 0xef, 0x28, 0x44, 0x87, 0x3f, 0x37, 0x1f, 0xa7, 0x35, 0xab,
+    0x77, 0xf0, 0xc9, 0xb4, 0x7d, 0x1a, 0x4b, 0x88, 0xaf, 0x16, 0x6b, 0xa4, 0x4d, 0xf2, 0x21,
+    0x4c, 0x02, 0x07, 0x5c, 0x1f, 0x6a, 0xf4, 0x7f, 0x17, 0x69, 0xf2, 0x36, 0x9d, 0x6f, 0xa9,
+    0x42, 0x3f, 0x7f, 0x66, 0xfe, 0x74, 0x67, 0xdb, 0x38, 0x61, 0xfd, 0x6b, 0x8d, 0xd6, 0x7c,
+    0x6e, 0xf7, 0x9a, 0x7c, 0x96, 0xf1, 0xd9, 0x79, 0x53, 0x48, 0xa5, 0x1d, 0xcb, 0x64, 0x28,
+    0xef, 0x81, 0x5b, 0xd3, 0x6e, 0x49, 0x38, 0x9a, 0xd6, 0xa7, 0x4a, 0x1c, 0xca, 0x7f, 0x2f,
+    0xeb, 0xd4, 0xf2, 0xfb, 0x85, 0xf2, 0xe3, 0x3e, 0xaf, 0xfc, 0xab, 0x2a, 0x4f, 0x97, 0x26,
+    0xb5, 0xef, 0xb9, 0x90, 0xfa, 0x0e, 0x95, 0x8f, 0x72, 0x79, 0xc5, 0x69, 0x37, 0x63, 0x8a,
+    0x8e, 0xc3, 0x23, 0x61, 0x8c, 0x1e, 0xb5, 0x4e, 0x75, 0x0b, 0x29, 0x27, 0xa6, 0x6a, 0xc8,
+    0x01, 0x50, 0xbb, 0x74, 0xaa, 0x32, 0x39, 0x92, 0x4c, 0xf6, 0xed, 0x5c, 0xd5, 0x1e, 0x89,
+    0x1b, 0xa2, 0x78, 0x49, 0x79, 0x85, 0x68, 0x6d, 0xc0, 0xaa, 0x56, 0x2a, 0x4b, 0x96, 0xf4,
+    0x15, 0x78, 0x1c, 0x9a, 0xd2, 0x92, 0xf7, 0x6e, 0x4c, 0x89, 0x61, 0x5f, 0x90, 0xfd, 0x6a,
+    0x9e, 0xa5, 0x27, 0x97, 0x0b, 0x7a, 0xe3, 0x15, 0xa1, 0x18, 0xc4, 0x79, 0xac, 0x4d, 0x62,
+    0x5c, 0xc8, 0xb1, 0x83, 0xee, 0x69, 0xd6, 0x7c, 0xb0, 0x64, 0xc3, 0x59, 0x19, 0x74, 0xaa,
+    0x69, 0x29, 0xe8, 0x8c, 0xe7, 0x8f, 0xce, 0xbc, 0xe4, 0x6e, 0x59, 0x81, 0xb9, 0x15, 0xd2,
+    0x69, 0x0c, 0xeb, 0x22, 0xb8, 0xcf, 0x07, 0x3c, 0x56, 0x25, 0xa5, 0xa9, 0xc8, 0x27, 0xa7,
+    0xa9, 0xae, 0x9a, 0xc0, 0x60, 0x00, 0x38, 0x02, 0xbb, 0xa8, 0x45, 0xa5, 0x76, 0x61, 0x55,
+    0xe9, 0x63, 0xdb, 0x7e, 0x1f, 0x6a, 0x42, 0x4b, 0x79, 0x2d, 0x58, 0xf3, 0x81, 0x22, 0x8f,
+    0xd0, 0xff, 0x00, 0x4a, 0xf4, 0x3b, 0x76, 0x0b, 0x04, 0xc9, 0xfd, 0xef, 0x98, 0x57, 0x84,
+    0x78, 0x67, 0x51, 0x6d, 0x3e, 0xf6, 0x19, 0x97, 0xa2, 0x37, 0x23, 0xd4, 0x1e, 0xa3, 0xf2,
+    0xaf, 0x6c, 0xb5, 0x9d, 0x66, 0x81, 0x25, 0x8d, 0x83, 0x2b, 0x28, 0x20, 0xfa, 0x8a, 0xc3,
+    0x13, 0x0b, 0x4a, 0xfd, 0xcf, 0x46, 0x8c, 0xbd, 0xa5, 0x3b, 0x76, 0x2f, 0x58, 0x9c, 0x4e,
+    0x47, 0xa8, 0xaf, 0x12, 0xf1, 0xf4, 0x1e, 0x5e, 0xb9, 0x76, 0x31, 0xd2, 0x56, 0xaf, 0x6a,
+    0xb4, 0x6c, 0x5c, 0x2f, 0xbf, 0x15, 0xe5, 0x1f, 0x12, 0xed, 0x9a, 0x2d, 0x72, 0x76, 0xed,
+    0x26, 0x1c, 0x7e, 0x5f, 0xfd, 0x6a, 0x30, 0xcf, 0xde, 0x33, 0xae, 0xb4, 0x67, 0x90, 0x5f,
+    0x96, 0x04, 0xe0, 0x11, 0x58, 0xd2, 0x4a, 0xc0, 0x9c, 0x90, 0x6b, 0xa0, 0xd4, 0x10, 0x31,
+    0x60, 0x6b, 0x9d, 0xb8, 0x4d, 0x8e, 0x46, 0x6b, 0xaa, 0xa5, 0xd2, 0x38, 0x29, 0x5b, 0x52,
+    0x26, 0x91, 0x8d, 0x44, 0x69, 0x24, 0x91, 0x50, 0x72, 0x6a, 0xac, 0x93, 0xb3, 0xf0, 0x38,
+    0x15, 0xcb, 0x29, 0xdb, 0x73, 0x74, 0x89, 0x9e, 0x65, 0x5e, 0x07, 0x26, 0xab, 0xb3, 0xb3,
+    0x1e, 0x4d, 0x32, 0x96, 0xb1, 0x72, 0x6c, 0xab, 0x16, 0xa2, 0xbe, 0x9a, 0x18, 0x7c, 0xa5,
+    0xc6, 0x3b, 0x13, 0xda, 0xaa, 0x93, 0x9a, 0x29, 0x28, 0x72, 0x6c, 0x49, 0x24, 0x06, 0x92,
+    0x8a, 0x2a, 0x46, 0x19, 0xe2, 0xad, 0xc0, 0x72, 0x95, 0x52, 0xac, 0x5b, 0x9e, 0x08, 0xaa,
+    0x86, 0xe2, 0x63, 0x27, 0x18, 0x90, 0xfb, 0xd2, 0xc7, 0xf3, 0x44, 0xc2, 0x9f, 0x70, 0x3e,
+    0xe9, 0xa8, 0xe1, 0x3c, 0x91, 0x4d, 0xe9, 0x20, 0x25, 0xd3, 0xd4, 0x3d, 0xd0, 0x56, 0xe8,
+    0x45, 0x6d, 0xb7, 0x03, 0x02, 0xb0, 0x6d, 0x9b, 0xca, 0xbd, 0x43, 0xe8, 0xd8, 0xad, 0xd7,
+    0x6e, 0x70, 0x2b, 0x7a, 0x3f, 0x09, 0x95, 0x45, 0xa9, 0x19, 0x5e, 0x73, 0xde, 0x94, 0x2f,
+    0x61, 0xde, 0x97, 0x18, 0xa1, 0x66, 0x58, 0x65, 0x56, 0x6e, 0x79, 0xe9, 0x5a, 0x3d, 0x04,
+    0xb5, 0x25, 0x7b, 0x29, 0x52, 0x3f, 0x35, 0xd0, 0x85, 0xf5, 0xc5, 0x54, 0x5b, 0x85, 0xde,
+    0x40, 0x07, 0xeb, 0x5d, 0xbd, 0xe6, 0xbf, 0xa6, 0x5c, 0x78, 0x71, 0x6d, 0x92, 0x25, 0xf3,
+    0x80, 0xe5, 0xab, 0x84, 0x7d, 0xa1, 0x8e, 0x3a, 0x54, 0x29, 0x36, 0x6b, 0x28, 0x24, 0x4b,
+    0xe7, 0x03, 0x91, 0xcd, 0x41, 0x3d, 0xc2, 0xc6, 0xa7, 0xd6, 0xa0, 0x9a, 0xe5, 0x50, 0x61,
+    0x79, 0x35, 0x49, 0xdd, 0x9c, 0xe5, 0x8e, 0x6a, 0x27, 0x52, 0xda, 0x21, 0x28, 0x20, 0x91,
+    0xcc, 0x8c, 0x58, 0x9a, 0x6d, 0x14, 0x57, 0x39, 0x61, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14,
+    0x50, 0x02, 0x81, 0x93, 0x52, 0x01, 0x81, 0x48, 0xab, 0xb7, 0xeb, 0x4e, 0xaa, 0x48, 0x04,
+    0xa4, 0x34, 0xb4, 0x86, 0x80, 0x12, 0x90, 0x9a, 0x09, 0xa6, 0xd2, 0x60, 0x75, 0xba, 0xc6,
+    0x8c, 0x18, 0x19, 0xed, 0x57, 0x0f, 0xd5, 0x90, 0x77, 0xfa, 0x54, 0x3a, 0x3d, 0xf1, 0xb5,
+    0x28, 0xb7, 0x07, 0x30, 0x31, 0xdb, 0xbb, 0xfb, 0x87, 0xdf, 0xda, 0xba, 0x20, 0x0c, 0x8f,
+    0x59, 0xda, 0xb6, 0x95, 0xe5, 0x06, 0xbc, 0x81, 0x37, 0x21, 0x1f, 0xbe, 0x8c, 0x0e, 0xa3,
+    0xd4, 0x57, 0xa1, 0x28, 0x59, 0xf3, 0x23, 0x92, 0x12, 0xe6, 0x5c, 0xb2, 0x37, 0xd1, 0x57,
+    0x68, 0x23, 0x90, 0x7a, 0x56, 0x77, 0x88, 0x07, 0xfc, 0x48, 0xee, 0xbf, 0xdd, 0x1f, 0xcc,
+    0x55, 0x1d, 0x17, 0x52, 0xfb, 0x3b, 0xad, 0x94, 0xcf, 0xba, 0x37, 0x19, 0x82, 0x43, 0xff,
+    0x00, 0xa0, 0xd5, 0xad, 0x6d, 0x8c, 0xba, 0x5d, 0xca, 0x0f, 0xee, 0x53, 0x7a, 0xa6, 0x1f,
+    0x0c, 0x92, 0x39, 0xed, 0x1c, 0x62, 0xfa, 0xcc, 0x0e, 0xf0, 0xb5, 0x75, 0x91, 0x5a, 0x96,
+    0xeb, 0x5c, 0xa6, 0x8e, 0x40, 0xd5, 0x34, 0xbc, 0xf4, 0x65, 0x2b, 0xfa, 0x57, 0x7c, 0xaa,
+    0x14, 0x71, 0x53, 0x49, 0xfb, 0xa3, 0xa9, 0x1b, 0xc8, 0xa8, 0xb6, 0x60, 0x76, 0xa4, 0x7b,
+    0x60, 0x3b, 0x55, 0xe3, 0x59, 0x3a, 0xd6, 0xac, 0x9a, 0x64, 0x03, 0x68, 0xdf, 0x3b, 0xf1,
+    0x1a, 0x7a, 0x9a, 0xd1, 0xca, 0xda, 0xb2, 0x79, 0x16, 0xc8, 0xaf, 0x77, 0x75, 0x0d, 0x92,
+    0xe6, 0x67, 0x03, 0xd0, 0x77, 0x35, 0xcc, 0xe8, 0xea, 0x2e, 0x2e, 0x2e, 0x00, 0x1c, 0x33,
+    0x13, 0xfa, 0xd5, 0xcb, 0x6b, 0x5b, 0x8b, 0x99, 0x1a, 0x79, 0xc1, 0x96, 0xe1, 0xfd, 0x7a,
+    0x2d, 0x47, 0xe1, 0xf4, 0x2b, 0xa8, 0x5c, 0xa1, 0x00, 0x15, 0x62, 0x0e, 0x3e, 0xb5, 0x0d,
+    0xb7, 0x28, 0xb6, 0x5a, 0x4a, 0x11, 0x76, 0xdc, 0xd0, 0xf0, 0xf0, 0xc5, 0x84, 0x8b, 0xe9,
+    0x33, 0x0a, 0xd7, 0xc5, 0x51, 0xf0, 0xd4, 0x06, 0x5b, 0x3b, 0x83, 0xe9, 0x33, 0x56, 0xb3,
+    0xdb, 0x95, 0xaa, 0x83, 0xf7, 0x51, 0x94, 0xe2, 0xf9, 0x9b, 0x20, 0xc5, 0x18, 0xa7, 0xec,
+    0xc7, 0x5a, 0x40, 0x2a, 0xc8, 0xb0, 0xdc, 0x52, 0xe2, 0x9d, 0x8a, 0x36, 0xd0, 0x21, 0x31,
+    0x4e, 0x00, 0x62, 0x80, 0xbc, 0xd3, 0xd6, 0x98, 0xd1, 0x73, 0x4c, 0xd3, 0x64, 0xd4, 0x27,
+    0xf2, 0xd3, 0x8f, 0x5a, 0xd5, 0xd4, 0x7c, 0x33, 0x2d, 0x94, 0x1e, 0x66, 0x4f, 0xae, 0x0d,
+    0x57, 0xd0, 0xb5, 0x05, 0xb0, 0xba, 0xdc, 0xf8, 0xc1, 0xad, 0xbd, 0x67, 0xc4, 0x51, 0xdd,
+    0xdb, 0xed, 0x04, 0x13, 0x8e, 0x00, 0xa8, 0x6e, 0x57, 0xd0, 0xe9, 0x84, 0x69, 0xb8, 0x5d,
+    0xee, 0x71, 0xa5, 0x48, 0xa3, 0x24, 0x8a, 0x79, 0x39, 0x24, 0xd3, 0x71, 0x5a, 0x1c, 0xc3,
+    0x36, 0xd2, 0x85, 0xa7, 0x62, 0x97, 0x14, 0xc0, 0x14, 0x73, 0x45, 0xc5, 0xc4, 0x56, 0xb6,
+    0xef, 0x34, 0xce, 0x12, 0x34, 0x19, 0x24, 0xd5, 0x1d, 0x4b, 0x57, 0xb6, 0xd2, 0xe3, 0xcc,
+    0xa7, 0x74, 0x87, 0xee, 0xc6, 0xbd, 0x4d, 0x63, 0xc7, 0xa6, 0x6a, 0xfe, 0x28, 0x95, 0x65,
+    0xbb, 0xcd, 0xad, 0x90, 0x39, 0x55, 0xf5, 0xfc, 0x3b, 0xfd, 0x6b, 0x39, 0x4e, 0xda, 0x2d,
+    0x59, 0xa4, 0x21, 0x7d, 0x5e, 0xc6, 0x26, 0xa5, 0xa8, 0xdd, 0x6b, 0xda, 0x82, 0xac, 0x31,
+    0x3b, 0x20, 0x38, 0x8a, 0x25, 0x19, 0xfc, 0xeb, 0xa2, 0xb2, 0xb3, 0xfe, 0xc1, 0xb6, 0x17,
+    0x5a, 0x94, 0xde, 0x6d, 0xd0, 0x1f, 0xba, 0x83, 0x77, 0xcb, 0x1f, 0xff, 0x00, 0x5e, 0xba,
+    0x0b, 0x7d, 0x32, 0xcf, 0x45, 0xb3, 0x2b, 0x6a, 0x8a, 0x8d, 0x8f, 0x9e, 0x56, 0xfb, 0xdf,
+    0x9d, 0x71, 0x1a, 0xc5, 0xea, 0xdd, 0x5d, 0xb0, 0x89, 0x89, 0x8c, 0x71, 0xb8, 0xff, 0x00,
+    0x11, 0xf5, 0xac, 0x54, 0x79, 0x3d, 0xf9, 0x3b, 0xb3, 0x5b, 0xf3, 0x3e, 0x55, 0xb1, 0x5a,
+    0xfa, 0xf6, 0x5b, 0xfb, 0x97, 0x9a, 0x56, 0xc9, 0x26, 0xab, 0x51, 0x5a, 0x1a, 0x7e, 0x96,
+    0xd7, 0x9f, 0xbc, 0x90, 0x94, 0xb7, 0x1d, 0x4f, 0x76, 0xf6, 0x15, 0x92, 0x4e, 0x6c, 0xd1,
+    0xb5, 0x15, 0xa9, 0x05, 0x9d, 0x93, 0x5d, 0xb6, 0xf6, 0xf9, 0x60, 0x5e, 0xa7, 0xfb, 0xd5,
+    0x6d, 0xd9, 0x46, 0x71, 0xc2, 0x8a, 0x9e, 0xee, 0xe1, 0x23, 0x5f, 0xb3, 0xdb, 0x80, 0x14,
+    0x71, 0xc7, 0x6f, 0x6a, 0xc8, 0xbb, 0x9f, 0x6a, 0xf9, 0x60, 0xfd, 0x6b, 0x57, 0xcb, 0x4d,
+    0x58, 0x51, 0x6e, 0x5a, 0x95, 0xae, 0xe6, 0x32, 0xc8, 0x71, 0xdf, 0x81, 0x53, 0xaa, 0x08,
+    0xa3, 0x09, 0xdc, 0x72, 0x7e, 0xb5, 0x05, 0xac, 0x65, 0xdc, 0xcc, 0xdf, 0x75, 0x7a, 0x7b,
+    0x9a, 0x9d, 0xb9, 0x38, 0xae, 0x78, 0xeb, 0xef, 0x32, 0xc7, 0xc4, 0xbb, 0x98, 0x0f, 0x53,
+    0x57, 0x1d, 0x82, 0x46, 0xcc, 0x7a, 0x01, 0x50, 0x5b, 0x2f, 0xcd, 0x9f, 0x4a, 0x4b, 0xf9,
+    0x36, 0x5a, 0xb0, 0xee, 0xdc, 0x56, 0xcb, 0x48, 0xdc, 0x46, 0x7c, 0x04, 0xee, 0x66, 0x3d,
+    0xea, 0x61, 0xe9, 0x4c, 0x8d, 0x76, 0xaa, 0xd4, 0xd8, 0xe0, 0x35, 0x63, 0x15, 0xa0, 0xca,
+    0xac, 0x3c, 0x99, 0x73, 0xfc, 0x2d, 0x4e, 0x96, 0x3c, 0xfc, 0xcb, 0xd7, 0xaf, 0x15, 0x3c,
+    0xb1, 0x87, 0x5f, 0x63, 0x50, 0x44, 0xc5, 0x1b, 0xcb, 0x7f, 0xc0, 0xd4, 0xb5, 0x6d, 0x06,
+    0x4d, 0x6f, 0x70, 0x1f, 0xf7, 0x72, 0xfd, 0xef, 0xe7, 0x52, 0x94, 0x31, 0x9e, 0x39, 0x5a,
+    0x81, 0xed, 0xc4, 0x8b, 0xb9, 0x0e, 0x18, 0x76, 0xa5, 0x86, 0xe0, 0xa9, 0xf2, 0xe5, 0x1f,
+    0x9d, 0x5a, 0x76, 0xd1, 0x88, 0xb5, 0x1c, 0xa5, 0x7a, 0x74, 0xa9, 0x41, 0x57, 0xe8, 0x70,
+    0x6a, 0x0d, 0x80, 0xfc, 0xca, 0x78, 0x34, 0x9c, 0xad, 0x68, 0x9d, 0x84, 0x5a, 0xde, 0x57,
+    0x86, 0x1f, 0x8d, 0x38, 0x38, 0x35, 0x5d, 0x65, 0x38, 0xc1, 0xe4, 0x7a, 0x1a, 0x5e, 0x0f,
+    0x4e, 0x3d, 0x8d, 0x57, 0x30, 0x16, 0x83, 0x7a, 0x53, 0xc4, 0x8c, 0x2a, 0x90, 0x2c, 0x0f,
+    0x0d, 0x8a, 0x70, 0x95, 0xc7, 0x5c, 0x1a, 0xa5, 0x3b, 0x0a, 0xc5, 0xe1, 0x3f, 0xa8, 0xa7,
+    0x0b, 0x91, 0xef, 0x54, 0x3c, 0xff, 0x00, 0x50, 0x69, 0x3c, 0xe5, 0xf7, 0xaa, 0xf6, 0xa2,
+    0xe5, 0x46, 0x89, 0xba, 0x5c, 0x75, 0xfd, 0x2a, 0x27, 0xba, 0x03, 0xb6, 0x6a, 0x9f, 0x9c,
+    0x3d, 0x29, 0x77, 0x86, 0x38, 0xe9, 0x49, 0xd5, 0x61, 0xca, 0x89, 0x0c, 0xec, 0xfd, 0x05,
+    0x31, 0xe5, 0x54, 0x04, 0xbb, 0x01, 0xf8, 0xd5, 0x4b, 0x9b, 0xbd, 0x99, 0x8e, 0x1f, 0xbd,
+    0xdc, 0xfa, 0x55, 0x40, 0x8d, 0x21, 0xcb, 0x92, 0xc6, 0xb1, 0x95, 0x57, 0x7b, 0x22, 0x92,
+    0x2e, 0xbd, 0xfc, 0x4b, 0xf7, 0x41, 0x6a, 0x67, 0xdb, 0x9d, 0xbe, 0xec, 0x47, 0xf1, 0xa6,
+    0x24, 0x6a, 0x07, 0xcd, 0x85, 0x15, 0x20, 0x30, 0x0f, 0xe3, 0x07, 0xf1, 0xa8, 0xe6, 0x93,
+    0xea, 0x30, 0x8a, 0x7b, 0x99, 0xe7, 0x10, 0xc5, 0x0e, 0x64, 0x6e, 0x8a, 0x3a, 0x9a, 0xba,
+    0x2c, 0x35, 0x91, 0xff, 0x00, 0x30, 0xd9, 0xcf, 0xd1, 0x73, 0x54, 0x65, 0x36, 0xee, 0x07,
+    0xef, 0x02, 0xb0, 0xe8, 0x47, 0x6a, 0xb5, 0x6b, 0xe2, 0x2d, 0x56, 0xcd, 0x95, 0x20, 0xbb,
+    0x32, 0xe3, 0x85, 0x0c, 0xbb, 0xbf, 0x9d, 0x54, 0x5a, 0x5f, 0x13, 0x7f, 0x21, 0x3b, 0xf4,
+    0x1c, 0x9a, 0x8d, 0xee, 0x9b, 0x30, 0x2c, 0xb7, 0x16, 0xce, 0x3d, 0x8a, 0xd7, 0x49, 0x6b,
+    0xe2, 0x3b, 0x0d, 0x6a, 0xdf, 0xec, 0x5a, 0xd4, 0x49, 0x20, 0x3c, 0x09, 0x47, 0x0c, 0xbe,
+    0xf5, 0xd3, 0xe8, 0xe6, 0xe7, 0x50, 0xd1, 0xe3, 0x6d, 0x5a, 0xda, 0x3f, 0x35, 0xf2, 0x4a,
+    0x15, 0xe3, 0x1d, 0xb8, 0xac, 0xfd, 0x53, 0xc1, 0x1a, 0x5d, 0xf2, 0x97, 0xb7, 0x4f, 0xb2,
+    0x4d, 0xd9, 0xa3, 0xe9, 0xf8, 0x8a, 0xe9, 0x51, 0x9a, 0x5a, 0x3b, 0xfa, 0x99, 0xdd, 0x32,
+    0xa5, 0xa4, 0xb7, 0x3e, 0x1a, 0x91, 0x11, 0xe7, 0x37, 0x9a, 0x3c, 0x9f, 0x72, 0x50, 0x72,
+    0xd0, 0xfa, 0x67, 0xda, 0xba, 0xe4, 0x64, 0x74, 0x57, 0x46, 0x0c, 0xac, 0x32, 0x08, 0xe8,
+    0x45, 0x79, 0x95, 0xdd, 0xae, 0xb5, 0xe1, 0xd5, 0x68, 0xae, 0x41, 0x96, 0xd1, 0xb8, 0xf3,
+    0x17, 0xe6, 0x5f, 0xc7, 0xd2, 0xba, 0x0f, 0x03, 0xeb, 0x1f, 0x6a, 0x86, 0x6d, 0x3e, 0x43,
+    0xf3, 0x43, 0xf3, 0x47, 0x93, 0xfc, 0x27, 0xb7, 0xe1, 0xfd, 0x6a, 0xa1, 0x35, 0x7e, 0x50,
+    0xb3, 0xdc, 0xec, 0x41, 0xa5, 0xa4, 0x0a, 0x7b, 0x0a, 0x36, 0xb0, 0xe4, 0x8a, 0xd4, 0x61,
+    0x4f, 0x89, 0x32, 0x73, 0x4d, 0x54, 0x24, 0xfb, 0x54, 0xeb, 0xc5, 0x26, 0xc6, 0x89, 0xc0,
+    0x0a, 0xbc, 0x54, 0x4c, 0x09, 0x34, 0xe5, 0x6c, 0xf0, 0x68, 0x6c, 0x2d, 0x49, 0x64, 0x64,
+    0x73, 0xcd, 0x37, 0x14, 0xe6, 0x6c, 0x9a, 0x61, 0x38, 0xa7, 0x72, 0x4b, 0xf6, 0x3a, 0x93,
+    0xd9, 0x37, 0xca, 0x69, 0x2f, 0xf5, 0x29, 0x2f, 0x0e, 0x5c, 0x9a, 0xcf, 0x27, 0xbd, 0x0e,
+    0xef, 0x2b, 0x6e, 0x73, 0x93, 0x8c, 0x54, 0xd9, 0x5e, 0xe5, 0x73, 0x3b, 0x58, 0x42, 0x7f,
+    0x3a, 0x88, 0xee, 0xa9, 0x3b, 0xd1, 0x4e, 0xe4, 0x11, 0x84, 0x3d, 0xe9, 0xdb, 0x40, 0xe9,
+    0x4b, 0x9a, 0x6e, 0x68, 0xb8, 0x58, 0x6b, 0x9c, 0x71, 0xde, 0xa3, 0xeb, 0x52, 0xe0, 0x7a,
+    0x52, 0x6d, 0x02, 0x8b, 0x80, 0xc0, 0x80, 0x73, 0xde, 0x90, 0xa8, 0xa7, 0x9a, 0x69, 0xa5,
+    0x70, 0x23, 0x22, 0x9b, 0x52, 0x1a, 0x8d, 0xc8, 0x55, 0x2c, 0x4e, 0x00, 0x19, 0x34, 0x5c,
+    0x0c, 0x7f, 0x10, 0xea, 0xab, 0xa5, 0x69, 0xcc, 0xeb, 0x83, 0x71, 0x27, 0xcb, 0x12, 0xfb,
+    0xfa, 0xd6, 0x26, 0x85, 0x60, 0x6d, 0xad, 0x7c, 0xe9, 0x72, 0x66, 0x97, 0xe6, 0x62, 0x7a,
+    0xd5, 0x39, 0x4c, 0x9a, 0xef, 0x89, 0x64, 0x92, 0x43, 0x9b, 0x6b, 0x73, 0x84, 0x5e, 0xd5,
+    0xd2, 0x22, 0x80, 0x2a, 0x63, 0xab, 0xb9, 0x94, 0xdf, 0x42, 0xb5, 0xec, 0xff, 0x00, 0x65,
+    0xb5, 0x79, 0x3a, 0xb0, 0x1c, 0x7d, 0x6b, 0x89, 0xbf, 0xb9, 0x20, 0x1e, 0x49, 0x77, 0x3c,
+    0x9a, 0xe9, 0x75, 0xbb, 0xa5, 0x58, 0xcc, 0x40, 0xf2, 0x6b, 0x8a, 0x9d, 0xcc, 0xb3, 0x93,
+    0xd8, 0x70, 0x2b, 0x2c, 0x44, 0xec, 0xac, 0x8b, 0xa2, 0xba, 0x8d, 0x41, 0xce, 0x6a, 0xd2,
+    0x83, 0x1a, 0x8c, 0x70, 0xcd, 0x4d, 0xb7, 0x8b, 0x7c, 0x81, 0x7b, 0x77, 0xa9, 0xdb, 0x1f,
+    0x6a, 0x00, 0xf4, 0xce, 0x2b, 0x9e, 0x2b, 0x4b, 0x9a, 0xb3, 0x56, 0xca, 0x11, 0x05, 0xaa,
+    0xe7, 0xef, 0x3f, 0x26, 0xa6, 0x6f, 0x4c, 0xd2, 0x4c, 0xfb, 0x64, 0x0a, 0x07, 0x00, 0x53,
+    0x15, 0x8b, 0x38, 0x1e, 0xf5, 0xde, 0x95, 0x95, 0x91, 0xcf, 0x66, 0xf5, 0x19, 0x7e, 0xdb,
+    0x6d, 0xf1, 0xea, 0x6a, 0xa4, 0x31, 0x6e, 0xd2, 0xa4, 0x7e, 0xe5, 0xf3, 0xfe, 0x7f, 0x3a,
+    0x97, 0x54, 0x6c, 0x46, 0x83, 0xeb, 0x56, 0xad, 0xe1, 0xc6, 0x8a, 0x83, 0x1f, 0x78, 0x13,
+    0x59, 0xb5, 0xcd, 0x36, 0xbc, 0x8a, 0xbd, 0xa2, 0xbd, 0x4a, 0x3a, 0x49, 0xff, 0x00, 0x47,
+    0x75, 0xf4, 0x72, 0x6b, 0x2f, 0x52, 0x39, 0xbf, 0x97, 0xd8, 0xe2, 0xb4, 0x74, 0xb3, 0x89,
+    0x66, 0x4f, 0xa1, 0xac, 0x9b, 0xa6, 0xdd, 0x75, 0x29, 0xff, 0x00, 0x68, 0xd7, 0x3d, 0x57,
+    0xfb, 0xa4, 0x8d, 0x22, 0xbd, 0xe6, 0x43, 0x52, 0x46, 0xb9, 0x34, 0xd0, 0x2a, 0xd3, 0xc2,
+    0x21, 0x88, 0x1c, 0xfc, 0xcd, 0xc5, 0x61, 0x18, 0xf5, 0x2c, 0x92, 0x1e, 0x5f, 0xe9, 0x5d,
+    0x4f, 0x87, 0x77, 0xc5, 0x79, 0x14, 0xf1, 0x9c, 0x3c, 0x6e, 0x19, 0x4f, 0xb8, 0x39, 0xae,
+    0x52, 0xdc, 0xf2, 0x2b, 0xb6, 0xf0, 0xe4, 0x5f, 0xbb, 0xde, 0x7f, 0x0a, 0xed, 0xc3, 0xea,
+    0x65, 0x57, 0x63, 0xe9, 0x9b, 0x61, 0x1e, 0xa7, 0xa1, 0x6e, 0xc0, 0x75, 0x65, 0xde, 0x07,
+    0xaa, 0xb0, 0xe9, 0xfc, 0xeb, 0xc6, 0xfc, 0x63, 0xa3, 0xae, 0x9b, 0xaa, 0x49, 0xe5, 0xa9,
+    0x11, 0x48, 0x37, 0x2f, 0xb7, 0xaf, 0xf9, 0xf7, 0xaf, 0x51, 0xf0, 0x05, 0xe8, 0x9f, 0x45,
+    0x81, 0x09, 0xe5, 0x41, 0x8c, 0xfd, 0x57, 0xa7, 0xe8, 0x6b, 0x2b, 0xe2, 0x16, 0x8c, 0x66,
+    0xd3, 0xda, 0x64, 0x5c, 0xb4, 0x07, 0x70, 0xf7, 0x43, 0xfe, 0x15, 0x9d, 0x19, 0x72, 0x55,
+    0x71, 0x67, 0x65, 0x58, 0xfb, 0x48, 0x35, 0xf3, 0x5f, 0xa9, 0xe1, 0x17, 0xd1, 0x85, 0x05,
+    0xbb, 0x56, 0x0b, 0x2e, 0xf9, 0x3e, 0xb5, 0xd4, 0xea, 0x91, 0x10, 0x84, 0x0a, 0xe6, 0x0c,
+    0x88, 0x27, 0x78, 0xf3, 0xc8, 0x15, 0xd7, 0x52, 0xdd, 0x4f, 0x3e, 0x96, 0x97, 0x45, 0x2b,
+    0xc7, 0xc1, 0x58, 0xc7, 0xd4, 0xd5, 0x5a, 0x7c, 0xcf, 0xbe, 0x46, 0x73, 0xde, 0xa1, 0x8d,
+    0xc3, 0x48, 0x41, 0xe9, 0x5c, 0x13, 0x95, 0xe4, 0x74, 0x23, 0x42, 0x39, 0x3c, 0x8b, 0x70,
+    0x07, 0xdf, 0x7e, 0x4f, 0xb0, 0xa7, 0x82, 0x7a, 0xf7, 0xaa, 0xb9, 0x2e, 0xf5, 0x6d, 0x57,
+    0x73, 0x01, 0x5a, 0xc5, 0xdf, 0x44, 0x22, 0xec, 0x4d, 0x98, 0xb2, 0x6b, 0x9b, 0xbb, 0x97,
+    0xce, 0xb9, 0x77, 0xed, 0x9e, 0x2b, 0x6a, 0xee, 0x71, 0x05, 0xa1, 0x55, 0xfb, 0xcd, 0xf2,
+    0xa8, 0xac, 0xa8, 0x6d, 0xf1, 0xf3, 0x37, 0x26, 0x95, 0x76, 0xe5, 0x68, 0xa1, 0x41, 0x5a,
+    0xec, 0x8a, 0x2b, 0x72, 0xdc, 0xb7, 0x03, 0xd2, 0xad, 0xc6, 0x81, 0x48, 0xe3, 0xf0, 0xa9,
+    0x12, 0x32, 0xc7, 0x0a, 0x2b, 0x46, 0xce, 0xcd, 0x77, 0xe5, 0x86, 0x4f, 0xbd, 0x2a, 0x74,
+    0x87, 0x29, 0x24, 0xae, 0xc7, 0xdb, 0x46, 0xac, 0x41, 0x27, 0xf0, 0xad, 0x7b, 0x75, 0xc6,
+    0x33, 0xc0, 0xa8, 0x15, 0x12, 0x21, 0xd8, 0x52, 0x1b, 0xa4, 0x4f, 0xe2, 0xae, 0xc5, 0xa1,
+    0xc7, 0x29, 0x39, 0x3d, 0x0e, 0x8e, 0xc6, 0x7d, 0x84, 0x7a, 0x57, 0xab, 0xf8, 0x23, 0x55,
+    0xf3, 0xa0, 0x36, 0x6e, 0xd9, 0xda, 0x37, 0x27, 0xd3, 0xb8, 0xaf, 0x0d, 0xb6, 0xbf, 0x05,
+    0x86, 0xdc, 0xd7, 0x6d, 0xe1, 0x3d, 0x60, 0xdb, 0x5f, 0x45, 0x26, 0x7e, 0xe3, 0x03, 0x8f,
+    0x51, 0xd0, 0x8a, 0xca, 0xb4, 0x39, 0xe3, 0x63, 0xb3, 0x0d, 0x57, 0x96, 0x56, 0x67, 0xb8,
+    0xc4, 0x42, 0xcc, 0x87, 0xdc, 0x57, 0x01, 0xf1, 0x4e, 0xdf, 0x17, 0x51, 0xcf, 0xd9, 0xa3,
+    0xc7, 0xe5, 0xff, 0x00, 0xeb, 0xae, 0xe6, 0x29, 0x15, 0xd1, 0x59, 0x48, 0x20, 0x8c, 0x82,
+    0x0d, 0x72, 0xbf, 0x11, 0xa2, 0x17, 0x3a, 0x5a, 0x4c, 0x3a, 0x82, 0x57, 0xf3, 0x1f, 0xfd,
+    0x6a, 0xe1, 0xa2, 0xed, 0x34, 0x77, 0x55, 0x8b, 0x69, 0xfa, 0x1e, 0x05, 0xa9, 0xcd, 0xb0,
+    0xb1, 0xc0, 0xc7, 0xad, 0x72, 0xb7, 0x97, 0x45, 0x98, 0xed, 0x1f, 0x8d, 0x74, 0x1a, 0xb2,
+    0x3b, 0xc8, 0x78, 0x27, 0xda, 0xb9, 0xe9, 0x6d, 0x64, 0x62, 0x78, 0xc7, 0xd6, 0xba, 0xeb,
+    0x73, 0x6c, 0x8f, 0x36, 0x92, 0x56, 0xb9, 0x41, 0x89, 0x27, 0x24, 0xe6, 0x92, 0xae, 0x8b,
+    0x1c, 0xfd, 0xe6, 0xfc, 0xa9, 0x5a, 0xc7, 0xfb, 0xa7, 0x1f, 0x5a, 0xe4, 0xf6, 0x72, 0x36,
+    0xb9, 0x4b, 0x14, 0x62, 0xae, 0x7d, 0x89, 0xfb, 0x91, 0x41, 0xb4, 0x70, 0x3b, 0x1a, 0x3d,
+    0x9b, 0x0b, 0x94, 0xf1, 0x49, 0x53, 0xb4, 0x45, 0x4f, 0x23, 0x9a, 0x88, 0x8a, 0x97, 0x11,
+    0x8d, 0xa2, 0x97, 0x14, 0x62, 0xa4, 0x06, 0xe2, 0xa6, 0xb7, 0x3f, 0x36, 0x29, 0x94, 0xf4,
+    0x1b, 0x5d, 0x4f, 0xad, 0x54, 0x77, 0x02, 0x59, 0x86, 0x63, 0xaa, 0xf1, 0x9c, 0x48, 0x2a,
+    0xe3, 0x0c, 0xa9, 0x15, 0x44, 0xf0, 0x7e, 0x95, 0x53, 0xde, 0xe2, 0x43, 0xe4, 0xf9, 0x64,
+    0x0c, 0x3e, 0xb5, 0xbd, 0x17, 0xcf, 0x1a, 0xbf, 0xa8, 0xcd, 0x61, 0xcc, 0x32, 0xa0, 0xd6,
+    0x9d, 0x95, 0xd2, 0xad, 0x80, 0x07, 0xef, 0x29, 0xc6, 0x2b, 0x4a, 0x4e, 0xd2, 0x68, 0x89,
+    0xa6, 0xd6, 0x84, 0xf3, 0x49, 0xe5, 0x8f, 0x53, 0xd8, 0x56, 0x74, 0xf3, 0xed, 0xc9, 0x27,
+    0x2c, 0x69, 0x27, 0xba, 0xf9, 0x8e, 0x39, 0x63, 0xde, 0xa9, 0xb1, 0x2c, 0x72, 0x4f, 0x34,
+    0xaa, 0x54, 0xec, 0x38, 0xc6, 0xc5, 0x98, 0xaf, 0x0a, 0x29, 0x0f, 0x93, 0x93, 0x9a, 0x8e,
+    0x5b, 0xa6, 0x7e, 0x07, 0x02, 0xa0, 0xa2, 0xb2, 0xe7, 0x76, 0xb1, 0x56, 0x0a, 0x28, 0xa2,
+    0xa4, 0x61, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01, 0x4a, 0x0e, 0x0e, 0x69, 0x28,
+    0xa0, 0x07, 0xef, 0xf6, 0xa7, 0xd4, 0x39, 0xa5, 0xcd, 0x3b, 0x80, 0xf2, 0xc0, 0x53, 0x09,
+    0xcd, 0x14, 0x94, 0x5c, 0x02, 0x8a, 0x28, 0xa4, 0x07, 0xa8, 0x5b, 0xa7, 0x7a, 0xb4, 0x70,
+    0x06, 0x0f, 0x4a, 0xc1, 0xd0, 0xf5, 0xd8, 0xaf, 0x94, 0x41, 0x2e, 0x12, 0xe0, 0x7e, 0x4d,
+    0xf4, 0xad, 0xb6, 0x38, 0x15, 0xe9, 0xa9, 0x29, 0x6a, 0x8e, 0x3b, 0x72, 0xe8, 0xce, 0x4f,
+    0x54, 0xb1, 0x16, 0xb7, 0x26, 0x21, 0xc4, 0x12, 0x9d, 0xd1, 0x1f, 0xee, 0x37, 0xa5, 0x69,
+    0xe9, 0x92, 0x1d, 0x46, 0xc2, 0x58, 0x65, 0xff, 0x00, 0x5e, 0x8a, 0x51, 0xc7, 0xe1, 0xc1,
+    0xab, 0x37, 0xd6, 0x62, 0xfe, 0xd9, 0xe2, 0x3c, 0x13, 0xca, 0xb7, 0xa1, 0xec, 0x6b, 0x0f,
+    0x4e, 0xba, 0x7b, 0x4b, 0xc4, 0xb8, 0x71, 0xb4, 0xab, 0x79, 0x37, 0x0b, 0xfd, 0x6a, 0x76,
+    0x65, 0x2f, 0x7e, 0x3e, 0x86, 0x75, 0xab, 0x98, 0x3e, 0xc7, 0x31, 0xeb, 0x05, 0xc6, 0xd6,
+    0xf6, 0x19, 0xaf, 0x45, 0xde, 0x31, 0x9a, 0xe1, 0x2f, 0xad, 0xbc, 0xbd, 0x47, 0x50, 0xb4,
+    0x1d, 0x1f, 0xf7, 0xb1, 0xfe, 0x3c, 0xd7, 0x57, 0xa7, 0xdc, 0xfd, 0xab, 0x4d, 0xb7, 0x9b,
+    0x3f, 0x79, 0x06, 0x7e, 0xbd, 0xe9, 0x43, 0x4d, 0x0a, 0x9b, 0xea, 0x5a, 0xb8, 0xb9, 0x58,
+    0x21, 0x79, 0x18, 0xe1, 0x54, 0x12, 0x4d, 0x72, 0x4a, 0x92, 0x5f, 0xdf, 0x7d, 0xae, 0x61,
+    0x99, 0x64, 0x38, 0x89, 0x3f, 0xba, 0x2a, 0xdf, 0x89, 0x75, 0x05, 0x82, 0x38, 0x6d, 0xcf,
+    0x3b, 0xd8, 0x33, 0x81, 0xfd, 0xd1, 0x57, 0x7c, 0x3d, 0x02, 0xdc, 0x06, 0xbf, 0x65, 0x21,
+    0x4f, 0xcb, 0x10, 0x3e, 0x9d, 0xcf, 0xf9, 0xf4, 0xaa, 0xba, 0x6e, 0xc2, 0x8d, 0xed, 0x73,
+    0x4a, 0xce, 0xc4, 0x45, 0x18, 0x04, 0x73, 0xdc, 0xd7, 0x2b, 0xa3, 0x0f, 0xf8, 0x9e, 0x6a,
+    0x18, 0xe9, 0xbd, 0xbf, 0x99, 0xae, 0xe4, 0x10, 0x05, 0x70, 0xbe, 0x1f, 0x3b, 0xf5, 0x5b,
+    0xe6, 0xf5, 0x76, 0xfe, 0x66, 0x93, 0xf8, 0x90, 0xad, 0x68, 0xb3, 0x6f, 0xc2, 0x64, 0x7d,
+    0x8e, 0xe8, 0x1e, 0xd3, 0x9f, 0xe5, 0x5b, 0x52, 0xca, 0xb8, 0xc7, 0x5a, 0xe6, 0xbc, 0x36,
+    0xcc, 0x22, 0xbb, 0x51, 0xff, 0x00, 0x3d, 0xb3, 0xfa, 0x56, 0xfc, 0x70, 0xb3, 0xf2, 0x7a,
+    0x55, 0x47, 0x60, 0x93, 0x77, 0xb2, 0x22, 0x63, 0xbb, 0x80, 0x28, 0x08, 0x6a, 0xf2, 0x5b,
+    0x2f, 0x7a, 0xb0, 0xb0, 0x0c, 0x74, 0xc5, 0x55, 0xc9, 0x54, 0xdb, 0x32, 0x76, 0x73, 0x46,
+    0xd3, 0x5a, 0xe6, 0xd0, 0x37, 0x6a, 0x82, 0x5b, 0x32, 0xb9, 0x20, 0x51, 0x70, 0x74, 0xd9,
+    0x9f, 0x8a, 0x51, 0xed, 0x52, 0xb4, 0x64, 0x76, 0xa6, 0x63, 0x14, 0xc8, 0xb5, 0x82, 0x96,
+    0x92, 0x8a, 0x60, 0x2d, 0x14, 0x51, 0x40, 0x82, 0xb2, 0x2f, 0xf5, 0x59, 0x7e, 0xd2, 0x34,
+    0xfd, 0x36, 0x3f, 0x3e, 0xf1, 0xb8, 0x38, 0xe9, 0x1f, 0xb9, 0xa5, 0xbe, 0xbc, 0x9e, 0xea,
+    0xeb, 0xfb, 0x33, 0x4d, 0xe6, 0xe1, 0x87, 0xef, 0x24, 0xed, 0x10, 0xff, 0x00, 0x1a, 0xd6,
+    0xd3, 0xf4, 0xeb, 0x3d, 0x02, 0xcc, 0xe3, 0x2d, 0x23, 0x72, 0xf2, 0x11, 0x96, 0x73, 0x52,
+    0xdb, 0x7a, 0x23, 0x48, 0xc5, 0x2d, 0x59, 0x5f, 0x49, 0xf0, 0xcc, 0x36, 0xb2, 0x7d, 0xae,
+    0xfd, 0xfe, 0xd5, 0x78, 0xdc, 0x96, 0x6e, 0x55, 0x7e, 0x95, 0x73, 0x50, 0xd7, 0x2d, 0x6c,
+    0x01, 0x50, 0x77, 0xc8, 0x3f, 0x85, 0x7b, 0x56, 0x7e, 0xa3, 0xa8, 0xdc, 0x49, 0x0b, 0xb1,
+    0x6f, 0xb3, 0x42, 0x3b, 0x7f, 0x1b, 0x7f, 0x85, 0x72, 0x33, 0x4b, 0x92, 0x4b, 0x13, 0x8f,
+    0x4e, 0xe6, 0x93, 0xb4, 0x11, 0xa4, 0x7d, 0xe2, 0xce, 0xa9, 0xad, 0x5d, 0x6a, 0x4f, 0x86,
+    0x72, 0xb1, 0x8e, 0x88, 0x3a, 0x56, 0x4e, 0x32, 0x70, 0xbc, 0x9a, 0xb7, 0x6d, 0x65, 0x73,
+    0x7f, 0x26, 0xd8, 0x62, 0x3b, 0x7b, 0x9c, 0x70, 0x3e, 0xa6, 0xb5, 0xd2, 0xda, 0xcf, 0x45,
+    0x4d, 0xf3, 0x11, 0x24, 0xf8, 0xef, 0xdb, 0xe8, 0x2b, 0x15, 0x19, 0x4d, 0xdd, 0xec, 0x53,
+    0x92, 0x8e, 0x8b, 0x72, 0xb5, 0x8e, 0x8e, 0x15, 0x05, 0xc5, 0xe9, 0xd8, 0x9d, 0x42, 0x1e,
+    0xa6, 0x92, 0xfb, 0x56, 0x52, 0x3c, 0x9b, 0x60, 0x02, 0x0e, 0x38, 0xaa, 0x37, 0xfa, 0xa4,
+    0xd7, 0xce, 0x55, 0x72, 0xa9, 0xe9, 0x9a, 0xa0, 0x58, 0x46, 0xbc, 0x1e, 0x7d, 0x69, 0x4a,
+    0xa2, 0x8a, 0xb4, 0x01, 0x41, 0xb7, 0x79, 0x93, 0x3c, 0xa6, 0x3c, 0x92, 0x7e, 0x6f, 0xe5,
+    0x55, 0xa3, 0x89, 0xee, 0x9f, 0x8c, 0xec, 0x1f, 0x79, 0xaa, 0x7b, 0x4b, 0x29, 0x6f, 0x5c,
+    0x93, 0xf2, 0xc6, 0x39, 0x66, 0x3d, 0x05, 0x5d, 0x60, 0x80, 0x79, 0x50, 0x0c, 0x20, 0xef,
+    0xeb, 0xef, 0x59, 0xa8, 0x39, 0x6a, 0xf6, 0x2e, 0xfd, 0x08, 0x5b, 0x6a, 0xa8, 0x44, 0x18,
+    0x45, 0x15, 0x1e, 0x32, 0x7d, 0xea, 0x57, 0x50, 0x83, 0x07, 0xad, 0x24, 0x4b, 0xb9, 0xc5,
+    0x55, 0xb5, 0x02, 0x78, 0xc6, 0xc8, 0xfd, 0xcd, 0x50, 0xbe, 0x7f, 0x32, 0x64, 0x8f, 0xb2,
+    0xf2, 0x6b, 0x49, 0xc8, 0x54, 0x24, 0xf0, 0x00, 0xcd, 0x64, 0xa9, 0x2e, 0xcf, 0x21, 0xea,
+    0xc6, 0x8a, 0x9b, 0x72, 0x82, 0x1e, 0x2a, 0x7e, 0xde, 0xc6, 0xa0, 0xa9, 0xe2, 0x3b, 0xe3,
+    0xc7, 0x71, 0x51, 0x11, 0x82, 0x1f, 0xe1, 0x3f, 0x85, 0x32, 0x5b, 0x71, 0x20, 0xc7, 0x43,
+    0xd8, 0xd3, 0xfa, 0x35, 0x4b, 0x8e, 0xfd, 0xaa, 0xad, 0x7d, 0x00, 0xa7, 0x0c, 0xac, 0x8c,
+    0x62, 0x93, 0x87, 0x1e, 0xbd, 0xea, 0x79, 0x21, 0x59, 0x97, 0x9e, 0x1b, 0xd6, 0x96, 0x68,
+    0x16, 0x65, 0xc1, 0xe1, 0xc7, 0x46, 0xa8, 0x62, 0x98, 0xc6, 0xde, 0x54, 0xe3, 0x6b, 0x0e,
+    0x86, 0x96, 0xda, 0x30, 0x11, 0x4c, 0x90, 0x1c, 0x37, 0x23, 0xd6, 0xac, 0x2c, 0xa8, 0xfc,
+    0x37, 0x06, 0x9c, 0x70, 0xdc, 0x30, 0x18, 0xa8, 0x64, 0xb5, 0xc8, 0xca, 0x1f, 0xc2, 0x9d,
+    0x9a, 0xd8, 0x09, 0x8c, 0x5c, 0x65, 0x4e, 0x69, 0x32, 0x47, 0x51, 0x55, 0x41, 0x9e, 0xdc,
+    0xfc, 0xa4, 0xe3, 0xd0, 0xd4, 0xcb, 0x7a, 0xa7, 0x89, 0x50, 0xa9, 0xf5, 0xa3, 0x99, 0x3d,
+    0xf4, 0x0b, 0x12, 0x83, 0x46, 0x7e, 0xb4, 0xe5, 0x68, 0xa4, 0x1f, 0x2b, 0x0f, 0xce, 0x94,
+    0xc4, 0x7b, 0x1a, 0x76, 0xec, 0x22, 0x2c, 0xf3, 0x4a, 0x36, 0xd2, 0x98, 0xda, 0x93, 0x61,
+    0x1d, 0x8d, 0x16, 0x01, 0xc0, 0x2d, 0x29, 0xe8, 0x71, 0xf8, 0x53, 0x36, 0x9f, 0x43, 0x4e,
+    0x0a, 0xc3, 0xb5, 0x00, 0x50, 0x64, 0x78, 0x64, 0x2c, 0x06, 0x7d, 0x88, 0xeb, 0x48, 0xd3,
+    0x16, 0xda, 0xa0, 0xec, 0xc9, 0xe4, 0xfa, 0x56, 0x8e, 0x18, 0xf6, 0xa3, 0xcb, 0xf5, 0x50,
+    0x3f, 0x0a, 0x8e, 0x4e, 0xc3, 0xb9, 0xa5, 0x63, 0xa6, 0xf8, 0x55, 0x23, 0x56, 0xbd, 0xd5,
+    0xe4, 0x95, 0xf1, 0x92, 0x11, 0x19, 0x40, 0xfd, 0x2b, 0x51, 0x60, 0xf0, 0x31, 0xe8, 0xe4,
+    0xfe, 0x2f, 0x5c, 0xab, 0x49, 0x6d, 0x1f, 0xde, 0x20, 0x9f, 0x40, 0x33, 0x5a, 0x7a, 0x4e,
+    0x8f, 0x7d, 0xad, 0x48, 0x16, 0xde, 0xdc, 0x41, 0x07, 0x79, 0x5c, 0x76, 0xf6, 0x15, 0xac,
+    0x5a, 0xd9, 0x45, 0x10, 0xd7, 0x76, 0x74, 0x3a, 0x75, 0x87, 0x83, 0xf5, 0x0b, 0xcf, 0xb2,
+    0xda, 0x43, 0xe6, 0xcb, 0x82, 0xdc, 0x97, 0xc6, 0x05, 0x74, 0xb6, 0x7a, 0x26, 0x9b, 0x62,
+    0x43, 0x5b, 0x59, 0x43, 0x1b, 0x0f, 0xe2, 0x0b, 0x93, 0xf9, 0x9a, 0x66, 0x8f, 0xa0, 0xda,
+    0x68, 0xd0, 0xe2, 0x04, 0xdd, 0x29, 0x1f, 0x3c, 0xac, 0x3e, 0x66, 0xff, 0x00, 0x01, 0x5a,
+    0x98, 0x35, 0xd5, 0x08, 0xd9, 0x6a, 0x95, 0xc9, 0x13, 0x14, 0x52, 0x81, 0x4e, 0x51, 0x96,
+    0x15, 0x61, 0x61, 0x3c, 0x88, 0xe7, 0x89, 0x92, 0x45, 0x0c, 0xad, 0xc1, 0x52, 0x38, 0x35,
+    0x9d, 0xa6, 0x78, 0x6b, 0x4f, 0xd2, 0x35, 0x09, 0xee, 0xed, 0x10, 0xa9, 0x98, 0x63, 0x69,
+    0x39, 0x0b, 0xce, 0x78, 0xad, 0x80, 0x31, 0xd2, 0x96, 0xa1, 0xef, 0x71, 0x8d, 0x3c, 0x52,
+    0x53, 0x8d, 0x26, 0x28, 0x18, 0x0a, 0x53, 0xd2, 0x8c, 0x71, 0x47, 0x5a, 0x06, 0x00, 0xe0,
+    0xe6, 0x9c, 0x48, 0x23, 0x9a, 0x66, 0x29, 0x0f, 0xd6, 0x80, 0x10, 0xb7, 0xa5, 0x32, 0x9c,
+    0x69, 0x28, 0x01, 0x3a, 0xd2, 0xed, 0x26, 0xa6, 0x8e, 0x2c, 0xf2, 0x6a, 0x51, 0x10, 0xf4,
+    0xa9, 0xb8, 0xd4, 0x4a, 0x9b, 0x7d, 0x69, 0xac, 0x6a, 0xd3, 0xc5, 0xce, 0x47, 0x15, 0x0b,
+    0x44, 0x73, 0x45, 0xc7, 0x62, 0x02, 0x73, 0x48, 0x01, 0xab, 0x1e, 0x49, 0xf4, 0xa6, 0x95,
+    0xc7, 0x6a, 0x2e, 0x2b, 0x10, 0xf4, 0xa3, 0x34, 0xe2, 0x3d, 0x69, 0x8d, 0xc7, 0x7a, 0x00,
+    0x69, 0x3c, 0xd2, 0x67, 0x34, 0x1a, 0x4a, 0x04, 0x07, 0x9a, 0xc4, 0xf1, 0x1d, 0xf8, 0xb4,
+    0xd3, 0xdd, 0x54, 0xfc, 0xcc, 0x31, 0x5b, 0x0e, 0xc1, 0x14, 0x93, 0xd2, 0xb8, 0x6d, 0x6e,
+    0x76, 0xbf, 0xd5, 0x52, 0xdd, 0x4e, 0x55, 0x4e, 0x4f, 0xd6, 0x91, 0x32, 0x7d, 0x09, 0x74,
+    0x28, 0x44, 0x36, 0x65, 0x9f, 0xef, 0xbb, 0x64, 0x9f, 0x5a, 0xd3, 0x9e, 0x65, 0x86, 0x16,
+    0x91, 0x8e, 0x00, 0x19, 0x35, 0x55, 0x76, 0xc3, 0x18, 0x1d, 0x02, 0x8c, 0x0a, 0xc9, 0xd5,
+    0xae, 0xcb, 0x22, 0xc4, 0xa4, 0xe0, 0xf2, 0x6a, 0x9f, 0xba, 0x8c, 0x13, 0x73, 0x91, 0x8f,
+    0xa9, 0x5e, 0x34, 0xf2, 0x33, 0x13, 0xd6, 0xb2, 0xd0, 0x72, 0x58, 0xd4, 0xb7, 0x2f, 0xba,
+    0x42, 0x05, 0x24, 0x48, 0x5d, 0x95, 0x07, 0x52, 0x71, 0x5c, 0x12, 0x6e, 0x52, 0x3a, 0xd2,
+    0xb2, 0x34, 0xac, 0xa2, 0x11, 0x5b, 0x34, 0xce, 0x3b, 0x64, 0x55, 0x7b, 0x54, 0x6b, 0x8b,
+    0xc4, 0xcf, 0xae, 0x4d, 0x5d, 0xbf, 0x61, 0x15, 0xba, 0xc2, 0xbd, 0xf8, 0xfc, 0x28, 0xd3,
+    0x90, 0x43, 0x13, 0xcc, 0xdd, 0x5b, 0xe5, 0x5a, 0xdf, 0x97, 0xde, 0x51, 0xec, 0x45, 0xf4,
+    0xb9, 0x66, 0x53, 0x99, 0x4d, 0x2c, 0x23, 0xe7, 0x06, 0xa3, 0x27, 0x2c, 0x49, 0xef, 0x53,
+    0x40, 0x33, 0x93, 0x5d, 0x04, 0xb5, 0x64, 0x50, 0xd5, 0x0e, 0x64, 0x41, 0xed, 0x5a, 0x56,
+    0xd9, 0xf2, 0x16, 0x33, 0xd0, 0x28, 0xac, 0xbd, 0x48, 0xee, 0xba, 0x51, 0xec, 0x2b, 0x42,
+    0xd6, 0x42, 0xd2, 0xed, 0xed, 0x8a, 0xce, 0x1f, 0x1b, 0x14, 0x97, 0xb8, 0x8c, 0xe8, 0x41,
+    0xb6, 0xd4, 0x65, 0x56, 0xfe, 0xe9, 0x35, 0x8c, 0xdf, 0x33, 0x96, 0xf5, 0x35, 0xb3, 0xaa,
+    0x9f, 0x2e, 0xf8, 0xb0, 0xea, 0x63, 0xac, 0x6e, 0x82, 0xb9, 0x6a, 0xe8, 0xf9, 0x7b, 0x1a,
+    0xc7, 0x55, 0x71, 0xf0, 0xae, 0xf9, 0xd1, 0x7d, 0xea, 0xdd, 0xf8, 0x23, 0x60, 0xc7, 0x03,
+    0xbd, 0x26, 0x99, 0x09, 0x79, 0x8b, 0xf6, 0x1c, 0x55, 0xfb, 0xd0, 0x3c, 0xa9, 0x01, 0xe8,
+    0x05, 0x54, 0x21, 0x7a, 0x6d, 0x8d, 0xbd, 0x4a, 0x9a, 0x74, 0x3e, 0x7d, 0xc2, 0xa1, 0x38,
+    0xf7, 0xae, 0xeb, 0x4c, 0x55, 0xb7, 0x89, 0x11, 0x7a, 0x0e, 0x2b, 0x90, 0xd1, 0x23, 0x26,
+    0x46, 0x7f, 0x6c, 0x57, 0x55, 0x6d, 0x26, 0xdc, 0x01, 0x5d, 0x38, 0x78, 0xda, 0x17, 0x39,
+    0xab, 0x4b, 0xde, 0x48, 0xf5, 0xcf, 0x87, 0x57, 0xc5, 0x1a, 0x78, 0x72, 0x70, 0x0a, 0xc8,
+    0x00, 0xfc, 0x8f, 0xf4, 0xaf, 0x45, 0xd5, 0xad, 0x92, 0xe6, 0xd4, 0x96, 0x01, 0x94, 0x8d,
+    0xac, 0x3d, 0x54, 0xff, 0x00, 0x9f, 0xd6, 0xbc, 0x67, 0xc1, 0x97, 0x7f, 0x67, 0xd5, 0xed,
+    0xb2, 0x78, 0x93, 0xe4, 0x3f, 0x8f, 0xff, 0x00, 0x5f, 0x15, 0xed, 0x96, 0x84, 0x4f, 0x64,
+    0x11, 0xbd, 0x36, 0x1c, 0x7f, 0x9f, 0x4a, 0xe6, 0xc4, 0xae, 0x59, 0xdc, 0xf4, 0x29, 0x4f,
+    0xdc, 0x8c, 0xbb, 0x1f, 0x38, 0xf8, 0xaf, 0x4f, 0x3a, 0x76, 0xa1, 0x73, 0x6c, 0xdc, 0x15,
+    0x62, 0xaa, 0x4f, 0x70, 0x7a, 0x1f, 0xd6, 0xbc, 0xce, 0xf2, 0x36, 0x57, 0x6c, 0xf0, 0x73,
+    0xcd, 0x7b, 0xd7, 0xc5, 0x2d, 0x28, 0x89, 0x6d, 0xef, 0x42, 0xf5, 0x06, 0x19, 0x31, 0xfd,
+    0xe1, 0xd3, 0xfa, 0xfe, 0x55, 0xe2, 0xda, 0xb4, 0x38, 0x99, 0x9b, 0xd7, 0x9f, 0xf1, 0xae,
+    0x89, 0xbf, 0x69, 0x4d, 0x48, 0xe5, 0x94, 0x7d, 0x9d, 0x67, 0x13, 0x9c, 0x90, 0xb7, 0x42,
+    0x69, 0x88, 0x3e, 0x6c, 0xd4, 0xd3, 0x2e, 0x0d, 0x35, 0x17, 0x15, 0xc0, 0xd6, 0xa6, 0x85,
+    0xab, 0x5c, 0xb4, 0x98, 0x3c, 0xe3, 0x9a, 0xd3, 0x45, 0xc0, 0xe3, 0xa9, 0xaa, 0xda, 0x75,
+    0xb9, 0x60, 0x5b, 0x1d, 0x6a, 0xfb, 0x61, 0x54, 0x85, 0xe7, 0xd4, 0xfa, 0xd7, 0x6d, 0x18,
+    0xda, 0x37, 0x66, 0x72, 0x7a, 0xd8, 0xce, 0x9c, 0x6f, 0x98, 0x93, 0xce, 0xde, 0x05, 0x3e,
+    0x1b, 0x66, 0x94, 0xf0, 0x38, 0xf5, 0xab, 0x70, 0x58, 0x96, 0x3b, 0xe5, 0xef, 0xce, 0x2a,
+    0xfa, 0xc6, 0x15, 0x78, 0x18, 0x14, 0xe3, 0x4e, 0xee, 0xec, 0x99, 0x54, 0x4b, 0x44, 0x56,
+    0x8a, 0xd9, 0x63, 0x18, 0xc5, 0x4a, 0x48, 0x41, 0xc7, 0x5a, 0x73, 0xb0, 0x51, 0x54, 0xe5,
+    0x97, 0x3d, 0x2b, 0x57, 0x64, 0x66, 0x93, 0x93, 0x09, 0x66, 0xcf, 0x00, 0xe6, 0xa0, 0x2e,
+    0x49, 0xf7, 0xa4, 0x20, 0xb7, 0xb0, 0xa7, 0x61, 0x23, 0x1c, 0x9a, 0xce, 0xed, 0x9b, 0x24,
+    0x91, 0x3c, 0x0c, 0xca, 0xe3, 0xde, 0xba, 0x5d, 0x2e, 0xf0, 0xc1, 0x2a, 0x31, 0x3f, 0x51,
+    0x5c, 0x80, 0xb9, 0x66, 0x6c, 0x47, 0xc7, 0xbd, 0x6b, 0x69, 0xd2, 0x60, 0x8d, 0xcd, 0x93,
+    0x55, 0x19, 0x27, 0xa2, 0x32, 0xa8, 0x9a, 0xf7, 0x8f, 0xa2, 0x7c, 0x25, 0xa9, 0x8b, 0xed,
+    0x25, 0x63, 0x2d, 0x97, 0x83, 0x0a, 0x7d, 0xd7, 0xb7, 0xf8, 0x7e, 0x15, 0x67, 0xc4, 0xb0,
+    0x7d, 0xa3, 0x41, 0xb9, 0x50, 0xb9, 0x2a, 0x37, 0x8f, 0x6c, 0x75, 0xfd, 0x33, 0x5e, 0x75,
+    0xe0, 0x7d, 0x5f, 0xec, 0xda, 0x84, 0x2a, 0xed, 0x84, 0x7f, 0xdd, 0xb6, 0x7d, 0x0f, 0x4f,
+    0xd7, 0x15, 0xea, 0x92, 0xaa, 0xcb, 0x13, 0x46, 0xe3, 0x28, 0xc0, 0xa9, 0x1e, 0xa0, 0xd7,
+    0x0d, 0x58, 0xf2, 0x54, 0xb9, 0xec, 0x50, 0x97, 0xb5, 0xa6, 0x7c, 0xed, 0xaa, 0xc0, 0x12,
+    0x69, 0x14, 0x0e, 0xf5, 0xcc, 0x5d, 0x26, 0x1c, 0xd7, 0x73, 0xe2, 0x8b, 0x66, 0xb2, 0xbb,
+    0x95, 0x1c, 0x7c, 0xc8, 0xc5, 0x0f, 0xd4, 0x57, 0x07, 0x77, 0x2c, 0x85, 0xce, 0x00, 0x02,
+    0xbb, 0xa4, 0xd5, 0xae, 0x79, 0x2a, 0x2d, 0x54, 0x68, 0x84, 0x29, 0x26, 0xac, 0x45, 0x6e,
+    0x5b, 0xb5, 0x43, 0x6f, 0x6f, 0x34, 0xed, 0xd4, 0x81, 0xeb, 0x5b, 0xda, 0x76, 0x8d, 0x2c,
+    0xd2, 0x05, 0xe4, 0xaf, 0xad, 0x44, 0x57, 0x51, 0xca, 0x5d, 0x16, 0xe5, 0x15, 0xb1, 0xdf,
+    0xc0, 0x19, 0x3d, 0xb1, 0x57, 0x6d, 0xbc, 0x31, 0x7b, 0x79, 0x8f, 0x2e, 0x26, 0xe7, 0xd1,
+    0x49, 0x3f, 0x90, 0xaf, 0x62, 0xf0, 0x6f, 0xc2, 0xd4, 0x9a, 0x35, 0xbb, 0xd5, 0x15, 0xa2,
+    0x87, 0x82, 0xb0, 0x8e, 0x19, 0xfe, 0xa7, 0xb0, 0xfd, 0x6b, 0xbf, 0xbc, 0x7d, 0x2b, 0xc2,
+    0xda, 0x35, 0xc4, 0xf0, 0x59, 0xc3, 0x1c, 0x56, 0xc9, 0x9e, 0x14, 0x65, 0x9b, 0xb0, 0xfa,
+    0xd6, 0x73, 0xad, 0x14, 0xed, 0x1d, 0x4d, 0x29, 0xd1, 0x97, 0xda, 0x67, 0xca, 0x9a, 0xef,
+    0x85, 0x2f, 0x34, 0xa5, 0x06, 0xe1, 0x1a, 0x27, 0x2b, 0xb8, 0x2c, 0x88, 0x54, 0x91, 0xf8,
+    0xd7, 0x2b, 0x22, 0x60, 0xd7, 0xa1, 0x78, 0xdb, 0xc4, 0x17, 0xde, 0x23, 0xd4, 0x24, 0xb9,
+    0xbc, 0x93, 0x2c, 0x7e, 0x50, 0xaa, 0x30, 0x14, 0x76, 0x02, 0xb8, 0x19, 0x47, 0x26, 0xa2,
+    0xac, 0x76, 0x61, 0x16, 0x9b, 0x76, 0xd8, 0xab, 0x45, 0x39, 0xb8, 0x26, 0x9b, 0x8a, 0xe7,
+    0xb1, 0x63, 0xe3, 0x42, 0xed, 0x8a, 0xbb, 0x3d, 0xa9, 0x8e, 0xcc, 0x4c, 0x78, 0xc3, 0x0f,
+    0xca, 0xa6, 0xd3, 0xec, 0xf3, 0x86, 0x61, 0xc5, 0x5f, 0xbc, 0x4f, 0x36, 0xd2, 0x48, 0xc7,
+    0xf7, 0x78, 0xae, 0x88, 0xd2, 0xf7, 0x5b, 0x32, 0x94, 0xec, 0xec, 0x8c, 0x61, 0xc8, 0x1f,
+    0x95, 0x54, 0x94, 0x61, 0xcd, 0x58, 0x88, 0xee, 0x8f, 0xe9, 0x51, 0xdc, 0x2f, 0xcd, 0x9f,
+    0x5a, 0xca, 0x5a, 0xab, 0x9a, 0x21, 0x0f, 0xcd, 0x07, 0xd2, 0xa2, 0x57, 0x20, 0x10, 0x0f,
+    0x06, 0xa5, 0x88, 0xe5, 0x08, 0xa8, 0x71, 0x86, 0xc5, 0x43, 0xe8, 0xc0, 0x5a, 0x28, 0xa2,
+    0x81, 0x8d, 0x34, 0x52, 0x80, 0x49, 0xa5, 0x08, 0x4d, 0x2b, 0x00, 0x80, 0x66, 0x9c, 0x50,
+    0xaa, 0xe4, 0x8a, 0xb3, 0x0c, 0x1f, 0xc4, 0x45, 0x45, 0x72, 0xe0, 0xc9, 0xb4, 0x74, 0x5a,
+    0xae, 0x5b, 0x2b, 0xb1, 0x5c, 0x82, 0x8a, 0x28, 0xa8, 0x18, 0x51, 0x45, 0x28, 0x1c, 0xd0,
+    0x02, 0x51, 0x4e, 0xc5, 0x26, 0x28, 0x01, 0x28, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a, 0x00,
+    0x28, 0xa2, 0x8a, 0x00, 0xe8, 0x75, 0x5d, 0x0d, 0xb4, 0xeb, 0x81, 0x34, 0x2c, 0xc2, 0x06,
+    0x3f, 0x2b, 0xf7, 0x43, 0xef, 0x5a, 0xfa, 0x46, 0xb2, 0xd7, 0x3f, 0xe8, 0x77, 0x7f, 0x2d,
+    0xca, 0xf4, 0x3f, 0xdf, 0x15, 0xb9, 0x2c, 0x69, 0x34, 0x4d, 0x14, 0x8a, 0x19, 0x18, 0x60,
+    0x83, 0x5c, 0x7e, 0xa1, 0xa6, 0xc9, 0x6d, 0x70, 0xa8, 0xac, 0x43, 0xa9, 0xcc, 0x12, 0xfa,
+    0xfb, 0x1f, 0x7a, 0xef, 0xe5, 0xe5, 0x77, 0x89, 0xcf, 0x75, 0x35, 0x66, 0x76, 0x51, 0x25,
+    0x73, 0x7a, 0xd5, 0xb0, 0xb5, 0xd5, 0xc3, 0xe3, 0xf7, 0x37, 0x6b, 0x86, 0xff, 0x00, 0x78,
+    0x56, 0xb6, 0x89, 0xa9, 0x7d, 0xbe, 0xd8, 0xac, 0xa3, 0x6d, 0xcc, 0x5f, 0x2c, 0x8b, 0xfd,
+    0x6a, 0x3f, 0x13, 0x42, 0x64, 0xd2, 0x5a, 0x55, 0x1f, 0x3c, 0x2c, 0x24, 0x1f, 0x85, 0x53,
+    0x77, 0x57, 0x42, 0x8a, 0xe5, 0x76, 0x30, 0xb5, 0x06, 0x65, 0x82, 0xca, 0xfc, 0xf2, 0xd0,
+    0xb7, 0x91, 0x29, 0xf5, 0x1d, 0x8f, 0xe5, 0x5a, 0xda, 0x0c, 0xbb, 0x52, 0x7b, 0x5c, 0xf0,
+    0x8f, 0xbd, 0x3f, 0xdd, 0x6f, 0xfe, 0xbe, 0x6b, 0x3a, 0xd0, 0xae, 0xa3, 0x05, 0xdd, 0x89,
+    0xeb, 0x24, 0x42, 0x45, 0xfa, 0x8e, 0x86, 0xab, 0xe8, 0xd7, 0xa6, 0x07, 0x8e, 0x57, 0xe0,
+    0xa0, 0x30, 0xc9, 0xfd, 0x3f, 0x5c, 0x54, 0xa6, 0x94, 0xb4, 0x29, 0xab, 0xa6, 0x8a, 0x9a,
+    0xc4, 0x8d, 0xa8, 0x6b, 0xad, 0x1a, 0x64, 0xfc, 0xc2, 0x25, 0xaf, 0x43, 0xb6, 0x81, 0x2d,
+    0x2d, 0x22, 0x81, 0x38, 0x58, 0xd4, 0x2d, 0x79, 0xff, 0x00, 0x87, 0xa3, 0xfb, 0x57, 0x88,
+    0x62, 0x76, 0xe7, 0x0c, 0x64, 0x35, 0xe8, 0x2e, 0xdd, 0xa9, 0x52, 0xd6, 0xf2, 0xee, 0x13,
+    0xd2, 0xc8, 0x47, 0x93, 0x8c, 0x0a, 0xe3, 0x7c, 0x34, 0x73, 0x7f, 0x77, 0xfe, 0xf1, 0xfe,
+    0xb5, 0xd6, 0xe3, 0x26, 0xb9, 0x0f, 0x0d, 0x7f, 0xc8, 0x4e, 0xe8, 0x7b, 0xb7, 0xf3, 0xab,
+    0x97, 0xc5, 0x12, 0x16, 0xb1, 0x66, 0xd7, 0x85, 0xa3, 0x05, 0x6f, 0x09, 0xed, 0x28, 0xfe,
+    0x55, 0xd2, 0x29, 0x07, 0x81, 0x5c, 0xcf, 0x86, 0x58, 0xe6, 0xf5, 0x47, 0xfc, 0xf4, 0x07,
+    0xf4, 0xae, 0x96, 0x20, 0x73, 0x4d, 0x6c, 0x53, 0xdc, 0xb1, 0x1a, 0x64, 0xd5, 0xf8, 0x6d,
+    0x8b, 0x76, 0xa6, 0x59, 0xc2, 0x5d, 0x80, 0xc5, 0x76, 0xde, 0x1e, 0xf0, 0xeb, 0x5f, 0xb8,
+    0x2e, 0x30, 0x83, 0xad, 0x44, 0xe6, 0xa2, 0x6f, 0x4e, 0x17, 0x39, 0x84, 0xb0, 0x76, 0x1f,
+    0x2a, 0x1f, 0xca, 0xa3, 0x9a, 0xc2, 0x45, 0x04, 0x14, 0x3f, 0x95, 0x7b, 0x45, 0xb6, 0x83,
+    0x65, 0x6f, 0x18, 0x5f, 0x28, 0x13, 0xf4, 0xa4, 0xb9, 0xd0, 0x6c, 0xa7, 0x42, 0xbe, 0x52,
+    0x83, 0xf4, 0xac, 0x3d, 0xb9, 0xa7, 0x2c, 0x36, 0xb9, 0xe0, 0x73, 0xda, 0x11, 0x9e, 0x2a,
+    0x84, 0x90, 0x95, 0x35, 0xe9, 0xfa, 0xf7, 0x87, 0x85, 0xa4, 0xad, 0x84, 0xf9, 0x3b, 0x7b,
+    0x57, 0x1b, 0x7b, 0xa7, 0x81, 0x92, 0xb5, 0xd3, 0x0a, 0x8a, 0x46, 0x35, 0x68, 0xd8, 0xe7,
+    0x08, 0xc5, 0x25, 0x59, 0x9a, 0x12, 0x8c, 0x78, 0xaa, 0xf8, 0xad, 0x4e, 0x46, 0xac, 0x15,
+    0x91, 0xac, 0xea, 0x72, 0xc0, 0xd1, 0xd8, 0xd9, 0x8d, 0xf7, 0xb3, 0xf0, 0xbf, 0xec, 0x8f,
+    0x5a, 0xd3, 0xb8, 0x99, 0x2d, 0xad, 0xa4, 0x9e, 0x43, 0x84, 0x45, 0x2c, 0x6b, 0x27, 0xc2,
+    0xf6, 0xc6, 0xea, 0xe2, 0xe3, 0x5b, 0xbb, 0xe0, 0xb9, 0x2b, 0x1e, 0x7f, 0x84, 0x7b, 0x7f,
+    0x2a, 0x99, 0x37, 0xb2, 0x2a, 0x2b, 0xab, 0x36, 0xf4, 0x6d, 0x2a, 0x3d, 0x2e, 0xcb, 0x6e,
+    0x41, 0x95, 0xbe, 0x69, 0xa5, 0x3d, 0x59, 0xaa, 0x96, 0xa9, 0xab, 0xc5, 0x6a, 0x5b, 0x67,
+    0x2f, 0x8e, 0xa4, 0xff, 0x00, 0x9c, 0x0a, 0x66, 0xbb, 0xaf, 0x47, 0x6b, 0x0e, 0xc0, 0x70,
+    0x4f, 0xdd, 0x51, 0xd4, 0xd6, 0x1d, 0x96, 0x85, 0x79, 0xab, 0xbf, 0xda, 0x6f, 0xcb, 0x43,
+    0x6e, 0x4e, 0x42, 0x7f, 0x13, 0x7d, 0x68, 0x6e, 0xde, 0xec, 0x77, 0x2b, 0x47, 0xab, 0xd8,
+    0xae, 0x6f, 0x2e, 0x75, 0x59, 0xd9, 0x6d, 0xd5, 0xa5, 0x61, 0xdf, 0x1f, 0x2a, 0xd6, 0x9d,
+    0xae, 0x83, 0x0c, 0x0b, 0xe7, 0xdf, 0xc8, 0x18, 0x8e, 0x48, 0x3c, 0x01, 0x5a, 0x12, 0x5c,
+    0x59, 0x69, 0x16, 0xde, 0x55, 0xba, 0x2a, 0x85, 0xf4, 0xae, 0x57, 0x51, 0xd5, 0x26, 0xbd,
+    0x93, 0x1b, 0x8e, 0xce, 0xc2, 0xa6, 0x56, 0x8e, 0xb2, 0xd5, 0x82, 0xbc, 0xb4, 0x8e, 0x88,
+    0xd6, 0xbe, 0xf1, 0x14, 0x56, 0xf1, 0x98, 0x6c, 0x63, 0x00, 0x0e, 0x37, 0x63, 0x8f, 0xca,
+    0xb9, 0xa9, 0xa6, 0x96, 0xe6, 0x43, 0x24, 0xac, 0x49, 0x3e, 0xb4, 0x85, 0x42, 0x7c, 0xce,
+    0x79, 0xa4, 0x89, 0x27, 0xbb, 0x90, 0x47, 0x6d, 0x1b, 0x31, 0x3d, 0xc0, 0xae, 0x79, 0xce,
+    0x52, 0x76, 0x66, 0xd1, 0x84, 0x63, 0xb0, 0xc6, 0x70, 0x83, 0x1f, 0xa0, 0xad, 0x0d, 0x3f,
+    0x48, 0x92, 0xec, 0x7d, 0xa2, 0xe3, 0xf7, 0x56, 0xeb, 0xce, 0x4f, 0x7f, 0xa5, 0x6c, 0xe9,
+    0x5e, 0x16, 0x48, 0x71, 0x3d, 0xf7, 0xce, 0xdd, 0x42, 0x7f, 0x8d, 0x6c, 0x4b, 0x14, 0x79,
+    0x0e, 0xf8, 0x08, 0x83, 0x80, 0x7a, 0x2d, 0x6b, 0x4e, 0x85, 0xf5, 0x99, 0x95, 0x4a, 0xc9,
+    0x69, 0x13, 0x0a, 0x58, 0x5e, 0x45, 0x58, 0x21, 0x88, 0xc7, 0x0f, 0xf0, 0xaf, 0x76, 0xf7,
+    0x35, 0x46, 0x66, 0x8e, 0xdd, 0x4a, 0x21, 0x0c, 0x47, 0xde, 0x6a, 0xbb, 0xa9, 0x6a, 0xe8,
+    0xfb, 0xa1, 0xb6, 0xf9, 0x53, 0xa3, 0x3f, 0x76, 0xac, 0x36, 0x6d, 0xc7, 0xda, 0x9d, 0x49,
+    0xa5, 0xa2, 0x2a, 0x9a, 0x76, 0xd4, 0x52, 0x4b, 0xb6, 0x4d, 0x5b, 0x81, 0x36, 0xa6, 0x7b,
+    0x9a, 0x82, 0x18, 0xf7, 0x37, 0xb0, 0xab, 0x6c, 0xc1, 0x10, 0xb1, 0xe0, 0x01, 0x51, 0x15,
+    0xd5, 0x9a, 0x32, 0xa5, 0xfc, 0x9f, 0x28, 0x88, 0x75, 0x6e, 0xbf, 0x4a, 0xac, 0x06, 0x00,
+    0x14, 0x2b, 0x19, 0xa5, 0x69, 0x5b, 0xf0, 0xa5, 0x35, 0x94, 0x9d, 0xdd, 0xc6, 0x27, 0xb5,
+    0x3e, 0x17, 0xd8, 0xf5, 0x1b, 0xe4, 0x2e, 0xff, 0x00, 0x4a, 0x0f, 0xa8, 0xe9, 0x4b, 0x66,
+    0x05, 0xa7, 0x19, 0x24, 0xd2, 0x23, 0xed, 0xe0, 0xf4, 0xa2, 0x37, 0xde, 0x9e, 0xe3, 0xad,
+    0x0c, 0xbd, 0xea, 0xfc, 0xc4, 0x4c, 0x30, 0x7e, 0x94, 0x92, 0x40, 0x93, 0x26, 0xc9, 0x07,
+    0xd0, 0x8e, 0xa2, 0xa2, 0x57, 0x2a, 0x79, 0xe9, 0x56, 0x51, 0x81, 0x15, 0x6a, 0xcf, 0x46,
+    0x06, 0x79, 0x12, 0xda, 0x1c, 0x30, 0x2f, 0x17, 0x62, 0x3b, 0x55, 0x98, 0x67, 0x46, 0x03,
+    0x9c, 0x8a, 0xb3, 0x80, 0x46, 0x08, 0xc8, 0x35, 0x52, 0x5b, 0x0e, 0x4b, 0xc0, 0x76, 0x9f,
+    0x4e, 0xc6, 0xa5, 0xc5, 0xc7, 0x60, 0xb9, 0x64, 0xc6, 0xb2, 0x0e, 0xcc, 0x2a, 0xbc, 0x96,
+    0xe4, 0x74, 0x19, 0x15, 0x0a, 0x4f, 0x24, 0x2f, 0xb6, 0x40, 0x55, 0xbf, 0x9d, 0x5e, 0x8a,
+    0xe1, 0x5c, 0x00, 0xc6, 0x9a, 0x71, 0x90, 0x19, 0xed, 0x02, 0xe7, 0xa1, 0x53, 0xed, 0x4a,
+    0xab, 0x32, 0xfd, 0xc9, 0x8f, 0xe3, 0x5a, 0xdb, 0x50, 0x8e, 0x82, 0xa1, 0x96, 0x18, 0xc4,
+    0x6c, 0xdb, 0x79, 0x00, 0x9a, 0x1d, 0x2b, 0x6a, 0x82, 0xe6, 0x6c, 0x93, 0xdc, 0xc4, 0x40,
+    0x76, 0x53, 0x9f, 0x6a, 0x72, 0xdc, 0xdc, 0xe0, 0x1d, 0x80, 0x83, 0x52, 0xda, 0xe9, 0xb7,
+    0xb7, 0x51, 0x79, 0xf1, 0x44, 0x8e, 0xac, 0x48, 0xc9, 0x61, 0xfc, 0xaa, 0xea, 0x68, 0x3a,
+    0x83, 0x0c, 0xb4, 0xb1, 0x27, 0xb5, 0x44, 0x61, 0x51, 0xea, 0xae, 0x27, 0x38, 0xad, 0xd9,
+    0x44, 0x5d, 0xdc, 0xff, 0x00, 0xcf, 0x2a, 0x5f, 0xb5, 0xdd, 0x7f, 0xcf, 0x1a, 0xbc, 0xfa,
+    0x1d, 0xcc, 0x31, 0x99, 0x26, 0xbe, 0x8a, 0x35, 0x1d, 0xcd, 0x1f, 0xd8, 0xda, 0x82, 0xe9,
+    0x87, 0x53, 0x86, 0x39, 0x6e, 0x2c, 0xd5, 0xb6, 0xb4, 0x8a, 0x84, 0x01, 0xef, 0xf4, 0xf7,
+    0xaa, 0x71, 0xa8, 0xb7, 0xfd, 0x01, 0x4a, 0x2f, 0x62, 0x81, 0x9a, 0xed, 0xfb, 0x05, 0xa6,
+    0xf9, 0x12, 0x49, 0xfe, 0xb6, 0x52, 0x47, 0xa0, 0xab, 0xb6, 0x9a, 0x6e, 0xa5, 0xa8, 0x43,
+    0xe7, 0x5a, 0xc0, 0x8d, 0x1e, 0x71, 0x92, 0xc2, 0x96, 0x5d, 0x2f, 0x56, 0xb7, 0x19, 0x92,
+    0xc9, 0x98, 0x0e, 0xa5, 0x0e, 0x69, 0x72, 0xc9, 0xab, 0xb4, 0xc7, 0xcd, 0x1b, 0xda, 0xe4,
+    0x16, 0xcc, 0xba, 0x75, 0xd4, 0x77, 0x51, 0x44, 0x92, 0xec, 0x3f, 0x34, 0x72, 0x8c, 0x86,
+    0x15, 0xeb, 0x7a, 0x35, 0xfd, 0xae, 0xa7, 0xa7, 0x47, 0x75, 0x6b, 0x80, 0x8c, 0x30, 0x54,
+    0x71, 0xb4, 0xf7, 0x06, 0xbc, 0x80, 0x5c, 0x21, 0x6d, 0x8e, 0x0a, 0x37, 0x70, 0xc2, 0xba,
+    0x4f, 0x01, 0x6a, 0x26, 0xd3, 0x5a, 0x97, 0x4e, 0x76, 0xfd, 0xd5, 0xc0, 0xca, 0x8f, 0x46,
+    0x1c, 0xff, 0x00, 0x2a, 0xd2, 0x8c, 0xec, 0xf9, 0x7a, 0x31, 0x49, 0x75, 0x3d, 0x33, 0x6f,
+    0x4a, 0x76, 0x06, 0x28, 0x1c, 0xd2, 0xd7, 0x55, 0xc4, 0x37, 0x68, 0xa7, 0x80, 0x00, 0xe0,
+    0x52, 0x62, 0x9d, 0x40, 0x06, 0x29, 0x78, 0xa6, 0xe6, 0x8a, 0x40, 0x2e, 0x68, 0xa4, 0xa2,
+    0x81, 0x8e, 0xed, 0x4d, 0xe9, 0x4f, 0x51, 0xb8, 0xd2, 0x84, 0xf5, 0xa0, 0x76, 0x22, 0xa4,
+    0xa9, 0xf6, 0x0f, 0x4a, 0x42, 0x83, 0x18, 0xc5, 0x2b, 0x85, 0x8a, 0xe6, 0x9f, 0x1a, 0xf2,
+    0x29, 0x76, 0x63, 0xad, 0x48, 0x8b, 0xd2, 0x93, 0x63, 0x48, 0x96, 0x31, 0xb8, 0xe2, 0xba,
+    0x65, 0xf0, 0xe4, 0x66, 0xd3, 0x99, 0x5b, 0xcf, 0xdb, 0x9c, 0xf6, 0xcd, 0x73, 0xf0, 0xc6,
+    0x73, 0xed, 0x5d, 0x5d, 0xb6, 0xa1, 0x25, 0xc4, 0x01, 0x04, 0x64, 0x48, 0x46, 0x0b, 0x76,
+    0xfa, 0xd6, 0x15, 0x1b, 0xe8, 0x74, 0xd2, 0x8c, 0x5e, 0xe7, 0x35, 0xf6, 0x43, 0xb8, 0x8c,
+    0x73, 0x47, 0xd8, 0x5b, 0x9f, 0x94, 0xfe, 0x55, 0xd7, 0x41, 0xa6, 0x45, 0x18, 0x05, 0xf9,
+    0x35, 0x67, 0xec, 0xb0, 0x81, 0x8d, 0x82, 0xb3, 0x75, 0x4b, 0x54, 0x4e, 0x11, 0xad, 0x18,
+    0x7f, 0x0d, 0x55, 0x92, 0x06, 0x1d, 0xab, 0xbd, 0xb8, 0xd3, 0x61, 0x95, 0x0e, 0xd1, 0x83,
+    0x5c, 0xfd, 0xfe, 0x97, 0x2d, 0xb0, 0xde, 0xcb, 0xf2, 0x13, 0xf7, 0x87, 0x4a, 0xb8, 0xd4,
+    0x4c, 0x89, 0xd2, 0xb1, 0xcb, 0xc9, 0x1e, 0x3a, 0x7e, 0x55, 0x5c, 0x8a, 0xd3, 0xb9, 0x8f,
+    0x19, 0x38, 0xac, 0xd7, 0x18, 0x35, 0xb2, 0x77, 0x39, 0xa4, 0x88, 0xcd, 0x25, 0x29, 0x1c,
+    0x52, 0x1a, 0x64, 0x99, 0xda, 0xb5, 0xd2, 0xdb, 0x5a, 0x3b, 0xb1, 0xe1, 0x57, 0x26, 0xb8,
+    0xdd, 0x29, 0x5a, 0x69, 0xe4, 0xb9, 0x90, 0x7c, 0xcc, 0x73, 0x5a, 0x5e, 0x2b, 0xbc, 0xde,
+    0xc9, 0x68, 0x87, 0x97, 0x39, 0x20, 0x7a, 0x0a, 0x86, 0xc9, 0x04, 0x16, 0xf8, 0xef, 0xde,
+    0x9a, 0x57, 0x7e, 0x86, 0x35, 0x1e, 0x97, 0x1f, 0x74, 0xd8, 0x00, 0x76, 0xea, 0x6b, 0x97,
+    0xd4, 0x6e, 0x87, 0x98, 0xcc, 0x39, 0xec, 0x2b, 0x4e, 0xfe, 0xf5, 0x9e, 0x47, 0x45, 0x18,
+    0x1d, 0x33, 0x58, 0x57, 0xe4, 0x00, 0x14, 0x75, 0xea, 0x6b, 0x2a, 0xf3, 0xf7, 0x6c, 0x8a,
+    0xa5, 0x0b, 0x6a, 0xca, 0x5c, 0x96, 0xc9, 0xea, 0x6a, 0xf5, 0x98, 0xfd, 0xfa, 0x91, 0xfc,
+    0x3c, 0xd5, 0x25, 0x1f, 0x30, 0xab, 0x71, 0x33, 0x27, 0x2a, 0x71, 0x5c, 0x90, 0xde, 0xe6,
+    0xec, 0xb1, 0x33, 0xbd, 0xd5, 0xd0, 0x50, 0x39, 0xce, 0xd0, 0x2b, 0x4a, 0xe2, 0x31, 0x08,
+    0x8a, 0x05, 0xe8, 0xa3, 0x9a, 0xaf, 0xa7, 0xdb, 0xb0, 0xb8, 0x8a, 0x47, 0x1c, 0xb7, 0x23,
+    0x35, 0x62, 0xe1, 0xb7, 0xdd, 0x31, 0xf4, 0xe2, 0xba, 0xe0, 0x9d, 0x9b, 0x7d, 0x4c, 0x9f,
+    0xc5, 0x61, 0xa0, 0x71, 0x56, 0x21, 0x18, 0x8f, 0xeb, 0x50, 0x55, 0xb0, 0x30, 0xa0, 0x7b,
+    0x56, 0xe8, 0x99, 0x98, 0xba, 0x8b, 0x62, 0xf8, 0x7d, 0x05, 0x68, 0x5a, 0x0f, 0xdf, 0x83,
+    0xed, 0x59, 0xda, 0x98, 0xc5, 0xe0, 0xfa, 0x0a, 0xd2, 0xb3, 0xe6, 0x51, 0x58, 0x43, 0xe3,
+    0x65, 0x4b, 0xe0, 0x33, 0x75, 0xdf, 0xf8, 0xf9, 0x53, 0xfe, 0xce, 0x2b, 0x24, 0x9c, 0xad,
+    0x6b, 0x6b, 0xbf, 0xf1, 0xf0, 0xb5, 0x95, 0x1a, 0xee, 0x70, 0x2b, 0x9a, 0xb7, 0xf1, 0x1a,
+    0x2e, 0x1f, 0x0a, 0x3a, 0x0d, 0x1e, 0x00, 0xb6, 0x65, 0x88, 0xe5, 0x8d, 0x57, 0xd4, 0x4e,
+    0x01, 0x5f, 0x56, 0xad, 0x5b, 0x68, 0xfc, 0xab, 0x58, 0xd7, 0xdb, 0x35, 0x89, 0x7a, 0xc5,
+    0xa6, 0x0b, 0x5d, 0x35, 0x17, 0x2d, 0x34, 0x88, 0x83, 0xbc, 0x9b, 0x34, 0xf4, 0x88, 0xf6,
+    0x5a, 0xee, 0xf5, 0x39, 0xad, 0x78, 0x1f, 0x32, 0x01, 0x54, 0x6d, 0xd7, 0xc9, 0xb7, 0x45,
+    0xe9, 0x85, 0xa9, 0x2d, 0x9f, 0xe6, 0x27, 0xd4, 0xd7, 0x44, 0x15, 0xa2, 0x91, 0x85, 0x45,
+    0xcd, 0x76, 0x76, 0x5a, 0x3d, 0xc1, 0x8e, 0x64, 0x75, 0x3c, 0xa9, 0x04, 0x57, 0xbe, 0x68,
+    0xb7, 0x02, 0x78, 0x01, 0x1d, 0x24, 0x41, 0x22, 0x8f, 0xaf, 0xf9, 0x15, 0xf3, 0xae, 0x9b,
+    0x2e, 0xd2, 0x09, 0xaf, 0x6a, 0xf0, 0x26, 0xa1, 0xf6, 0xbd, 0x26, 0xd9, 0xb3, 0xf7, 0x19,
+    0xa1, 0x3e, 0xfe, 0x9f, 0xcc, 0x57, 0x3e, 0x2e, 0x3e, 0xed, 0xce, 0xbc, 0x24, 0xb9, 0xa0,
+    0xe2, 0x4b, 0xe3, 0xcd, 0x33, 0xed, 0xda, 0x1d, 0xda, 0x85, 0xcb, 0x6c, 0xf3, 0x57, 0xfd,
+    0xe5, 0xeb, 0xfa, 0x7f, 0x3a, 0xf9, 0xb3, 0x59, 0x83, 0x0d, 0x9c, 0x57, 0xd6, 0xda, 0xa4,
+    0x42, 0x4b, 0x6c, 0x95, 0x07, 0x07, 0x07, 0x3e, 0x87, 0xfc, 0x8a, 0xf9, 0x97, 0xc4, 0xfa,
+    0x71, 0xb4, 0xbe, 0xba, 0xb7, 0x23, 0x98, 0xa4, 0x65, 0xfc, 0x8d, 0x4e, 0x15, 0xde, 0x2e,
+    0x22, 0xc4, 0x6d, 0x09, 0xfc, 0x8f, 0x3c, 0x9e, 0x3f, 0x9a, 0x92, 0x18, 0x1a, 0x59, 0x02,
+    0x81, 0xd6, 0xaf, 0xcb, 0x6e, 0x59, 0xc8, 0x03, 0xbd, 0x6a, 0xe9, 0x9a, 0x66, 0x3e, 0x77,
+    0x5c, 0x28, 0xfd, 0x69, 0x2a, 0x2d, 0xcb, 0x52, 0x65, 0x35, 0x15, 0x71, 0x21, 0xb4, 0x29,
+    0x0a, 0xc7, 0x18, 0xe7, 0xb9, 0xab, 0x22, 0xd9, 0x21, 0x4e, 0x99, 0x63, 0xde, 0xaf, 0x6c,
+    0x03, 0x80, 0x30, 0x2a, 0x19, 0x71, 0xbb, 0x8e, 0xd5, 0xd9, 0x64, 0xb6, 0x38, 0xdc, 0xdb,
+    0x2b, 0x88, 0xc2, 0x8c, 0x9a, 0x8e, 0x46, 0xc5, 0x49, 0x23, 0xe3, 0x8a, 0xa8, 0xe4, 0xb1,
+    0xc0, 0xe4, 0xd2, 0x65, 0x45, 0x5f, 0x56, 0x45, 0x2b, 0x92, 0x71, 0x51, 0x18, 0xf0, 0x32,
+    0xd5, 0x71, 0xa1, 0x48, 0x22, 0x32, 0x4a, 0xc0, 0x1a, 0xc3, 0xba, 0xbb, 0x79, 0xdb, 0x62,
+    0x02, 0x17, 0xdb, 0xa9, 0xac, 0xaa, 0x49, 0x47, 0x73, 0xa2, 0x0e, 0xfb, 0x05, 0xcd, 0xea,
+    0xa1, 0x2a, 0x9c, 0x9a, 0x8e, 0x26, 0x96, 0x44, 0xdd, 0x21, 0xfa, 0x51, 0x15, 0xb0, 0x5f,
+    0x99, 0xb9, 0x35, 0x64, 0x2e, 0x45, 0x73, 0xfb, 0xd2, 0x77, 0x66, 0x83, 0x13, 0x8e, 0x05,
+    0x68, 0xda, 0xb8, 0x46, 0x04, 0x9a, 0xa2, 0xe5, 0x62, 0x5c, 0x9f, 0xca, 0xab, 0x7d, 0xa9,
+    0xdd, 0xb1, 0xd0, 0x7a, 0x55, 0xa9, 0xa8, 0x09, 0xae, 0x65, 0x63, 0xbb, 0xd2, 0x35, 0x25,
+    0x4b, 0x84, 0x01, 0xb8, 0x3c, 0x67, 0xd2, 0xbd, 0xe7, 0x44, 0xd4, 0x3f, 0xb4, 0xb4, 0x88,
+    0x2e, 0x09, 0xcb, 0xe3, 0x6b, 0xff, 0x00, 0xbc, 0x3a, 0xff, 0x00, 0x8f, 0xe3, 0x5f, 0x30,
+    0x58, 0x4f, 0xb5, 0x87, 0x35, 0xed, 0x9f, 0x0d, 0xf5, 0x8f, 0x37, 0x75, 0x9b, 0xb7, 0xfa,
+    0xd5, 0xdc, 0xa3, 0xfd, 0xa1, 0xd7, 0xf3, 0x1f, 0xca, 0x8a, 0xf1, 0xe7, 0x85, 0xd1, 0xae,
+    0x0e, 0x7e, 0xce, 0xa7, 0x23, 0xd9, 0x94, 0xfe, 0x23, 0xe9, 0x84, 0x5e, 0x19, 0xd5, 0x7e,
+    0x59, 0x90, 0x38, 0x3f, 0xed, 0x0e, 0x08, 0xfe, 0x47, 0xf1, 0xaf, 0x2f, 0xfe, 0xcd, 0x69,
+    0x64, 0xca, 0xa6, 0xef, 0xaf, 0x4a, 0xfa, 0x03, 0xc6, 0x3a, 0x7f, 0xdb, 0x34, 0x36, 0x94,
+    0x2e, 0x5e, 0xdc, 0xef, 0xe0, 0x64, 0xed, 0xe8, 0x7f, 0xc7, 0xf0, 0xaf, 0x2e, 0x36, 0x8b,
+    0xd1, 0x46, 0x07, 0xa0, 0xaa, 0xa3, 0x2e, 0x68, 0x21, 0x62, 0xa9, 0x35, 0x56, 0xeb, 0xa9,
+    0x85, 0x69, 0xa3, 0xb9, 0x23, 0x2c, 0x3e, 0x80, 0x71, 0x5e, 0xc1, 0xf0, 0xeb, 0xc1, 0xf1,
+    0x15, 0x4d, 0x4a, 0xea, 0x30, 0x63, 0x43, 0xfb, 0xa5, 0x3d, 0xcf, 0xad, 0x72, 0x3a, 0x26,
+    0x96, 0x6f, 0xb5, 0x18, 0x2d, 0x94, 0x1f, 0xde, 0x30, 0x04, 0x8e, 0xc3, 0xb9, 0xfc, 0xab,
+    0xde, 0xac, 0xed, 0xa3, 0xb3, 0xb3, 0x8a, 0xde, 0x25, 0xda, 0x88, 0xa0, 0x01, 0x59, 0xd7,
+    0xa9, 0x65, 0xca, 0x89, 0xa7, 0x05, 0x15, 0xcd, 0xd4, 0x2e, 0xa6, 0x16, 0xf6, 0xe4, 0xa8,
+    0xf9, 0xba, 0x28, 0xf7, 0xaf, 0x30, 0xf8, 0xa1, 0xa9, 0x79, 0x1a, 0x7d, 0xbe, 0x9a, 0xad,
+    0xf3, 0x37, 0xef, 0x64, 0xf7, 0xf4, 0xfe, 0xbf, 0x95, 0x7a, 0x1c, 0xf2, 0x89, 0xaf, 0x40,
+    0xcf, 0xc9, 0x18, 0xcd, 0x78, 0x4f, 0x8e, 0x75, 0x33, 0xa8, 0xeb, 0x97, 0x32, 0xee, 0xca,
+    0xee, 0xda, 0xbf, 0x41, 0xc5, 0x63, 0x42, 0x3c, 0xd3, 0xbf, 0x63, 0x7a, 0x9f, 0xbb, 0xa5,
+    0xe6, 0xcf, 0x3e, 0xd4, 0x7a, 0xb5, 0x73, 0x33, 0x7d, 0xf3, 0x5d, 0x16, 0xa2, 0xf8, 0xc9,
+    0xae, 0x6e, 0x43, 0x93, 0x9a, 0xde, 0xb9, 0xc9, 0x4b, 0x62, 0x13, 0xd6, 0xac, 0x59, 0xdb,
+    0x99, 0xa7, 0x03, 0xb0, 0xa8, 0x42, 0xe4, 0xfa, 0x9a, 0xdb, 0xd3, 0xad, 0xfc, 0xa8, 0xb7,
+    0x11, 0xc9, 0xac, 0x69, 0xc7, 0x9a, 0x45, 0xc9, 0xd9, 0x16, 0x91, 0x02, 0x28, 0x55, 0xe8,
+    0x29, 0xe1, 0x73, 0x4b, 0x8a, 0x47, 0x70, 0x89, 0x9a, 0xed, 0xb1, 0xcc, 0xf5, 0x39, 0xcd,
+    0xbe, 0x55, 0xcc, 0xb1, 0x1e, 0xcc, 0x45, 0x24, 0xeb, 0x94, 0xfa, 0x53, 0xef, 0x1b, 0xfd,
+    0x3c, 0xbf, 0xf7, 0x87, 0x34, 0x38, 0xca, 0x9a, 0xe2, 0xb6, 0xe8, 0xea, 0x45, 0x58, 0x4e,
+    0x1c, 0x8f, 0x5a, 0x6c, 0xa3, 0x0f, 0x40, 0xf9, 0x64, 0x1f, 0x5a, 0x7c, 0xc3, 0x80, 0x6b,
+    0x2e, 0x85, 0x11, 0xd1, 0x40, 0xe9, 0x4f, 0x45, 0xef, 0x40, 0x0f, 0x89, 0x39, 0xab, 0x71,
+    0xc0, 0x3a, 0x9a, 0x65, 0xba, 0x67, 0xe6, 0x3d, 0x2a, 0xc9, 0x61, 0x8a, 0xde, 0x11, 0xd2,
+    0xe4, 0x49, 0x90, 0xcc, 0xfb, 0x46, 0x05, 0x66, 0x93, 0x92, 0x4d, 0x5a, 0xb9, 0x6e, 0x0f,
+    0xa9, 0xaa, 0x95, 0x95, 0x47, 0x76, 0x52, 0x41, 0x45, 0x14, 0x56, 0x63, 0x14, 0x0a, 0x78,
+    0x18, 0xe2, 0x91, 0x07, 0x7f, 0x4a, 0x52, 0x6a, 0xac, 0x02, 0x1a, 0x42, 0x68, 0x26, 0x9b,
+    0x48, 0x02, 0x8a, 0x28, 0xa4, 0x01, 0x45, 0x14, 0x50, 0x01, 0x45, 0x14, 0xb4, 0x01, 0xe9,
+    0x22, 0x69, 0x14, 0xe1, 0x85, 0x2c, 0xf6, 0xd1, 0x6a, 0x16, 0xcd, 0x13, 0xf0, 0x4f, 0x2a,
+    0xc3, 0xaa, 0x9f, 0x5a, 0xb0, 0xc8, 0xac, 0x39, 0xaa, 0xe3, 0x31, 0x3f, 0xb5, 0x7a, 0x9b,
+    0x9c, 0x1a, 0xa6, 0x73, 0x88, 0xf3, 0xd9, 0x5f, 0x19, 0x54, 0x62, 0xea, 0x03, 0xb6, 0x54,
+    0x1d, 0x24, 0x4a, 0xe9, 0xe4, 0x96, 0x3d, 0x43, 0x4b, 0x76, 0x8c, 0xee, 0x8e, 0x58, 0xce,
+    0x3f, 0x2a, 0xcf, 0xd7, 0x2c, 0xda, 0x58, 0x16, 0xfe, 0xdd, 0x73, 0x3c, 0x23, 0xe6, 0x03,
+    0xf8, 0xd7, 0xb8, 0xaa, 0xda, 0x35, 0xea, 0x47, 0x20, 0x8c, 0x1f, 0xf4, 0x7b, 0x8e, 0x57,
+    0xfd, 0x96, 0xf4, 0xfc, 0x6a, 0x16, 0x8e, 0xc6, 0xcf, 0x55, 0x74, 0x63, 0x78, 0x7e, 0xe3,
+    0x1a, 0xcd, 0xaa, 0x1f, 0xbd, 0x86, 0x8c, 0xff, 0x00, 0x4a, 0xb3, 0xa9, 0xda, 0x8b, 0x1d,
+    0x76, 0x58, 0xc8, 0xc4, 0x37, 0x43, 0x72, 0xfd, 0x7f, 0xfd, 0x75, 0x9d, 0xa7, 0x7e, 0xe7,
+    0xc4, 0xd1, 0x0f, 0x4b, 0x82, 0x3f, 0x5c, 0x57, 0x5d, 0xe2, 0x9b, 0x03, 0x75, 0xa6, 0x79,
+    0xf1, 0x8f, 0xde, 0xdb, 0x9d, 0xe3, 0xe9, 0xde, 0xb1, 0x85, 0xdc, 0x5f, 0x93, 0x34, 0x7a,
+    0x4a, 0xe6, 0x0f, 0x85, 0x22, 0x31, 0x6b, 0x52, 0xab, 0x7d, 0xe4, 0x8c, 0x8f, 0xd4, 0x57,
+    0x68, 0x79, 0xae, 0x47, 0x46, 0x99, 0x7f, 0xb5, 0xad, 0xee, 0x47, 0x0b, 0x70, 0x85, 0x0f,
+    0xfb, 0xdf, 0xe4, 0x57, 0x65, 0x1a, 0xe4, 0xe4, 0xd6, 0xb4, 0xd5, 0x95, 0x91, 0x9c, 0xf5,
+    0x62, 0xc6, 0x98, 0x19, 0x35, 0xc3, 0xf8, 0x70, 0xe3, 0x58, 0xb9, 0x1e, 0xa5, 0xbf, 0x9d,
+    0x77, 0x6c, 0x70, 0x31, 0x5c, 0x0f, 0x87, 0xce, 0x35, 0xd9, 0x07, 0xab, 0xbf, 0xf5, 0xa2,
+    0x5f, 0x14, 0x46, 0x97, 0xba, 0xcd, 0xdf, 0x0c, 0x9f, 0xdf, 0xdf, 0x0f, 0xf6, 0x97, 0xfa,
+    0xd7, 0x57, 0x69, 0x11, 0x91, 0x85, 0x72, 0x7e, 0x18, 0x1b, 0xaf, 0x2f, 0x47, 0xd3, 0xf9,
+    0x9a, 0xee, 0xec, 0x54, 0x29, 0x02, 0x9d, 0xf4, 0x29, 0x2b, 0xc8, 0xde, 0xd1, 0xf4, 0xfd,
+    0xf2, 0x22, 0x81, 0x92, 0x4d, 0x7a, 0x8c, 0x02, 0x0d, 0x13, 0x4b, 0x56, 0x60, 0x03, 0x63,
+    0xf3, 0xae, 0x2f, 0xc2, 0x91, 0x09, 0x6f, 0xe2, 0x04, 0x64, 0x66, 0xb7, 0x7c, 0x4f, 0x72,
+    0x5a, 0xed, 0x20, 0xcf, 0xca, 0xa3, 0x35, 0xc9, 0x51, 0xf3, 0x4a, 0xc7, 0x74, 0x62, 0xac,
+    0x90, 0xc9, 0xf5, 0xcb, 0xbb, 0x86, 0x25, 0x1b, 0x62, 0x76, 0x14, 0xc8, 0x75, 0xab, 0xbb,
+    0x79, 0x43, 0x33, 0xee, 0x4e, 0xe2, 0xb2, 0x0c, 0xc4, 0x70, 0x29, 0x3c, 0xfc, 0xf5, 0xa3,
+    0x95, 0x1a, 0x5d, 0x6c, 0x76, 0xf7, 0x29, 0x0e, 0xaf, 0xa6, 0x17, 0x00, 0x13, 0xb6, 0xbc,
+    0xbb, 0x57, 0xb5, 0x30, 0x4f, 0x22, 0x11, 0xd0, 0xd7, 0x7f, 0xe1, 0x79, 0x8b, 0xc5, 0x2c,
+    0x27, 0xa7, 0x38, 0xae, 0x2f, 0xc5, 0x19, 0x8a, 0xfa, 0x50, 0x7a, 0x9e, 0x69, 0xd2, 0xd2,
+    0x56, 0x32, 0x9a, 0xb4, 0x59, 0xc6, 0xde, 0x44, 0x0e, 0x71, 0xd4, 0x56, 0x53, 0xae, 0x1a,
+    0xb5, 0x2e, 0x65, 0xc9, 0x35, 0x9d, 0x21, 0xcb, 0x57, 0x72, 0x3c, 0xfa, 0x96, 0xb9, 0x83,
+    0xe2, 0x35, 0x92, 0x5b, 0x28, 0xad, 0x63, 0xff, 0x00, 0x96, 0xf2, 0x00, 0xc7, 0xd8, 0x7f,
+    0x91, 0x4d, 0xd4, 0x75, 0x25, 0xd3, 0x60, 0x83, 0x4a, 0xb2, 0x88, 0xcb, 0x38, 0x50, 0x15,
+    0x17, 0xd7, 0xd4, 0xd4, 0x7e, 0x27, 0xbe, 0x36, 0xe2, 0xd6, 0x28, 0x86, 0xeb, 0x82, 0xfb,
+    0x91, 0x47, 0xe5, 0x57, 0x74, 0x4d, 0x23, 0xfb, 0x3e, 0x26, 0xba, 0xbb, 0x3e, 0x65, 0xec,
+    0xdf, 0x33, 0xb1, 0xe7, 0x1e, 0xd5, 0x2d, 0xde, 0x56, 0x5b, 0x89, 0x2f, 0x77, 0x52, 0x0d,
+    0x33, 0x42, 0x5b, 0x77, 0xfe, 0xd0, 0xd4, 0xd8, 0x4d, 0x76, 0x79, 0x00, 0xf4, 0x4f, 0xa5,
+    0x49, 0xa9, 0x6a, 0xcb, 0x1a, 0x91, 0x9c, 0x01, 0xd0, 0x0a, 0x6e, 0xab, 0xa8, 0x15, 0xca,
+    0x83, 0xd2, 0xb9, 0x97, 0x77, 0xb9, 0x90, 0xb3, 0x1e, 0x29, 0xb6, 0xa0, 0xac, 0x85, 0x18,
+    0xb9, 0xea, 0xf6, 0x16, 0x79, 0x65, 0xbc, 0x72, 0xcc, 0x7e, 0x5f, 0x4a, 0xad, 0x2e, 0xd8,
+    0x48, 0x44, 0x1b, 0xa4, 0x6e, 0x80, 0x54, 0x92, 0xcc, 0xca, 0xcb, 0x04, 0x0a, 0x5e, 0x66,
+    0xe0, 0x01, 0x5d, 0x2e, 0x8d, 0xa1, 0x47, 0xa7, 0x20, 0xba, 0xbb, 0xc4, 0x97, 0x4d, 0xcf,
+    0x3f, 0xc3, 0x58, 0xa8, 0xb9, 0xbb, 0x23, 0x67, 0x25, 0x04, 0x66, 0x69, 0xde, 0x16, 0x96,
+    0xe4, 0x89, 0xaf, 0xd8, 0xa2, 0x75, 0x11, 0x8e, 0xa6, 0xba, 0x58, 0x2d, 0xed, 0x2c, 0x23,
+    0xd9, 0x0c, 0x4a, 0x83, 0xd7, 0xb9, 0xa8, 0x6e, 0xf5, 0x15, 0x84, 0x12, 0x48, 0xcf, 0xa7,
+    0xa5, 0x65, 0xc9, 0xaa, 0x23, 0x26, 0xf7, 0x63, 0x8f, 0x41, 0xd4, 0xd7, 0x44, 0x61, 0x18,
+    0x1c, 0xf2, 0x94, 0xe6, 0x6b, 0x4b, 0x7c, 0xa1, 0x59, 0x8f, 0x0a, 0xbd, 0x49, 0xe8, 0x2b,
+    0x99, 0xd4, 0x75, 0x59, 0x2e, 0xd8, 0xc7, 0x19, 0x22, 0x2f, 0xe7, 0x50, 0x5d, 0xdf, 0x4b,
+    0x76, 0x76, 0xfd, 0xd8, 0xc7, 0x45, 0x15, 0x12, 0x2e, 0xde, 0x6b, 0x39, 0xd4, 0xbe, 0x88,
+    0xd2, 0x9d, 0x2b, 0x6a, 0xf7, 0x21, 0x65, 0xc0, 0xe7, 0xad, 0x22, 0xa6, 0x4d, 0x3d, 0xf3,
+    0xba, 0xa6, 0x86, 0x3e, 0x37, 0x1f, 0xc2, 0xb1, 0x4a, 0xec, 0xd8, 0x92, 0x34, 0xd8, 0xa0,
+    0x7e, 0x75, 0x42, 0xfa, 0x73, 0x2c, 0x82, 0xde, 0x3e, 0x79, 0xf9, 0xaa, 0xcd, 0xe5, 0xc8,
+    0xb7, 0x8f, 0x00, 0xfe, 0xf1, 0xba, 0x0f, 0x4a, 0xa3, 0x66, 0x01, 0x49, 0x18, 0xf2, 0xe4,
+    0xe3, 0x34, 0xaa, 0x4b, 0x5e, 0x44, 0x0b, 0xb9, 0x32, 0xa6, 0xd4, 0x0a, 0x3d, 0x2a, 0x33,
+    0x43, 0xcd, 0xb5, 0xf6, 0x28, 0x1c, 0xf0, 0x4d, 0x26, 0x6b, 0x36, 0xd6, 0xc3, 0x24, 0x40,
+    0x0a, 0xe0, 0xf4, 0x3d, 0x6a, 0x22, 0x86, 0x29, 0x0c, 0x4d, 0xf8, 0x1a, 0x91, 0x4e, 0x05,
+    0x59, 0x96, 0x11, 0x73, 0x02, 0xb0, 0xe1, 0x80, 0xeb, 0x55, 0xcb, 0x75, 0xa0, 0x14, 0xd1,
+    0xcc, 0x6f, 0x9e, 0xd5, 0x6c, 0x60, 0x8c, 0x8e, 0x41, 0xaa, 0x5c, 0xe4, 0xab, 0x7d, 0xe1,
+    0x53, 0x41, 0x26, 0xd3, 0xb1, 0xba, 0x1a, 0x51, 0x7d, 0x00, 0x94, 0xae, 0x3e, 0x94, 0x02,
+    0x54, 0xe4, 0x54, 0x9e, 0xc7, 0x90, 0x69, 0xc6, 0x2d, 0xab, 0x8e, 0xa3, 0xd6, 0xb4, 0xb0,
+    0x85, 0x8e, 0x60, 0x78, 0x3c, 0x54, 0xe2, 0xaa, 0x98, 0x09, 0x19, 0x5f, 0xca, 0x85, 0x77,
+    0x8c, 0xe0, 0xe6, 0x9a, 0x6d, 0x6e, 0x05, 0x89, 0x23, 0x49, 0x57, 0x6b, 0xa8, 0x22, 0xa9,
+    0x49, 0x64, 0xd1, 0xfc, 0xd0, 0xb1, 0x23, 0xd0, 0xd5, 0xa5, 0x99, 0x5b, 0xaf, 0x06, 0xa5,
+    0x04, 0x1e, 0x86, 0x9b, 0x8a, 0x90, 0x6c, 0x67, 0xc5, 0x76, 0xd1, 0xb6, 0xd7, 0x04, 0x7b,
+    0x1a, 0xbd, 0x1c, 0xd1, 0xca, 0x31, 0x9e, 0xbd, 0xa9, 0x93, 0x5b, 0x24, 0xc3, 0xe6, 0x18,
+    0x3d, 0x88, 0xac, 0xe6, 0x8e, 0x48, 0x25, 0x11, 0xb1, 0xc6, 0x7e, 0xeb, 0x76, 0x35, 0x3c,
+    0xd2, 0x87, 0xa0, 0x68, 0xcd, 0x4b, 0x3b, 0x89, 0x74, 0xa7, 0x60, 0xab, 0xe6, 0xdb, 0x31,
+    0xce, 0xd1, 0xd5, 0x6a, 0xe4, 0x5a, 0x8d, 0xfe, 0xa7, 0x23, 0x45, 0x63, 0x02, 0xc6, 0x07,
+    0x57, 0x91, 0xb9, 0x1f, 0x85, 0x63, 0x47, 0x73, 0x24, 0x7f, 0x2b, 0x8c, 0x8f, 0x43, 0x53,
+    0xa3, 0xc3, 0x29, 0xc8, 0xca, 0x37, 0xb1, 0xaa, 0x8c, 0xdd, 0xad, 0x16, 0x44, 0xa9, 0xc5,
+    0xbb, 0xb5, 0xa9, 0xd3, 0x58, 0x78, 0x7e, 0x04, 0x99, 0x67, 0xd4, 0x1d, 0xaf, 0x24, 0x07,
+    0x25, 0x58, 0xfc, 0x9f, 0x95, 0x7a, 0x96, 0x93, 0x7b, 0x6b, 0x73, 0x68, 0xb1, 0x44, 0xaa,
+    0x9b, 0x57, 0x69, 0x8f, 0x00, 0x00, 0x3d, 0x85, 0x78, 0x94, 0x77, 0xda, 0x8c, 0x1f, 0xf1,
+    0xef, 0x78, 0x58, 0x0f, 0xe1, 0x93, 0xe6, 0x1f, 0xad, 0x5e, 0xb6, 0xf1, 0x45, 0xfd, 0xb9,
+    0x1f, 0x68, 0xb3, 0x0f, 0x8f, 0xe2, 0x89, 0xb0, 0x6a, 0xaf, 0x1e, 0xd6, 0x12, 0xe7, 0x8b,
+    0xbe, 0xe7, 0xa1, 0x6b, 0x3e, 0x0d, 0x22, 0x63, 0xa9, 0x78, 0x79, 0xd2, 0xce, 0xf4, 0x1c,
+    0xbc, 0x3d, 0x22, 0x9b, 0xd8, 0x8e, 0xc6, 0xa8, 0xe9, 0x9a, 0xd4, 0x77, 0x77, 0x0d, 0x63,
+    0x7f, 0x6e, 0x6c, 0xf5, 0x24, 0xe1, 0xa0, 0x94, 0x63, 0x77, 0xba, 0x9e, 0xe2, 0xb0, 0x20,
+    0xf8, 0x90, 0xd6, 0x8c, 0x0a, 0xc5, 0x72, 0xcf, 0xfd, 0xc6, 0x60, 0x41, 0xaf, 0x40, 0x9b,
+    0x49, 0xb3, 0xf1, 0x7e, 0x89, 0x6b, 0x73, 0x7d, 0x68, 0xd6, 0xf7, 0x0e, 0x81, 0xd1, 0x94,
+    0xe2, 0x48, 0x4f, 0xb1, 0xa2, 0x33, 0xb3, 0xd1, 0x97, 0x6e, 0x6e, 0x86, 0x55, 0xff, 0x00,
+    0x87, 0xf4, 0xdd, 0x4e, 0x32, 0xb7, 0x56, 0x91, 0xb1, 0x23, 0xef, 0x85, 0xc3, 0x0f, 0xc4,
+    0x57, 0x3d, 0xa3, 0x78, 0x15, 0xb4, 0xaf, 0x10, 0x8b, 0xd6, 0xb9, 0x12, 0x5b, 0xc5, 0x93,
+    0x10, 0xc7, 0xcd, 0x9f, 0x7a, 0xd0, 0x97, 0x56, 0x9f, 0xc2, 0xba, 0x8a, 0x69, 0x9a, 0xe4,
+    0x86, 0x58, 0x1c, 0x7e, 0xe2, 0xf7, 0x1d, 0x47, 0xa3, 0x0f, 0x5f, 0x7a, 0xe8, 0xe2, 0x92,
+    0x39, 0xe2, 0x59, 0x62, 0x75, 0x78, 0xd8, 0x65, 0x59, 0x4e, 0x41, 0x15, 0xa5, 0xa3, 0x27,
+    0x7e, 0xc4, 0xf9, 0x05, 0x3a, 0x97, 0x6d, 0x2e, 0x2a, 0xc6, 0x37, 0xb5, 0x25, 0x38, 0x8a,
+    0x28, 0x01, 0xb4, 0x01, 0x4b, 0x4b, 0x8a, 0x60, 0x20, 0xe2, 0x9c, 0x10, 0xb7, 0x41, 0x4d,
+    0xc1, 0x26, 0xaf, 0x59, 0xb2, 0x46, 0x72, 0xf4, 0x99, 0x49, 0x5c, 0xaf, 0x8d, 0xbc, 0x1a,
+    0x7c, 0x68, 0xd2, 0x30, 0x54, 0x52, 0xcc, 0xc7, 0x00, 0x0a, 0x59, 0xd9, 0x5a, 0x42, 0x56,
+    0xae, 0xe8, 0x93, 0x47, 0x06, 0xa1, 0x1c, 0x93, 0x7d, 0xdf, 0x7e, 0xde, 0xf5, 0x2d, 0xe9,
+    0x72, 0xd2, 0xbb, 0xb0, 0x5c, 0x69, 0x37, 0x76, 0xf0, 0xf9, 0xb2, 0x20, 0xc7, 0x7c, 0x1c,
+    0xe2, 0xb3, 0xca, 0x74, 0xae, 0xe3, 0x50, 0xbe, 0xb5, 0x8e, 0xcd, 0xc9, 0x91, 0x1c, 0x91,
+    0x80, 0xa0, 0xe7, 0x26, 0xb8, 0xc3, 0x8c, 0xd6, 0x70, 0x93, 0x92, 0xd4, 0xd2, 0xa4, 0x14,
+    0x5e, 0x84, 0x62, 0x3a, 0x95, 0x22, 0xe9, 0xc5, 0x5c, 0xb3, 0xb2, 0x6b, 0x87, 0xc0, 0x15,
+    0xbf, 0x6f, 0xa2, 0xc4, 0x10, 0x16, 0xe4, 0xd4, 0xce, 0x69, 0x04, 0x29, 0xb9, 0x6c, 0x61,
+    0xdb, 0x41, 0x92, 0x38, 0xae, 0x9f, 0x4f, 0xb6, 0x58, 0xa2, 0x0d, 0x8e, 0x4d, 0x42, 0x74,
+    0xc1, 0x19, 0x0c, 0x95, 0xa5, 0x18, 0xda, 0x8a, 0x3d, 0xab, 0x09, 0xce, 0xeb, 0x43, 0xa6,
+    0x9c, 0x39, 0x77, 0x1a, 0xf2, 0x08, 0xc7, 0xa9, 0xa8, 0x8b, 0x4e, 0xc3, 0x23, 0x23, 0xe9,
+    0x4e, 0x50, 0x1e, 0x56, 0x63, 0xc8, 0x15, 0x31, 0x3e, 0xa6, 0xb3, 0xd8, 0xd4, 0xa6, 0xb7,
+    0x4d, 0x1c, 0x9b, 0x65, 0xe8, 0x7b, 0xfa, 0x53, 0xef, 0x10, 0x4d, 0x63, 0x22, 0xf0, 0x41,
+    0x1c, 0x55, 0x7d, 0x4e, 0x44, 0x50, 0x0e, 0x46, 0xea, 0x8e, 0x0b, 0xa0, 0xd6, 0xac, 0xa4,
+    0xf6, 0xaa, 0xe5, 0xea, 0x4d, 0xfa, 0x1c, 0x8d, 0xea, 0xed, 0x66, 0x1e, 0x95, 0x91, 0x30,
+    0xe4, 0x56, 0xce, 0xa2, 0xdf, 0xbe, 0x63, 0xdb, 0x35, 0x8f, 0x2f, 0x3c, 0xd7, 0x5c, 0x76,
+    0x38, 0x27, 0xb9, 0x0d, 0x43, 0x72, 0xe2, 0x38, 0x98, 0xd4, 0xf5, 0x81, 0xe2, 0x9b, 0xff,
+    0x00, 0xb1, 0xe9, 0x72, 0xb0, 0x38, 0x62, 0x36, 0x2f, 0xd4, 0xd5, 0xed, 0xab, 0x31, 0x7b,
+    0x1c, 0xaa, 0xc8, 0x75, 0x4d, 0x72, 0xe2, 0x7e, 0xb1, 0xc6, 0x76, 0xa9, 0xa6, 0xdf, 0xde,
+    0x35, 0xb9, 0x28, 0x8d, 0x8c, 0x75, 0xf7, 0xab, 0x1a, 0x55, 0xbf, 0xd8, 0xb4, 0xb0, 0xee,
+    0x3e, 0x67, 0x1b, 0xda, 0xb0, 0xae, 0xe6, 0x32, 0x4c, 0xee, 0x7b, 0x54, 0x4a, 0x4e, 0x30,
+    0xf3, 0x66, 0x71, 0x5c, 0xd2, 0xf2, 0x46, 0x7c, 0x92, 0xcb, 0x3c, 0x84, 0x92, 0x79, 0x3d,
+    0x2a, 0x36, 0x66, 0x3c, 0x1c, 0x92, 0x3d, 0x69, 0x77, 0x10, 0xd9, 0x14, 0x16, 0x25, 0xb2,
+    0x7a, 0xd7, 0x0b, 0x77, 0x3a, 0x44, 0x8c, 0x65, 0xc5, 0x68, 0xda, 0x40, 0x67, 0x9c, 0x2e,
+    0x3e, 0x51, 0xc9, 0xaa, 0x70, 0x0f, 0x99, 0xab, 0xa3, 0xd1, 0xe2, 0x5f, 0xb2, 0x33, 0x63,
+    0x96, 0x6a, 0xda, 0x84, 0x39, 0x99, 0x9d, 0x49, 0x72, 0xab, 0x96, 0xbc, 0x9d, 0xb3, 0xc6,
+    0xdd, 0x95, 0x2b, 0x3b, 0x96, 0x76, 0x63, 0xdc, 0xd6, 0xcc, 0xdc, 0x44, 0xe7, 0xfd, 0x93,
+    0x58, 0xea, 0x2b, 0xb6, 0x4b, 0x54, 0x63, 0x49, 0xdd, 0x5c, 0x7a, 0x8c, 0xb0, 0x15, 0x68,
+    0xd5, 0x78, 0x87, 0xef, 0x05, 0x58, 0x6a, 0xa1, 0xcf, 0x73, 0x17, 0x55, 0xe6, 0xe9, 0x4f,
+    0xfb, 0x35, 0xa3, 0x61, 0xf3, 0x6d, 0x3e, 0xd5, 0x42, 0xff, 0x00, 0xe6, 0x60, 0xde, 0xe6,
+    0xaf, 0x69, 0x47, 0x31, 0x67, 0xda, 0xb0, 0x87, 0xf1, 0x19, 0x72, 0xd2, 0x06, 0x6e, 0xbb,
+    0xff, 0x00, 0x1f, 0x03, 0xfc, 0xf6, 0xaa, 0x96, 0x10, 0xf9, 0xb7, 0x08, 0xbe, 0xa6, 0xad,
+    0xeb, 0xa7, 0xfd, 0x24, 0x0a, 0x93, 0x45, 0x8b, 0x37, 0x05, 0x88, 0xe1, 0x16, 0xb0, 0x71,
+    0xe6, 0xad, 0x62, 0x93, 0xb4, 0x2e, 0x6c, 0x4a, 0x71, 0x1b, 0x63, 0xd2, 0xb0, 0x15, 0x7c,
+    0xed, 0x41, 0x47, 0x62, 0xd5, 0xbb, 0x72, 0xdb, 0x6d, 0xdd, 0xbd, 0xab, 0x1b, 0x4e, 0x4d,
+    0xd7, 0xe8, 0x4f, 0xb9, 0xad, 0xea, 0xeb, 0x28, 0xa3, 0x3a, 0x7a, 0x45, 0xb3, 0x62, 0x63,
+    0x84, 0x00, 0x77, 0xa4, 0x84, 0xfe, 0xf0, 0x0f, 0x4a, 0x73, 0x8f, 0xde, 0x13, 0xd7, 0x68,
+    0xe3, 0xeb, 0x4d, 0x8b, 0xe5, 0x25, 0x8f, 0x40, 0x32, 0x4d, 0x6e, 0x4f, 0xd9, 0x35, 0x52,
+    0xe4, 0x46, 0x12, 0x30, 0x7e, 0x66, 0xfd, 0x2b, 0xd6, 0x7e, 0x18, 0x5d, 0xe2, 0xde, 0xe6,
+    0x12, 0x7e, 0xe3, 0xa4, 0x80, 0x7e, 0x87, 0xf9, 0x0a, 0xf1, 0x1b, 0x39, 0x5a, 0x7b, 0xcf,
+    0x30, 0xf7, 0xe9, 0xec, 0x2b, 0xd7, 0x3e, 0x1b, 0xcb, 0xb3, 0x51, 0x96, 0x3f, 0xef, 0xc2,
+    0x7f, 0x30, 0x47, 0xff, 0x00, 0x5e, 0xb3, 0xab, 0xef, 0x53, 0x65, 0xe1, 0x57, 0x25, 0x64,
+    0x8f, 0x66, 0xb9, 0x50, 0xf6, 0xb2, 0x03, 0xfd, 0xd2, 0x7f, 0x2e, 0x6b, 0xc1, 0xfc, 0x7b,
+    0xa7, 0xff, 0x00, 0xc5, 0x47, 0x71, 0xe5, 0xaf, 0x12, 0x05, 0x7f, 0xd3, 0x9f, 0xd7, 0x35,
+    0xef, 0x63, 0xe6, 0x41, 0x9e, 0xe2, 0xbc, 0xc3, 0xc6, 0x56, 0xc8, 0xd7, 0x11, 0xcb, 0xb4,
+    0x6e, 0x31, 0xe3, 0x3f, 0x42, 0x6b, 0x93, 0x0d, 0x2b, 0x4c, 0xe9, 0x94, 0x39, 0xe9, 0x38,
+    0xf6, 0x67, 0x91, 0x8d, 0x2e, 0x38, 0x9b, 0x91, 0x93, 0xde, 0xa5, 0x74, 0x0a, 0x9b, 0x47,
+    0x15, 0xaf, 0x73, 0x16, 0xc2, 0x49, 0xac, 0xa9, 0x88, 0xaf, 0x44, 0xf3, 0xa7, 0x1b, 0x15,
+    0x9d, 0xb6, 0x29, 0x35, 0x4a, 0x49, 0x29, 0xf7, 0x13, 0x65, 0xb0, 0x0f, 0x02, 0xa8, 0x4b,
+    0x28, 0x5e, 0xa7, 0x9a, 0x4d, 0xd8, 0x51, 0x85, 0xc7, 0x31, 0x2c, 0x70, 0x29, 0xfb, 0xa3,
+    0xb6, 0x42, 0xec, 0x46, 0xec, 0x72, 0x4f, 0x6a, 0x8e, 0x30, 0x42, 0x19, 0x1f, 0x81, 0x54,
+    0x66, 0x77, 0xbb, 0x93, 0x6a, 0xe7, 0xcb, 0x07, 0x8f, 0x7a, 0x89, 0x4a, 0xde, 0xa6, 0xaa,
+    0x37, 0xd3, 0xa1, 0x05, 0xd5, 0xc4, 0x97, 0x92, 0x63, 0x90, 0x83, 0xa0, 0xa6, 0x2c, 0x42,
+    0x3e, 0x07, 0x5f, 0x5a, 0xb2, 0xf0, 0x34, 0x4a, 0x06, 0xdc, 0x03, 0x53, 0x43, 0x69, 0x85,
+    0xf3, 0x25, 0x1c, 0x76, 0xac, 0x79, 0x1b, 0x7a, 0x9b, 0x5d, 0x45, 0x14, 0xc2, 0xfa, 0xd4,
+    0x53, 0xcf, 0xe5, 0xc6, 0x76, 0xf5, 0xa9, 0x6e, 0xa4, 0x4f, 0x30, 0xf9, 0x7c, 0x28, 0xeb,
+    0x59, 0x53, 0xcb, 0xe6, 0x36, 0x07, 0xdd, 0x15, 0x95, 0x49, 0x72, 0xe8, 0x8a, 0x5a, 0x93,
+    0xf9, 0xe0, 0xaf, 0x27, 0x26, 0xa1, 0x0d, 0x96, 0xe2, 0x99, 0x14, 0x4f, 0x33, 0x84, 0x45,
+    0x24, 0x9a, 0xdf, 0xb1, 0xd2, 0xd2, 0x1c, 0x3c, 0x98, 0x66, 0xfe, 0x55, 0x10, 0x8c, 0xaa,
+    0x6c, 0x12, 0x92, 0x8e, 0xe3, 0xb4, 0xbb, 0x17, 0x93, 0x0f, 0x2e, 0x55, 0x3d, 0x3b, 0x9a,
+    0xed, 0xf4, 0x2b, 0xc7, 0xd3, 0xee, 0xe2, 0x96, 0x0e, 0x3c, 0xb6, 0x0c, 0x0f, 0xb8, 0xac,
+    0x08, 0x80, 0xc6, 0x08, 0xad, 0x3b, 0x47, 0xc6, 0x3d, 0x2b, 0xb5, 0x45, 0x25, 0x63, 0x95,
+    0x54, 0x6e, 0x77, 0x3d, 0xfa, 0x09, 0x61, 0xd4, 0xf4, 0xe4, 0x94, 0x00, 0xd0, 0xcf, 0x1f,
+    0x2a, 0x7d, 0x08, 0xe4, 0x1a, 0xf2, 0xed, 0x42, 0xc1, 0xec, 0x6f, 0xa7, 0xb5, 0x23, 0x94,
+    0x72, 0x01, 0x23, 0xa8, 0xec, 0x7f, 0x2a, 0xe9, 0xfc, 0x03, 0xa9, 0x99, 0xec, 0x25, 0xb0,
+    0x66, 0xcb, 0x42, 0x77, 0xa7, 0xfb, 0xa7, 0xaf, 0xe4, 0x7f, 0x9d, 0x3f, 0xc5, 0x76, 0x45,
+    0x2e, 0xa1, 0xbc, 0x45, 0xff, 0x00, 0x58, 0xbb, 0x1b, 0x8e, 0xe3, 0xa7, 0xe9, 0xfc, 0xab,
+    0x96, 0x1e, 0xe4, 0xdc, 0x4f, 0x62, 0xa5, 0xaa, 0xd2, 0x53, 0x23, 0xf0, 0x25, 0xa0, 0x3a,
+    0xba, 0xc8, 0xcb, 0x92, 0xab, 0x91, 0xf5, 0x24, 0x0f, 0xf1, 0xaf, 0x51, 0xba, 0x98, 0x43,
+    0x03, 0x37, 0x73, 0xc0, 0xae, 0x13, 0xc0, 0x10, 0xe6, 0xea, 0x77, 0xfe, 0xe2, 0xaf, 0xf5,
+    0xff, 0x00, 0xeb, 0x57, 0x55, 0xa9, 0x4a, 0x64, 0x9c, 0x44, 0x3a, 0x2f, 0xf3, 0xac, 0x6b,
+    0x3b, 0xcc, 0x88, 0x43, 0x99, 0xc5, 0x19, 0x5a, 0xb5, 0xf7, 0xf6, 0x6e, 0x85, 0x7b, 0x78,
+    0x4e, 0x1c, 0xa6, 0xc4, 0xfa, 0x9e, 0x2b, 0xe7, 0xfd, 0x56, 0xe3, 0xcc, 0x99, 0xce, 0x73,
+    0x5e, 0x9b, 0xf1, 0x1f, 0x5a, 0x55, 0x48, 0x74, 0xc8, 0x9c, 0x1d, 0x9f, 0x3c, 0x98, 0xf5,
+    0xed, 0xfd, 0x7f, 0x4a, 0xf2, 0x0b, 0xe9, 0xb2, 0x4f, 0x35, 0xd3, 0x87, 0x85, 0xa3, 0x77,
+    0xd4, 0xe5, 0xc6, 0xd4, 0xe6, 0x9f, 0x2a, 0x31, 0x35, 0x49, 0x7e, 0x5d, 0xb9, 0xea, 0x6b,
+    0x15, 0xea, 0xf5, 0xfc, 0xbb, 0xe5, 0xeb, 0xc5, 0x51, 0x0a, 0x5d, 0xc0, 0x1d, 0xeb, 0x2a,
+    0xae, 0xf2, 0x14, 0x15, 0x91, 0x35, 0x9c, 0x06, 0x49, 0x41, 0xed, 0x9a, 0xe8, 0x15, 0x42,
+    0x80, 0x07, 0x4a, 0xa7, 0x63, 0x00, 0x55, 0xce, 0x3d, 0x85, 0x5a, 0x7f, 0x41, 0xd4, 0xd6,
+    0xf4, 0xa3, 0xcb, 0x13, 0x39, 0xbb, 0xbb, 0x0e, 0x07, 0x71, 0xe3, 0xa0, 0xaa, 0x77, 0x93,
+    0x63, 0x81, 0xdb, 0xf9, 0xd5, 0xcd, 0x8c, 0xb1, 0x9c, 0x63, 0xda, 0xb1, 0xe6, 0x62, 0xee,
+    0x7d, 0xaa, 0xa6, 0xec, 0x85, 0x04, 0x9b, 0xb9, 0x4e, 0xe8, 0x7c, 0xa1, 0xfb, 0x83, 0x4e,
+    0x53, 0xb9, 0x05, 0x3e, 0x64, 0xdd, 0x0b, 0x0f, 0x6a, 0x86, 0xdd, 0xb2, 0x98, 0xf4, 0xae,
+    0x4d, 0xa4, 0x6c, 0x41, 0x28, 0xc3, 0x9a, 0x7b, 0x7c, 0xd1, 0x67, 0xda, 0x8b, 0x85, 0xe7,
+    0x34, 0x45, 0xcc, 0x78, 0xf4, 0xa8, 0xb6, 0xad, 0x0c, 0x8e, 0x31, 0x96, 0xc5, 0x4c, 0xab,
+    0x92, 0x00, 0xef, 0x51, 0x27, 0x12, 0xe2, 0xaf, 0xdb, 0x45, 0xc9, 0x73, 0xda, 0x88, 0x2b,
+    0x83, 0x76, 0x24, 0xdb, 0xe5, 0xc6, 0x14, 0x54, 0x6c, 0x30, 0xb8, 0xcf, 0x26, 0xa5, 0x62,
+    0x39, 0x35, 0x11, 0xf9, 0x54, 0xb9, 0xae, 0x86, 0x42, 0x65, 0x1b, 0x83, 0xfb, 0xc2, 0x3d,
+    0x2a, 0x1a, 0x56, 0x3b, 0x98, 0x93, 0xde, 0x92, 0xb9, 0x1b, 0xbb, 0x34, 0x0a, 0x51, 0x49,
+    0x4e, 0x1d, 0x69, 0x00, 0xee, 0x83, 0x14, 0xc2, 0x68, 0x26, 0x92, 0x9b, 0x60, 0x14, 0x51,
+    0x45, 0x20, 0x0a, 0x28, 0xa2, 0x80, 0x0a, 0x5c, 0x50, 0x05, 0x3c, 0x0a, 0x76, 0x01, 0xb8,
+    0xa0, 0xf1, 0x4e, 0xc5, 0x37, 0x14, 0x01, 0xe8, 0x31, 0x5d, 0x92, 0x30, 0x4d, 0x48, 0xef,
+    0xb9, 0x6b, 0x2a, 0x09, 0x52, 0x4c, 0x34, 0x6c, 0x18, 0x7b, 0x56, 0x8a, 0x9c, 0xa5, 0x7a,
+    0x88, 0xe0, 0x9a, 0xb1, 0x6e, 0xce, 0x4d, 0xc0, 0xa9, 0xe6, 0xb9, 0xcb, 0xeb, 0x3f, 0xec,
+    0xed, 0x49, 0xa0, 0xe4, 0x5b, 0x5c, 0x7c, 0xd1, 0x1f, 0xee, 0xb7, 0xa5, 0x6e, 0xd9, 0x1f,
+    0xde, 0x11, 0x52, 0x6b, 0x36, 0x1f, 0xda, 0x3a, 0x7b, 0xc6, 0x38, 0x95, 0x7e, 0x68, 0xcf,
+    0xa3, 0x0a, 0x89, 0xae, 0xc5, 0xd3, 0x76, 0x38, 0x7b, 0x65, 0x91, 0x7c, 0x41, 0x16, 0xff,
+    0x00, 0xbf, 0xe7, 0x82, 0x7f, 0x3a, 0xf4, 0x97, 0x01, 0xd0, 0xab, 0x0c, 0x83, 0xc1, 0x15,
+    0xe7, 0xf0, 0x3a, 0xc9, 0xa8, 0xd8, 0x5c, 0x38, 0xda, 0xc2, 0x50, 0x92, 0xfb, 0x10, 0x6b,
+    0xd0, 0xbe, 0x95, 0x9d, 0x35, 0x6b, 0x9a, 0xcc, 0xe0, 0x2e, 0x61, 0x7d, 0x2f, 0x53, 0x96,
+    0xcc, 0x1d, 0xa3, 0x77, 0x9b, 0x6e, 0xde, 0x9d, 0xc5, 0x76, 0xfa, 0x75, 0xda, 0xde, 0xd8,
+    0xc5, 0x70, 0x9f, 0xc4, 0x39, 0x1e, 0x87, 0xb8, 0xac, 0x6f, 0x15, 0xe9, 0xe6, 0x6b, 0x15,
+    0xbc, 0x88, 0x7e, 0xf6, 0xdc, 0xe7, 0x23, 0xfb, 0xb5, 0x5b, 0xc3, 0x3a, 0x80, 0x5b, 0xa3,
+    0x6e, 0x4f, 0xee, 0xee, 0x07, 0x99, 0x1f, 0xb3, 0x0e, 0xa2, 0x9c, 0x7d, 0xd9, 0x58, 0x1e,
+    0xaa, 0xe7, 0x54, 0xfd, 0x2b, 0x85, 0xd1, 0x86, 0xcf, 0x12, 0xca, 0xbe, 0x92, 0x48, 0x3f,
+    0x9d, 0x77, 0x24, 0x12, 0x6b, 0x86, 0xb3, 0xfd, 0xdf, 0x8b, 0x26, 0x1e, 0x93, 0x3f, 0xf5,
+    0xa7, 0x3d, 0xe3, 0xea, 0x4a, 0xd9, 0x9b, 0x9e, 0x15, 0xff, 0x00, 0x8f, 0xcb, 0xc3, 0xf4,
+    0xfe, 0x66, 0xbb, 0x8b, 0x43, 0x96, 0x15, 0xc2, 0xf8, 0x5c, 0xe2, 0xfa, 0xf1, 0x7d, 0x87,
+    0xf3, 0x35, 0xdb, 0xda, 0x1c, 0x30, 0xa3, 0xa1, 0xa4, 0x7e, 0x23, 0xbf, 0xf0, 0x8c, 0x9b,
+    0x35, 0x08, 0xab, 0x53, 0xc4, 0xd9, 0x5d, 0x53, 0x3d, 0xb6, 0xd7, 0x33, 0xa2, 0x5c, 0x7d,
+    0x9e, 0xe2, 0x37, 0xcf, 0x00, 0x8c, 0xd7, 0x5f, 0xe2, 0x18, 0x7e, 0xd3, 0x6d, 0x0d, 0xda,
+    0x73, 0xc7, 0x38, 0xae, 0x59, 0x69, 0x33, 0xbe, 0x3b, 0x19, 0x9a, 0x45, 0xb2, 0x5e, 0x3c,
+    0xa8, 0x46, 0x4e, 0x38, 0xaa, 0xf2, 0x69, 0x77, 0x69, 0x33, 0x28, 0x88, 0x9c, 0x1e, 0xb5,
+    0x1d, 0xb5, 0xd4, 0xb6, 0x33, 0x89, 0x62, 0x3f, 0x87, 0xad, 0x6c, 0x2f, 0x8b, 0xd9, 0x71,
+    0xe6, 0x42, 0x0b, 0x7a, 0xf1, 0x43, 0xe6, 0xbe, 0x83, 0xba, 0xb1, 0xab, 0xa1, 0xd9, 0x36,
+    0x9b, 0x65, 0x24, 0xf3, 0xfc, 0xac, 0x47, 0x7a, 0xf3, 0xdf, 0x11, 0xcc, 0x2e, 0xb5, 0x09,
+    0x58, 0x1c, 0xa8, 0x38, 0x15, 0xb9, 0xac, 0x78, 0xb9, 0xee, 0x61, 0x31, 0xc7, 0xf2, 0x82,
+    0x30, 0x6b, 0x88, 0xbb, 0xba, 0x2e, 0x49, 0x35, 0xa5, 0x28, 0x3b, 0xdd, 0x98, 0xd4, 0x92,
+    0xb5, 0x8c, 0xf9, 0xe3, 0x52, 0x6a, 0x94, 0xc1, 0x22, 0x8d, 0xe4, 0x73, 0x85, 0x45, 0x2c,
+    0x49, 0xec, 0x2a, 0xd4, 0x8c, 0x4f, 0x7a, 0xc0, 0xf1, 0x45, 0xc3, 0x43, 0xa3, 0x3c, 0x71,
+    0xff, 0x00, 0xac, 0xb8, 0x61, 0x12, 0xe3, 0xdf, 0xaf, 0xe9, 0x5d, 0x57, 0xb2, 0xb9, 0xc6,
+    0xd2, 0x6c, 0xc7, 0xd0, 0xed, 0xdb, 0x57, 0xd5, 0x67, 0xd6, 0xae, 0x47, 0xee, 0xd5, 0x8a,
+    0xc0, 0xa7, 0xb6, 0x3f, 0xc2, 0xb6, 0xaf, 0xee, 0xca, 0x21, 0x09, 0xf7, 0x8f, 0x4a, 0x92,
+    0x0b, 0x78, 0xf4, 0xcd, 0x2a, 0x18, 0x17, 0xa2, 0x2e, 0x0f, 0xb9, 0xef, 0x58, 0xf2, 0xc8,
+    0x65, 0x90, 0xb1, 0xef, 0x4e, 0x11, 0xb2, 0x32, 0x9b, 0xbb, 0x32, 0xee, 0xc3, 0x92, 0x43,
+    0x1c, 0xb1, 0xe6, 0xa8, 0x5c, 0x4c, 0x2d, 0xa2, 0xe3, 0x97, 0x6e, 0x82, 0xae, 0x5c, 0x49,
+    0xf3, 0x3b, 0xb1, 0xe0, 0x7f, 0x2a, 0x6f, 0x87, 0xac, 0x3f, 0xb5, 0x35, 0x06, 0xbd, 0x9d,
+    0x7f, 0x71, 0x09, 0xf9, 0x41, 0xe8, 0x4f, 0x6a, 0xce, 0xa3, 0xbb, 0xb2, 0xdd, 0x9b, 0xad,
+    0x23, 0x76, 0x6b, 0x78, 0x7f, 0x49, 0x16, 0x30, 0x7d, 0xb6, 0xe8, 0x6e, 0xb9, 0x93, 0x95,
+    0x07, 0xf8, 0x45, 0x4b, 0xa8, 0xea, 0x5e, 0x50, 0x63, 0xbb, 0xe6, 0xe9, 0x81, 0x53, 0xea,
+    0x37, 0xa2, 0x25, 0x38, 0x3c, 0xf6, 0xf6, 0xae, 0x56, 0x79, 0x1e, 0x69, 0x4b, 0x39, 0xef,
+    0x56, 0xda, 0xa7, 0x1b, 0x23, 0x18, 0xc5, 0xd4, 0x7c, 0xcf, 0x61, 0xd3, 0x5c, 0xbc, 0xe7,
+    0x24, 0xf1, 0xde, 0xa2, 0xda, 0xd2, 0x1e, 0x7a, 0x54, 0xab, 0x1e, 0xe0, 0x38, 0xc0, 0xa9,
+    0x55, 0x42, 0x8e, 0x2b, 0x3b, 0x37, 0xab, 0x37, 0xd8, 0xae, 0xc0, 0x47, 0xc6, 0x39, 0xa0,
+    0x8c, 0x2e, 0xe6, 0xfc, 0x05, 0x3c, 0x47, 0xf3, 0x6e, 0x63, 0x9a, 0x63, 0x83, 0x23, 0xe0,
+    0x74, 0xa9, 0x60, 0x36, 0x24, 0x32, 0x36, 0x4f, 0x4a, 0x9a, 0x79, 0x92, 0xda, 0x2d, 0xed,
+    0xf8, 0x0f, 0x5a, 0x19, 0xe3, 0xb6, 0x84, 0xb3, 0x9e, 0x07, 0xe6, 0x6b, 0x12, 0xe2, 0xe1,
+    0xee, 0x25, 0x2e, 0xe7, 0xe8, 0x3d, 0x05, 0x4c, 0xe7, 0xec, 0xd7, 0x98, 0xd2, 0xb8, 0xd9,
+    0x65, 0x69, 0xa4, 0x2e, 0xe7, 0x93, 0x56, 0x6d, 0x8f, 0x96, 0x08, 0xf5, 0x15, 0x51, 0x7e,
+    0xf5, 0x48, 0xd2, 0x1e, 0xa2, 0xb9, 0xa2, 0xf5, 0xb9, 0x42, 0x83, 0x99, 0x73, 0x56, 0x3b,
+    0x55, 0x55, 0x3f, 0x30, 0xab, 0x19, 0xaa, 0x4c, 0x05, 0x07, 0x15, 0x7a, 0xd2, 0x4c, 0xa9,
+    0x5f, 0xc4, 0x56, 0x78, 0xa9, 0x23, 0x73, 0x1b, 0x86, 0x15, 0x70, 0x95, 0x98, 0x99, 0x6a,
+    0xe6, 0xd7, 0x7f, 0xce, 0x9f, 0x7a, 0xa9, 0xe7, 0x3c, 0x30, 0xc3, 0x56, 0xb2, 0x38, 0x91,
+    0x03, 0x2f, 0x43, 0x50, 0x4f, 0x6a, 0xb2, 0x8c, 0x8e, 0x1b, 0xd6, 0xb4, 0x94, 0x2f, 0xaa,
+    0x12, 0x65, 0x78, 0x66, 0xc7, 0xca, 0xdd, 0x3b, 0x1a, 0xb6, 0x8f, 0x8e, 0x0d, 0x66, 0x38,
+    0x68, 0x9b, 0x6c, 0x80, 0x8f, 0x7a, 0x9a, 0x29, 0x8a, 0xf0, 0x79, 0x5f, 0xe5, 0x53, 0x19,
+    0xdb, 0x46, 0x36, 0x8d, 0x25, 0x03, 0xa8, 0xe9, 0x46, 0x01, 0xec, 0x2a, 0x14, 0x93, 0x8c,
+    0x83, 0x91, 0x53, 0x03, 0x91, 0x91, 0x5b, 0x27, 0x72, 0x6c, 0x35, 0xa2, 0x46, 0xed, 0xf9,
+    0x55, 0x3f, 0x35, 0x8d, 0xc9, 0x8a, 0x20, 0x49, 0xce, 0xd0, 0x73, 0xd4, 0xd6, 0x82, 0x8e,
+    0x6a, 0x2d, 0x3e, 0x3b, 0x44, 0xd7, 0x04, 0x17, 0xe0, 0x7d, 0x96, 0xe3, 0x82, 0xdf, 0xdd,
+    0x3d, 0x8e, 0x7e, 0xb5, 0x33, 0x5b, 0x58, 0x2e, 0x24, 0x8d, 0x71, 0x6d, 0x81, 0x71, 0x03,
+    0xa8, 0x3d, 0x09, 0x18, 0xa4, 0x71, 0x15, 0xdc, 0x45, 0x43, 0x0c, 0xf5, 0x1e, 0xa2, 0xba,
+    0x0d, 0x53, 0xc1, 0xda, 0x8c, 0x50, 0x95, 0xd3, 0xae, 0xda, 0xe2, 0xdb, 0xaf, 0x91, 0x23,
+    0x60, 0xfe, 0x07, 0xa1, 0xae, 0x66, 0xe2, 0xda, 0x38, 0x4f, 0x95, 0x3c, 0x57, 0x16, 0x37,
+    0x4b, 0xff, 0x00, 0x3d, 0x32, 0x55, 0xbf, 0xc2, 0x94, 0x93, 0x5a, 0x3d, 0x81, 0x31, 0x2d,
+    0x6d, 0xae, 0x2f, 0x62, 0x62, 0xb2, 0xdb, 0xfe, 0xec, 0xed, 0x3e, 0x63, 0x6d, 0x3f, 0x5a,
+    0x99, 0x74, 0x5d, 0x46, 0x4c, 0x98, 0x52, 0x29, 0x57, 0x3f, 0x7a, 0x39, 0x01, 0x14, 0xba,
+    0x06, 0x99, 0x0d, 0xf5, 0xe4, 0xb1, 0x5c, 0xab, 0x14, 0x55, 0xdd, 0xf2, 0x9e, 0x33, 0x9f,
+    0x5f, 0xce, 0xb6, 0xa7, 0xf0, 0xe4, 0xb6, 0x8c, 0x67, 0xd2, 0x6e, 0x5e, 0x27, 0x1c, 0xf9,
+    0x64, 0xf0, 0x6a, 0x63, 0x4d, 0xca, 0x3c, 0xcd, 0x0a, 0x53, 0xb3, 0xb5, 0xcc, 0xd8, 0xb4,
+    0x1d, 0x69, 0xba, 0x42, 0xaa, 0x3d, 0x4b, 0x8a, 0xb9, 0x17, 0x85, 0x6f, 0x65, 0x23, 0xed,
+    0x57, 0xaa, 0x8b, 0xdd, 0x63, 0x19, 0x35, 0x69, 0x6e, 0xbc, 0x4d, 0x22, 0x2a, 0x47, 0x6d,
+    0x04, 0x2c, 0x38, 0x2e, 0x48, 0xe6, 0x8f, 0xec, 0xcf, 0x11, 0x5c, 0x1c, 0xcb, 0xaa, 0xa4,
+    0x79, 0xec, 0x9f, 0xfd, 0x61, 0x5a, 0x28, 0xae, 0xcd, 0x91, 0xcc, 0xfb, 0xa3, 0x4b, 0x4d,
+    0xf0, 0xfe, 0x9f, 0x60, 0xc2, 0x45, 0x8f, 0xcc, 0x94, 0x7f, 0x1c, 0x9c, 0x9a, 0xeb, 0xb4,
+    0xfd, 0x79, 0xf4, 0xf4, 0xc4, 0xec, 0x0d, 0xba, 0x8e, 0x77, 0x1f, 0xba, 0x3e, 0xb5, 0xc0,
+    0x1f, 0x0c, 0xdf, 0x49, 0xfe, 0xb3, 0x58, 0x98, 0xb7, 0xb6, 0x7f, 0xc6, 0x9d, 0x07, 0x84,
+    0xd0, 0xb6, 0x2e, 0xef, 0xe7, 0x9a, 0x3f, 0xee, 0x64, 0x8a, 0xbb, 0x3b, 0x59, 0x44, 0x95,
+    0x2b, 0x3b, 0xf3, 0x1d, 0x05, 0x85, 0xd4, 0x9f, 0x10, 0x7c, 0x5f, 0x11, 0xbc, 0x8c, 0xae,
+    0x83, 0x13, 0x94, 0x48, 0xc8, 0xe5, 0xff, 0x00, 0xda, 0xfa, 0xf7, 0xae, 0x9f, 0x53, 0xf0,
+    0x0d, 0xcf, 0x87, 0x37, 0x5e, 0x78, 0x66, 0xec, 0xcd, 0x68, 0x7e, 0x66, 0xb5, 0x91, 0xb7,
+    0x0f, 0xfe, 0xb7, 0xd4, 0x7e, 0x55, 0xc0, 0xc5, 0xe1, 0x9f, 0x20, 0xff, 0x00, 0xa1, 0xea,
+    0x77, 0xb6, 0xeb, 0xfd, 0xd4, 0x7a, 0xd0, 0xb1, 0xd0, 0x2f, 0xda, 0x5d, 0xb1, 0x6b, 0xda,
+    0x92, 0xb3, 0x71, 0x9f, 0x3b, 0x00, 0xd4, 0xa8, 0xce, 0x2e, 0xe5, 0xf3, 0xc5, 0xe8, 0x6e,
+    0x69, 0x1e, 0x24, 0xb2, 0xd5, 0x9d, 0xa0, 0xcf, 0x93, 0x78, 0x87, 0x6b, 0xc0, 0xe7, 0x90,
+    0x47, 0x5c, 0x7a, 0xd6, 0xc6, 0x2b, 0x36, 0xcf, 0xe1, 0xb6, 0x9f, 0x25, 0xb9, 0x5b, 0xab,
+    0xb9, 0x85, 0xd3, 0x36, 0xe5, 0xb9, 0x43, 0x96, 0x56, 0xf5, 0xf7, 0xa7, 0xcb, 0x67, 0xae,
+    0x78, 0x60, 0xac, 0x5a, 0xca, 0x1b, 0xcb, 0x22, 0x71, 0x1e, 0xa1, 0x6e, 0xb9, 0x18, 0xed,
+    0xbc, 0x76, 0xad, 0x23, 0x2b, 0xe8, 0xca, 0xb3, 0x4a, 0xec, 0xbf, 0x8a, 0x4c, 0x53, 0xa3,
+    0x64, 0x91, 0x03, 0xa3, 0x06, 0x53, 0xd0, 0x8a, 0x5c, 0x55, 0x8c, 0x60, 0x5a, 0x7e, 0xca,
+    0x70, 0x5c, 0x50, 0x68, 0x1a, 0x1b, 0x8e, 0x94, 0x12, 0x05, 0x04, 0xd2, 0x01, 0x93, 0x40,
+    0x00, 0x39, 0xa7, 0x2b, 0x95, 0xfc, 0x69, 0x3a, 0x50, 0x08, 0xe8, 0x45, 0x03, 0x1c, 0x24,
+    0x24, 0xf7, 0xcd, 0x38, 0x36, 0x0e, 0x6a, 0x32, 0x47, 0x6a, 0x6e, 0xef, 0xce, 0xa4, 0x77,
+    0x35, 0xec, 0xf5, 0x13, 0x6e, 0xbf, 0x2e, 0x32, 0x6b, 0x42, 0x3d, 0x6a, 0x4c, 0xd7, 0x34,
+    0x1b, 0x9a, 0x9d, 0x25, 0xac, 0xa5, 0x04, 0x6b, 0x1a, 0x8d, 0x1d, 0x9d, 0xa6, 0xa6, 0x26,
+    0x21, 0x5b, 0xad, 0x68, 0xe7, 0xbd, 0x71, 0x10, 0x5c, 0x14, 0x60, 0x41, 0xae, 0x9e, 0xc6,
+    0xf0, 0x4b, 0x6f, 0x82, 0x72, 0x40, 0xae, 0x79, 0xc2, 0xdb, 0x1d, 0x34, 0xe7, 0xcd, 0xb9,
+    0x24, 0x13, 0xa8, 0x95, 0x94, 0x9a, 0xa5, 0xa9, 0x5d, 0xba, 0x49, 0xf2, 0x92, 0x05, 0x52,
+    0xba, 0xb9, 0x30, 0xdc, 0x92, 0x0d, 0x45, 0x2d, 0xec, 0x73, 0x2f, 0xcc, 0x79, 0xa6, 0xa3,
+    0xd4, 0x52, 0x9e, 0x96, 0x20, 0x96, 0xea, 0x49, 0x9b, 0x9e, 0x6a, 0x75, 0x9b, 0xc9, 0xb7,
+    0x39, 0xeb, 0x55, 0x5a, 0xe2, 0x18, 0xf9, 0x1d, 0x6a, 0x85, 0xcd, 0xe9, 0x97, 0x81, 0xd2,
+    0xb4, 0x51, 0xb9, 0x93, 0x95, 0x88, 0x2e, 0xe5, 0x2e, 0xed, 0xcf, 0x5a, 0xa1, 0x27, 0x5a,
+    0x99, 0xdf, 0x71, 0xa8, 0x18, 0xe4, 0xd6, 0xc9, 0x58, 0xe7, 0x90, 0xc3, 0xc0, 0xcd, 0x70,
+    0x5e, 0x27, 0x98, 0xdf, 0xeb, 0x76, 0xb6, 0x00, 0xe5, 0x54, 0xf9, 0x8f, 0x8f, 0xf3, 0xe9,
+    0x5d, 0xcd, 0xcb, 0x88, 0xe0, 0x62, 0x4e, 0x2b, 0xce, 0xf4, 0xd7, 0x37, 0xfa, 0xbd, 0xee,
+    0xa0, 0xdd, 0x0b, 0x6d, 0x4f, 0xa7, 0xff, 0x00, 0xa8, 0x50, 0xd5, 0xed, 0x1e, 0xe6, 0x33,
+    0x76, 0x57, 0x2c, 0xea, 0xb3, 0x08, 0xad, 0xc4, 0x63, 0xf8, 0xbf, 0x90, 0xae, 0x62, 0x6e,
+    0x23, 0x07, 0xa9, 0x24, 0x93, 0x5a, 0x3a, 0xbd, 0xd0, 0x96, 0xf5, 0xa1, 0x53, 0xca, 0xfc,
+    0xb5, 0x97, 0x70, 0x7b, 0x7e, 0x15, 0x8d, 0x69, 0xdd, 0xb1, 0xd2, 0x8d, 0xa2, 0x8a, 0xa5,
+    0x49, 0xc9, 0x03, 0x8a, 0x4c, 0x57, 0x4b, 0x69, 0x62, 0xb1, 0x68, 0x72, 0x48, 0xea, 0x37,
+    0x48, 0xa4, 0xf3, 0xe9, 0x8a, 0xe6, 0x8d, 0x73, 0xce, 0x9f, 0x22, 0x4d, 0xf5, 0x34, 0x8c,
+    0x94, 0xaf, 0x62, 0x68, 0x3b, 0xd7, 0x53, 0xa4, 0x0c, 0x59, 0xa8, 0xfc, 0x6b, 0x96, 0x83,
+    0x97, 0x0b, 0xea, 0x71, 0x5d, 0x6e, 0x9e, 0xbb, 0x63, 0xdb, 0xe8, 0x31, 0x5d, 0x18, 0x55,
+    0xad, 0xcc, 0xab, 0xfc, 0x24, 0xb7, 0x47, 0x10, 0x37, 0xd2, 0xb2, 0x97, 0xa5, 0x6a, 0x5d,
+    0x8f, 0xdc, 0x9f, 0x60, 0x6b, 0x35, 0x07, 0xcb, 0x5d, 0x4f, 0x72, 0x28, 0xfc, 0x23, 0xa3,
+    0x3b, 0x4e, 0x4d, 0x3e, 0x59, 0x54, 0x2f, 0x07, 0x24, 0xd3, 0x3b, 0x54, 0x4f, 0xda, 0x94,
+    0x9d, 0x91, 0xa5, 0x93, 0x77, 0x2a, 0x5d, 0x8f, 0xdc, 0xe7, 0xd0, 0xd5, 0xed, 0x13, 0xe6,
+    0x86, 0x41, 0xe9, 0x55, 0x27, 0x5c, 0xc2, 0xc3, 0xda, 0xad, 0x78, 0x7d, 0x80, 0x92, 0x64,
+    0x3f, 0xdd, 0x06, 0xb1, 0x86, 0x95, 0x10, 0x54, 0xf8, 0x19, 0x93, 0xab, 0xb1, 0x7d, 0x4a,
+    0x41, 0xd9, 0x70, 0x2b, 0x5f, 0x46, 0x8b, 0x6d, 0xb3, 0xbf, 0x76, 0x38, 0xac, 0x59, 0xff,
+    0x00, 0x7b, 0x7b, 0x34, 0x9e, 0xae, 0x48, 0xae, 0x9e, 0xc2, 0x1d, 0x96, 0x31, 0x0e, 0xe4,
+    0x66, 0x95, 0x05, 0x7a, 0x8e, 0x42, 0xaa, 0xf9, 0x60, 0x91, 0x5f, 0x51, 0xf9, 0x6c, 0xd8,
+    0x0e, 0xa7, 0x8a, 0xa7, 0xa4, 0x40, 0x5a, 0xe8, 0xb6, 0x38, 0x55, 0xad, 0x0d, 0x49, 0x3f,
+    0x74, 0x8b, 0xea, 0x6a, 0xe6, 0x89, 0x62, 0x4c, 0x25, 0x82, 0xf2, 0xed, 0x81, 0x5b, 0x38,
+    0xde, 0xa2, 0x7d, 0x8c, 0xd4, 0xad, 0x4f, 0x4e, 0xa4, 0x6d, 0x07, 0x18, 0x23, 0xa9, 0xc9,
+    0xaa, 0x97, 0xdf, 0xbb, 0x84, 0x46, 0xbd, 0x58, 0xfe, 0x95, 0xde, 0xf8, 0x9f, 0xc2, 0xf1,
+    0xe8, 0x71, 0x58, 0x90, 0xee, 0xd2, 0xce, 0x84, 0xb8, 0x6c, 0x60, 0x11, 0x8e, 0x9f, 0x9d,
+    0x70, 0xf7, 0x30, 0xbd, 0xc5, 0xd9, 0x0a, 0x32, 0x07, 0x15, 0x6d, 0xf3, 0x47, 0x41, 0x25,
+    0x28, 0x4f, 0x96, 0x7d, 0x03, 0x4a, 0x88, 0xf9, 0x80, 0x8a, 0xf5, 0x8f, 0x01, 0x5b, 0x32,
+    0x6a, 0x2b, 0x23, 0x0c, 0x65, 0x18, 0x57, 0x09, 0xa4, 0xd8, 0x04, 0x2b, 0x91, 0x5e, 0x9f,
+    0xe1, 0x18, 0xf6, 0xdd, 0x29, 0xc7, 0x01, 0x4e, 0x3f, 0x2a, 0x8a, 0xba, 0x53, 0x68, 0xdf,
+    0x0c, 0xb9, 0xaa, 0xf3, 0x1e, 0xa9, 0x1f, 0xfa, 0xb5, 0xfa, 0x0a, 0xf3, 0xef, 0x15, 0xa0,
+    0xdd, 0x17, 0xb0, 0x61, 0x5e, 0x82, 0x9f, 0x71, 0x7e, 0x95, 0xe7, 0x9e, 0x30, 0x98, 0x47,
+    0x1a, 0x13, 0xd7, 0x0d, 0xc5, 0x70, 0x50, 0xf8, 0xce, 0xa8, 0xfc, 0x32, 0x3c, 0xdb, 0x53,
+    0x75, 0x0e, 0xc0, 0x1a, 0xe7, 0x2f, 0x2e, 0x3a, 0xaa, 0xfe, 0x75, 0xa7, 0xa8, 0xc9, 0x96,
+    0x62, 0x4f, 0xe2, 0x6b, 0x95, 0xbe, 0x98, 0x97, 0x2a, 0xa7, 0x8e, 0xf5, 0xe9, 0xb7, 0x64,
+    0x79, 0xad, 0x73, 0xce, 0xc3, 0x27, 0xb9, 0x0a, 0x48, 0x5e, 0x5a, 0x8b, 0x68, 0x09, 0xfd,
+    0xf4, 0xdf, 0x86, 0x69, 0x96, 0xb6, 0xde, 0x63, 0x79, 0x8e, 0x3e, 0x51, 0xd3, 0xde, 0xae,
+    0x34, 0x6d, 0x29, 0xda, 0x41, 0x11, 0x8f, 0xd6, 0xa1, 0x26, 0xf5, 0x65, 0xb6, 0x96, 0x88,
+    0xae, 0xca, 0xf7, 0x6d, 0x81, 0x95, 0x84, 0x77, 0xf5, 0xab, 0x09, 0x12, 0xc6, 0x30, 0xa0,
+    0x0a, 0x93, 0x6e, 0x00, 0x00, 0x52, 0xaa, 0x12, 0x6a, 0xb9, 0x7a, 0x99, 0xb9, 0x0d, 0x58,
+    0x83, 0xf2, 0xc3, 0x20, 0x7a, 0xf7, 0xac, 0xfd, 0x46, 0xeb, 0x71, 0xf2, 0x90, 0xfc, 0xa3,
+    0xa9, 0xab, 0xf7, 0x93, 0x79, 0x30, 0x61, 0x7e, 0xf1, 0xe0, 0x57, 0x31, 0x79, 0x31, 0x24,
+    0xa2, 0x7e, 0x26, 0xb2, 0xad, 0x3e, 0x54, 0x69, 0x46, 0x3c, 0xcf, 0x99, 0x90, 0x5c, 0xcf,
+    0xb8, 0xec, 0x43, 0xc7, 0x73, 0xeb, 0x45, 0xa5, 0x94, 0xb7, 0x2e, 0x00, 0x18, 0x15, 0x35,
+    0xa5, 0x83, 0x4b, 0x20, 0xe3, 0x27, 0xf4, 0x15, 0xd1, 0x5b, 0x5b, 0x2c, 0x49, 0xb5, 0x47,
+    0x1d, 0xcf, 0xad, 0x73, 0x53, 0xa4, 0xe6, 0xef, 0x23, 0x69, 0xcd, 0x45, 0x10, 0xda, 0xd9,
+    0xa5, 0xb2, 0x61, 0x40, 0xcf, 0x73, 0x56, 0xc2, 0xf3, 0x4e, 0xdb, 0xe9, 0x52, 0x85, 0xda,
+    0x32, 0x6b, 0xb5, 0x24, 0x95, 0x91, 0xc9, 0x29, 0xdc, 0x14, 0xec, 0x19, 0x26, 0x9f, 0x1d,
+    0xe1, 0xdd, 0xb5, 0x47, 0xe3, 0x55, 0x26, 0x2f, 0xd4, 0x8c, 0x7a, 0x0a, 0x48, 0x14, 0xa9,
+    0x04, 0xd0, 0x0a, 0x3a, 0x5c, 0xee, 0xbc, 0x25, 0xab, 0x1d, 0x3f, 0x55, 0xb7, 0x99, 0x9b,
+    0xe4, 0xdd, 0xb2, 0x4f, 0xf7, 0x4f, 0x5f, 0xf1, 0xfc, 0x2b, 0xd6, 0x35, 0x7b, 0x4f, 0xb6,
+    0xe9, 0x73, 0x46, 0xbc, 0xb6, 0x37, 0xa6, 0x3d, 0x47, 0x3f, 0xfd, 0x6f, 0xc6, 0xbc, 0x26,
+    0xc5, 0x8a, 0x91, 0x5e, 0xd7, 0xe1, 0x3d, 0x47, 0xfb, 0x4b, 0x42, 0x84, 0xb3, 0x66, 0x58,
+    0x7f, 0x76, 0xff, 0x00, 0x87, 0x4f, 0xd3, 0x15, 0xcd, 0x5e, 0x36, 0x6a, 0x48, 0xf4, 0xb0,
+    0x35, 0x39, 0xa2, 0xe9, 0xb3, 0x47, 0xc0, 0xf1, 0x79, 0x1a, 0x2c, 0xd7, 0x6e, 0xa0, 0x17,
+    0x63, 0x83, 0xea, 0x07, 0x1f, 0xd2, 0xa0, 0xd7, 0x35, 0xcb, 0x7d, 0x22, 0xd2, 0x5b, 0x89,
+    0xa4, 0x53, 0x31, 0x52, 0x52, 0x3c, 0xf2, 0xc7, 0xfc, 0x2a, 0xec, 0xb7, 0x50, 0x68, 0x1e,
+    0x1a, 0xb8, 0x90, 0xa9, 0x31, 0x2b, 0x31, 0x0a, 0x3d, 0xcf, 0x4f, 0xcc, 0xd7, 0x88, 0xeb,
+    0xfa, 0xc4, 0xfa, 0x9d, 0xec, 0x97, 0x33, 0x37, 0x2c, 0x78, 0x03, 0xa2, 0x8e, 0xc0, 0x56,
+    0x30, 0xa7, 0xed, 0x24, 0xdb, 0xd8, 0xd2, 0xa5, 0x5f, 0x60, 0x9f, 0x73, 0x37, 0x56, 0xd4,
+    0x24, 0xbb, 0x9e, 0x49, 0xa5, 0x72, 0xce, 0xe4, 0x92, 0x49, 0xeb, 0x5c, 0xc5, 0xf5, 0xc0,
+    0x54, 0x63, 0x9a, 0xbd, 0x75, 0x36, 0xe2, 0x79, 0xae, 0x7a, 0xfe, 0x5d, 0xd2, 0x6c, 0xcf,
+    0x4a, 0xeb, 0x9c, 0xb9, 0x62, 0x79, 0xb4, 0xd7, 0x34, 0xb9, 0x99, 0x4a, 0x47, 0xdc, 0xc4,
+    0x9a, 0x9a, 0xd6, 0x22, 0x4e, 0x71, 0xc9, 0xe0, 0x54, 0x2a, 0xbb, 0xe4, 0x02, 0xb5, 0xac,
+    0xe2, 0xcb, 0x6e, 0xc7, 0x0b, 0xc0, 0xae, 0x6a, 0x71, 0xe6, 0x77, 0x3a, 0x24, 0xec, 0x8b,
+    0x91, 0xa0, 0x8e, 0x30, 0x3d, 0x05, 0x2c, 0x2b, 0xbd, 0xcb, 0x9e, 0x83, 0xa5, 0x24, 0x87,
+    0x0b, 0x81, 0x53, 0x80, 0x22, 0x80, 0x0e, 0xf8, 0xae, 0xb3, 0x9e, 0x4f, 0x4f, 0x52, 0xb5,
+    0xd4, 0xa2, 0x38, 0xcf, 0xe9, 0x59, 0x07, 0x9a, 0xb3, 0x73, 0x2f, 0x99, 0x26, 0x07, 0x41,
+    0x50, 0x11, 0x58, 0xcd, 0xdd, 0x9b, 0x42, 0x3c, 0xa8, 0x8d, 0xb8, 0x52, 0x4d, 0x52, 0x80,
+    0xe2, 0x46, 0x5a, 0xb9, 0x3e, 0x42, 0x81, 0xeb, 0x54, 0x9c, 0x14, 0x95, 0x5b, 0xb1, 0xac,
+    0x27, 0xb9, 0x68, 0x92, 0x75, 0xca, 0xe6, 0xa2, 0x80, 0xfc, 0xc4, 0x55, 0x97, 0x1b, 0x92,
+    0xa9, 0xa1, 0xdb, 0x28, 0xfa, 0xd4, 0x4b, 0x46, 0x98, 0xd0, 0xae, 0x36, 0xca, 0x0d, 0x6b,
+    0x00, 0x23, 0x84, 0x62, 0xb3, 0x27, 0x1d, 0x0d, 0x5e, 0x59, 0x37, 0xc4, 0x87, 0xda, 0xae,
+    0x9e, 0x8d, 0x93, 0x2d, 0x45, 0x03, 0x27, 0xd8, 0x55, 0x7b, 0xc9, 0x30, 0x9b, 0x07, 0x53,
+    0xd6, 0xac, 0x9f, 0x91, 0x6b, 0x36, 0xe1, 0xb7, 0x48, 0x7d, 0xa9, 0xd4, 0x76, 0x40, 0xb5,
+    0x64, 0x34, 0x51, 0x45, 0x73, 0x16, 0x14, 0xb4, 0x94, 0x50, 0x01, 0x45, 0x14, 0x50, 0x01,
+    0x45, 0x14, 0x50, 0x01, 0x4e, 0x55, 0xcd, 0x00, 0x66, 0xa4, 0x1c, 0x53, 0x48, 0x00, 0x0a,
+    0x0d, 0x2d, 0x21, 0xaa, 0x10, 0x86, 0x9a, 0x69, 0xd4, 0xde, 0xa7, 0x3d, 0xa9, 0x0c, 0xb1,
+    0x13, 0x5c, 0x40, 0x43, 0x21, 0x2a, 0x40, 0xce, 0x47, 0xa5, 0x6d, 0xd8, 0xeb, 0xeb, 0x81,
+    0x1d, 0xd0, 0xc7, 0xfb, 0x63, 0xfa, 0xd5, 0x16, 0x49, 0x2d, 0xfa, 0x0c, 0xc9, 0x6e, 0x7f,
+    0xef, 0xa4, 0x35, 0x6e, 0x6d, 0x2a, 0x1b, 0xeb, 0x65, 0xb9, 0xb4, 0x21, 0x59, 0x86, 0x76,
+    0xf6, 0x35, 0xd3, 0x05, 0x28, 0xfc, 0x26, 0x53, 0xe5, 0x7f, 0x11, 0xd2, 0x69, 0xec, 0xb2,
+    0x1d, 0xea, 0xc1, 0x94, 0xf4, 0x22, 0xb5, 0xb6, 0x8a, 0xe0, 0x34, 0xcb, 0x9b, 0x9d, 0x3a,
+    0x52, 0x88, 0x48, 0x91, 0x4f, 0xcd, 0x13, 0xf4, 0x71, 0xed, 0x5d, 0x9e, 0x9d, 0xaa, 0xdb,
+    0xea, 0x11, 0xe5, 0x09, 0x59, 0x17, 0xef, 0xc6, 0xdd, 0x54, 0xd6, 0xca, 0x5c, 0xc6, 0x7c,
+    0x9c, 0xa7, 0x31, 0xad, 0xe9, 0xbf, 0x66, 0xd5, 0x24, 0xdb, 0xc4, 0x37, 0x40, 0xba, 0xff,
+    0x00, 0xb2, 0xe2, 0xba, 0x4d, 0x12, 0xf8, 0xdf, 0x69, 0x91, 0xbb, 0xff, 0x00, 0xad, 0x4f,
+    0x92, 0x41, 0xee, 0x29, 0xba, 0xed, 0xaf, 0xda, 0xb4, 0xc6, 0x64, 0x19, 0x92, 0x13, 0xe6,
+    0x2e, 0x3d, 0xba, 0x8f, 0xca, 0xb1, 0xf4, 0x0b, 0x91, 0x06, 0xa8, 0x62, 0xcf, 0xee, 0xae,
+    0x97, 0x72, 0xff, 0x00, 0xbc, 0x3f, 0xfa, 0xd4, 0xad, 0x66, 0x56, 0xf1, 0x3a, 0xa7, 0x45,
+    0x96, 0x36, 0x8d, 0xc6, 0x55, 0x81, 0x04, 0x1e, 0xe2, 0xbc, 0xf2, 0x48, 0xa5, 0xd3, 0x2f,
+    0x26, 0x80, 0x13, 0xe6, 0x5a, 0x4a, 0x24, 0x8c, 0xfa, 0xaf, 0xff, 0x00, 0xaa, 0xbd, 0x18,
+    0x0a, 0xe6, 0x3c, 0x4d, 0x66, 0x12, 0xf2, 0xda, 0xf7, 0x1f, 0x2b, 0xfe, 0xe6, 0x4f, 0xc7,
+    0xa5, 0x13, 0x57, 0xd4, 0x22, 0xf5, 0x36, 0x9b, 0x51, 0x85, 0x74, 0xb1, 0x7e, 0x4f, 0xee,
+    0xca, 0x06, 0x1e, 0xfe, 0xd5, 0xc1, 0x59, 0x5e, 0x3c, 0x9a, 0xf9, 0x9d, 0xb0, 0x1a, 0x47,
+    0x63, 0x8f, 0xad, 0x2c, 0xd7, 0xd2, 0xa6, 0x9e, 0x34, 0xb6, 0x27, 0x6c, 0x52, 0x93, 0xf5,
+    0x1d, 0xbf, 0xad, 0x52, 0x8c, 0x35, 0xbd, 0xfa, 0x76, 0x61, 0x86, 0xfc, 0xc6, 0x6b, 0x19,
+    0xd4, 0xbb, 0x5e, 0x45, 0x46, 0x1a, 0x33, 0xae, 0xf0, 0xcc, 0xbf, 0xf1, 0x38, 0x99, 0x4f,
+    0xf1, 0xc6, 0x4f, 0xfe, 0x3d, 0xff, 0x00, 0xd7, 0xae, 0xf2, 0xd7, 0xef, 0x8a, 0xf3, 0xdd,
+    0x00, 0xf9, 0x5a, 0xe5, 0xb9, 0x3d, 0x25, 0x8d, 0xd7, 0xfa, 0xff, 0x00, 0x4a, 0xf4, 0x2b,
+    0x52, 0x03, 0x03, 0x5b, 0x74, 0x1a, 0xdc, 0xeb, 0x74, 0x58, 0x63, 0x9a, 0x64, 0x8e, 0x46,
+    0xda, 0x09, 0xc6, 0x6b, 0xd0, 0xed, 0x34, 0xe6, 0x3a, 0x6b, 0xdb, 0xc8, 0xfb, 0xd3, 0x1f,
+    0x29, 0x35, 0xc4, 0x78, 0x73, 0x4c, 0x6b, 0xe2, 0x09, 0x25, 0x51, 0x7a, 0x91, 0x5d, 0xe4,
+    0x57, 0x16, 0xf6, 0x30, 0xac, 0x4d, 0x28, 0xe3, 0xd4, 0xd7, 0x25, 0x47, 0xa9, 0xdd, 0x1b,
+    0xa8, 0x68, 0x71, 0x37, 0xf6, 0xef, 0x69, 0x33, 0x42, 0xe0, 0xf0, 0x78, 0x3e, 0xd5, 0x89,
+    0x74, 0xc4, 0x13, 0x5e, 0x81, 0xad, 0x59, 0xc5, 0xa8, 0xdb, 0x19, 0x61, 0x20, 0xba, 0xf2,
+    0x31, 0x5c, 0x15, 0xdc, 0x64, 0x31, 0x04, 0x55, 0xd3, 0x95, 0xc9, 0x9a, 0xd0, 0xc6, 0x9e,
+    0x43, 0xcf, 0x35, 0x42, 0x56, 0x35, 0xa9, 0x25, 0xab, 0xca, 0x7e, 0x55, 0x26, 0xab, 0xdc,
+    0x69, 0x77, 0x11, 0xa1, 0x72, 0x87, 0x18, 0xae, 0x84, 0xd1, 0xcd, 0x24, 0xcc, 0xa7, 0x24,
+    0xd7, 0x31, 0xe2, 0x29, 0x33, 0xac, 0xe8, 0xd0, 0x93, 0xf2, 0x99, 0x8b, 0x11, 0xf9, 0x57,
+    0x4a, 0xf9, 0x04, 0xfb, 0x57, 0x2d, 0xe2, 0x31, 0x8d, 0x67, 0x47, 0x90, 0xf4, 0xf3, 0x08,
+    0xfd, 0x45, 0x5c, 0xfe, 0x13, 0x0e, 0xa6, 0x8e, 0xb1, 0x30, 0x45, 0x00, 0x9c, 0x2e, 0x32,
+    0x7d, 0x85, 0x73, 0x70, 0x35, 0xfe, 0xb3, 0x3b, 0x45, 0xa6, 0xa8, 0x48, 0x53, 0x86, 0x99,
+    0xfa, 0x55, 0xaf, 0x11, 0x99, 0xaf, 0xf5, 0x7b, 0x7d, 0x2e, 0xdc, 0xe0, 0xc8, 0x01, 0x73,
+    0xe8, 0x2b, 0xa8, 0xb1, 0xb5, 0x86, 0xc2, 0xd1, 0x2d, 0xe0, 0x4d, 0xa8, 0x83, 0xf3, 0xf7,
+    0x34, 0x36, 0xe4, 0xec, 0xb6, 0x44, 0xc5, 0x25, 0xab, 0x3c, 0xf3, 0x58, 0xb2, 0xd4, 0x34,
+    0xd6, 0x16, 0xb7, 0x25, 0x5c, 0x4b, 0xf7, 0x24, 0x5f, 0xe2, 0xae, 0xaa, 0xca, 0x25, 0xd3,
+    0x34, 0xa8, 0xe0, 0x51, 0xf3, 0x01, 0x96, 0xf7, 0x34, 0xcd, 0x66, 0x05, 0xbc, 0xf1, 0x35,
+    0x9a, 0xf2, 0x52, 0x08, 0xbc, 0xc6, 0x1d, 0xb3, 0x9e, 0x29, 0x6f, 0x24, 0xcf, 0xca, 0x3a,
+    0x51, 0x4e, 0x16, 0x93, 0x62, 0xab, 0x2b, 0xda, 0x26, 0x4d, 0xe4, 0x86, 0x49, 0x39, 0x39,
+    0xaa, 0x2c, 0x23, 0x8b, 0xe6, 0x76, 0xe3, 0xb0, 0xa9, 0x6f, 0x26, 0x11, 0x12, 0xdd, 0x49,
+    0x38, 0x51, 0xea, 0x6b, 0xa1, 0xd1, 0x74, 0x04, 0x89, 0x12, 0xee, 0xf9, 0x44, 0x97, 0x2d,
+    0xc8, 0x43, 0xd1, 0x3f, 0xfa, 0xf4, 0x3d, 0x65, 0x63, 0x55, 0x68, 0xa3, 0x98, 0x92, 0xe2,
+    0x48, 0x91, 0x64, 0x7b, 0x59, 0x56, 0x16, 0x38, 0x12, 0x30, 0x20, 0x54, 0xc0, 0x86, 0x50,
+    0x47, 0x43, 0x5d, 0xa6, 0xaf, 0x04, 0x53, 0xe9, 0x17, 0x49, 0x2a, 0x82, 0x9e, 0x59, 0x3f,
+    0x4c, 0x0c, 0x8a, 0xe0, 0x74, 0xd7, 0x2d, 0x65, 0xcf, 0xf0, 0xb1, 0x02, 0xa7, 0x58, 0xca,
+    0xcd, 0x8d, 0x3b, 0xa2, 0xcd, 0x35, 0x99, 0x22, 0x42, 0xee, 0x40, 0x51, 0xd6, 0x92, 0x59,
+    0x56, 0x24, 0x2e, 0xe7, 0x00, 0x54, 0x9a, 0x46, 0x8f, 0x71, 0xe2, 0x09, 0xfc, 0xc9, 0x49,
+    0x8a, 0xc5, 0x0f, 0x24, 0x75, 0x6f, 0x61, 0xfe, 0x34, 0x9b, 0xd6, 0xcb, 0x71, 0xf9, 0xb2,
+    0x3d, 0x2f, 0x48, 0xb9, 0xf1, 0x05, 0xc3, 0xca, 0xd9, 0x8e, 0xd6, 0x30, 0x79, 0xf5, 0x3e,
+    0x82, 0xb0, 0x18, 0x15, 0x62, 0xa7, 0xa8, 0x38, 0xaf, 0x65, 0xb6, 0xb7, 0x8a, 0xd6, 0x04,
+    0x86, 0x04, 0x09, 0x1a, 0x0c, 0x05, 0x1d, 0xab, 0xca, 0xb5, 0xeb, 0x6f, 0xb2, 0x6b, 0x97,
+    0x71, 0x01, 0x81, 0xe6, 0x16, 0x1f, 0x43, 0xcf, 0xf5, 0xac, 0x6b, 0xd2, 0xe5, 0x8a, 0x7d,
+    0x42, 0x12, 0xbb, 0x33, 0xa8, 0xce, 0x68, 0xa2, 0xb9, 0x4d, 0x05, 0x15, 0x61, 0x58, 0x11,
+    0x9a, 0xaf, 0x4a, 0x09, 0x14, 0xd3, 0xb0, 0x16, 0x32, 0x01, 0xa7, 0xd5, 0x55, 0x6c, 0x75,
+    0xa9, 0x56, 0x50, 0x0e, 0x09, 0xab, 0x4d, 0x08, 0xb5, 0x04, 0xe6, 0x16, 0xf5, 0x53, 0xd4,
+    0x56, 0x8a, 0x3a, 0xba, 0x86, 0x53, 0x90, 0x6b, 0x20, 0x9c, 0xd3, 0xa2, 0xb8, 0x78, 0x1b,
+    0x23, 0x95, 0x3d, 0x45, 0x6b, 0x09, 0xf2, 0xe8, 0xc4, 0xd1, 0x63, 0x54, 0x62, 0x23, 0x45,
+    0xec, 0x4d, 0x66, 0xab, 0xb2, 0x1e, 0x3f, 0x2a, 0xd7, 0x71, 0x15, 0xfd, 0xbe, 0x15, 0x86,
+    0x7a, 0x8f, 0x63, 0x59, 0x0e, 0x8d, 0x1b, 0x94, 0x61, 0x82, 0x2a, 0x2a, 0xa7, 0x7e, 0x64,
+    0x08, 0xb5, 0x15, 0xca, 0xe7, 0x93, 0xb4, 0xfe, 0x95, 0x7a, 0x29, 0x41, 0x1c, 0xfe, 0x63,
+    0x91, 0x58, 0xc3, 0xad, 0x77, 0x2b, 0xe0, 0x78, 0xee, 0xb4, 0xfb, 0x7b, 0xab, 0x1b, 0xb6,
+    0x89, 0xe4, 0x8d, 0x5c, 0xa4, 0x83, 0x23, 0x24, 0x7a, 0x8a, 0xba, 0x3c, 0xf2, 0xd8, 0x25,
+    0x64, 0x63, 0x06, 0xef, 0x9c, 0x8f, 0x5a, 0x49, 0xe0, 0x4b, 0xa8, 0xb6, 0x9e, 0x18, 0x74,
+    0x3e, 0x95, 0x2d, 0xcf, 0x87, 0xb5, 0xeb, 0x02, 0x49, 0xb6, 0x33, 0xa8, 0xfe, 0x28, 0xbe,
+    0x6f, 0xfe, 0xbd, 0x50, 0x37, 0x53, 0x40, 0xe5, 0x67, 0xb7, 0x74, 0x23, 0xa8, 0x20, 0x83,
+    0x5a, 0xb9, 0x74, 0x92, 0x27, 0xd0, 0xe9, 0x7c, 0x3d, 0xe2, 0xe7, 0xd3, 0xca, 0xe9, 0xfa,
+    0xb6, 0x7c, 0xb1, 0xc2, 0x4f, 0xd7, 0x03, 0xdf, 0xda, 0xbb, 0x89, 0xad, 0xec, 0x75, 0x5b,
+    0x51, 0xe6, 0x47, 0x15, 0xc4, 0x2e, 0x32, 0x0f, 0x04, 0x7e, 0x06, 0xbc, 0x99, 0xaf, 0x6c,
+    0xe7, 0x4d, 0x92, 0x83, 0x8f, 0x71, 0xd2, 0xae, 0xe9, 0x57, 0xba, 0x86, 0x93, 0x2e, 0xfd,
+    0x3e, 0xe8, 0x35, 0xb9, 0x39, 0x68, 0xa4, 0x3c, 0x1f, 0xc2, 0xae, 0x13, 0xb6, 0x9b, 0xaf,
+    0xc4, 0x4d, 0x1d, 0x2d, 0xe7, 0x81, 0xcc, 0x32, 0x19, 0xf4, 0x6b, 0xc7, 0xb7, 0x93, 0xfe,
+    0x79, 0xb9, 0xca, 0x9f, 0xc6, 0xb3, 0xde, 0xfb, 0x59, 0xd1, 0xf0, 0xba, 0xb6, 0x9e, 0xef,
+    0x1f, 0x4f, 0x3e, 0x21, 0x91, 0xfa, 0x71, 0x5d, 0x2e, 0x99, 0xe2, 0x9b, 0x2b, 0xbc, 0x25,
+    0xc1, 0xfb, 0x3c, 0xbf, 0xed, 0x1f, 0x94, 0xfd, 0x0d, 0x74, 0x4a, 0x52, 0x44, 0xe0, 0xab,
+    0x2b, 0x0f, 0xa8, 0x35, 0x6e, 0x2b, 0xec, 0xe8, 0x4d, 0x93, 0xdc, 0xe2, 0xac, 0x75, 0x6b,
+    0x2b, 0xec, 0x79, 0x13, 0xa9, 0x6f, 0xee, 0xb7, 0x07, 0xf2, 0xad, 0x01, 0x53, 0x6a, 0xbe,
+    0x0d, 0xd2, 0xb5, 0x32, 0x5d, 0x62, 0xfb, 0x2c, 0xfd, 0x7c, 0xc8, 0x38, 0xfc, 0xc7, 0x4a,
+    0xc7, 0x5d, 0x0b, 0xc4, 0x5a, 0x4b, 0xe2, 0x39, 0x52, 0xfe, 0xd8, 0x76, 0xfe, 0x30, 0x3f,
+    0xcf, 0xd6, 0x84, 0xe4, 0xb7, 0x44, 0x4a, 0x9f, 0x63, 0x51, 0x49, 0xce, 0x01, 0xa9, 0x95,
+    0x0b, 0x76, 0xc9, 0xaa, 0xf6, 0x57, 0x0b, 0x21, 0xc4, 0xf6, 0xf2, 0xc0, 0xe3, 0x83, 0xe6,
+    0x0c, 0x0a, 0xda, 0x86, 0x28, 0xd9, 0x72, 0xae, 0x08, 0xf6, 0xab, 0x6c, 0x85, 0x1b, 0x95,
+    0x63, 0x80, 0xe7, 0x2c, 0x7f, 0x01, 0x57, 0x61, 0x84, 0xb7, 0x45, 0xc1, 0xf5, 0xab, 0x09,
+    0x12, 0x20, 0xe9, 0x4e, 0xde, 0xa0, 0x54, 0xdc, 0xd1, 0x42, 0xc5, 0xcb, 0x3b, 0xb9, 0xed,
+    0xb0, 0x19, 0xb7, 0x0e, 0xc3, 0xd2, 0xba, 0xad, 0x33, 0x59, 0x8a, 0x58, 0xfc, 0x99, 0x76,
+    0xe1, 0x86, 0x19, 0x5b, 0xa3, 0x57, 0x13, 0xe7, 0x8e, 0x9d, 0x45, 0x20, 0xb8, 0x64, 0x60,
+    0xc8, 0x4d, 0x44, 0xa1, 0xcc, 0x6f, 0x1a, 0x8e, 0x27, 0x5b, 0x7f, 0xe1, 0x08, 0x25, 0x2d,
+    0x73, 0xa3, 0xc8, 0xb6, 0xd2, 0x9e, 0x5a, 0x06, 0xe6, 0x37, 0xfa, 0x7a, 0x7e, 0x15, 0xcd,
+    0xca, 0xef, 0x6b, 0x77, 0xf6, 0x3b, 0xd8, 0x9a, 0xda, 0xeb, 0x19, 0x08, 0xfd, 0x18, 0x7a,
+    0xa9, 0xe8, 0x45, 0x6a, 0xe9, 0x1e, 0x26, 0x7b, 0x67, 0x54, 0x9b, 0xe6, 0x4e, 0xf9, 0xae,
+    0xa2, 0xe2, 0x0d, 0x2b, 0xc4, 0xda, 0x79, 0x82, 0xe2, 0x24, 0x9e, 0x23, 0xce, 0x0f, 0x0c,
+    0x87, 0xd4, 0x1e, 0xa0, 0xfb, 0x8a, 0x9e, 0x79, 0x43, 0x49, 0x6a, 0x8b, 0x50, 0x8c, 0xf5,
+    0x86, 0x8c, 0xe1, 0x7a, 0xd1, 0x8a, 0x5d, 0x5f, 0x40, 0xd5, 0xfc, 0x34, 0x1a, 0x78, 0x44,
+    0x9a, 0xa6, 0x96, 0xb9, 0x27, 0x03, 0x33, 0xc2, 0xbe, 0xe3, 0xf8, 0x80, 0x1d, 0xc7, 0xa5,
+    0x55, 0xd3, 0xf5, 0x1b, 0x5d, 0x4e, 0x01, 0x35, 0xa4, 0xa2, 0x45, 0xee, 0x31, 0x82, 0x0f,
+    0xa1, 0x06, 0xb6, 0x52, 0x52, 0x57, 0x46, 0x6e, 0xe9, 0xd9, 0x96, 0x31, 0x9a, 0x5c, 0x54,
+    0x9b, 0x71, 0x49, 0x8a, 0x63, 0x22, 0x23, 0x9a, 0x69, 0x15, 0x31, 0x5a, 0x69, 0x18, 0xed,
+    0x48, 0x64, 0x58, 0xa6, 0x91, 0x52, 0x11, 0x8a, 0x69, 0x14, 0x00, 0xd0, 0x79, 0xa7, 0xab,
+    0x54, 0x67, 0xad, 0x3c, 0x54, 0xb0, 0x45, 0xc8, 0x41, 0x65, 0xcd, 0x69, 0x69, 0xf7, 0x46,
+    0x36, 0xda, 0x4f, 0x06, 0xa9, 0xd9, 0x00, 0xea, 0x54, 0xd3, 0xb6, 0xb4, 0x53, 0x56, 0x52,
+    0x5d, 0x0d, 0xa3, 0xa6, 0xa4, 0xfa, 0x91, 0x3b, 0xcb, 0x7a, 0xd6, 0x43, 0xb9, 0xf5, 0xad,
+    0x9b, 0x94, 0x32, 0xc2, 0x18, 0x56, 0x44, 0x91, 0xf2, 0x68, 0x88, 0xa7, 0xb9, 0x5d, 0x98,
+    0x9e, 0xa6, 0xa2, 0x63, 0xdb, 0x39, 0xa9, 0x8a, 0xe0, 0xf4, 0xa8, 0x99, 0x70, 0x6b, 0x44,
+    0x66, 0xc8, 0xcd, 0x46, 0x47, 0x34, 0xf6, 0xcd, 0x25, 0x32, 0x59, 0xcf, 0xf8, 0xae, 0xec,
+    0xda, 0xe8, 0xd3, 0x15, 0xfb, 0xcc, 0xbb, 0x17, 0xea, 0x78, 0xae, 0x5b, 0x4d, 0xdb, 0x65,
+    0xa3, 0x97, 0x6c, 0x0c, 0x02, 0x4d, 0x6e, 0x78, 0xad, 0xbc, 0xe9, 0x60, 0xb6, 0x1c, 0x82,
+    0xd9, 0x22, 0xb9, 0x4d, 0x5e, 0x63, 0x0d, 0xa8, 0xb6, 0x53, 0x8d, 0xcd, 0x8f, 0xc2, 0x89,
+    0x7b, 0xbe, 0xff, 0x00, 0x91, 0x8c, 0x97, 0x37, 0xba, 0x65, 0xc3, 0x99, 0xee, 0x9e, 0x66,
+    0xee, 0x49, 0xa8, 0xe6, 0x3b, 0xa6, 0xc7, 0xbd, 0x59, 0xb6, 0x1b, 0x63, 0x63, 0xe8, 0xb5,
+    0x59, 0x41, 0x69, 0xd5, 0x7b, 0xe6, 0xb8, 0x9e, 0xc8, 0xdc, 0xeb, 0xae, 0x94, 0x0d, 0x34,
+    0x20, 0xe8, 0x21, 0xe9, 0xf8, 0x57, 0x12, 0x7a, 0xd7, 0x73, 0x7a, 0x36, 0xda, 0xc8, 0xbf,
+    0xdd, 0x8f, 0x1f, 0xa5, 0x71, 0x0c, 0x3e, 0x63, 0x5b, 0x62, 0xd6, 0xa8, 0xc6, 0x86, 0xcc,
+    0x96, 0xd0, 0x66, 0xe2, 0x3f, 0xf7, 0xab, 0xae, 0xb1, 0xff, 0x00, 0x56, 0x7e, 0xb5, 0xca,
+    0x59, 0x0f, 0xf4, 0x94, 0xfa, 0xd7, 0x5b, 0x66, 0x36, 0xc2, 0x0f, 0xad, 0x5e, 0x17, 0x66,
+    0x2a, 0xff, 0x00, 0x08, 0xdb, 0xa2, 0x4e, 0x57, 0xb6, 0x2b, 0x3c, 0x74, 0xad, 0x09, 0xb9,
+    0x90, 0xd5, 0x10, 0xbc, 0xe2, 0xba, 0x19, 0x34, 0xf6, 0x03, 0xd2, 0xa1, 0x71, 0xcd, 0x59,
+    0x2b, 0xc5, 0x46, 0x53, 0x9a, 0x96, 0xae, 0x68, 0x99, 0x06, 0xcd, 0xca, 0x47, 0xa8, 0xa8,
+    0xb4, 0xe9, 0x0d, 0xbc, 0xce, 0xdd, 0x32, 0x8c, 0x3f, 0x4a, 0xbf, 0x1c, 0x47, 0x35, 0x52,
+    0x7b, 0x73, 0x14, 0xce, 0x31, 0x81, 0x9e, 0x2b, 0x39, 0x45, 0xab, 0x49, 0x0e, 0xe9, 0xe8,
+    0x51, 0x86, 0x12, 0xf2, 0x63, 0xb9, 0x35, 0xd8, 0xc7, 0x06, 0xd4, 0x55, 0x03, 0x80, 0x2b,
+    0x0f, 0x4d, 0xb5, 0xdf, 0x75, 0x18, 0xc7, 0x00, 0xe4, 0xd7, 0x52, 0x13, 0x9a, 0xba, 0x10,
+    0xe5, 0x46, 0x18, 0x87, 0x76, 0x91, 0x99, 0x77, 0x6f, 0xbe, 0x48, 0xc6, 0x3d, 0xeb, 0xb1,
+    0xf0, 0x6e, 0x95, 0xe7, 0xea, 0xb6, 0x08, 0x53, 0x2a, 0xac, 0x1c, 0x8f, 0x61, 0xcd, 0x73,
+    0xcd, 0x0f, 0x99, 0x70, 0x00, 0x19, 0x3d, 0x2b, 0xd4, 0x3c, 0x0b, 0x60, 0x13, 0x54, 0x49,
+    0x18, 0x7d, 0xc4, 0x00, 0x0f, 0xa9, 0x02, 0xaa, 0xa4, 0xb9, 0x62, 0xd9, 0x58, 0x68, 0xf3,
+    0x49, 0x5f, 0x64, 0x33, 0xe2, 0x65, 0x9b, 0x05, 0xb3, 0x27, 0xaa, 0xee, 0x5e, 0x3d, 0xf0,
+    0x6b, 0xcd, 0xd2, 0xcb, 0x67, 0x45, 0xe6, 0xbd, 0xb3, 0xc7, 0x76, 0x1f, 0x6a, 0xb0, 0xdc,
+    0x17, 0x2c, 0x8c, 0xaf, 0xf8, 0x74, 0x35, 0xe6, 0x37, 0x16, 0x82, 0x1e, 0x00, 0xe7, 0xd6,
+    0xb3, 0xc3, 0xca, 0xf4, 0xd2, 0x36, 0xc4, 0x53, 0xe6, 0x9f, 0x3f, 0x72, 0xa5, 0x94, 0x38,
+    0x70, 0x3a, 0xd7, 0xa1, 0xf8, 0x52, 0x3c, 0xdc, 0x2f, 0x1d, 0x17, 0x3f, 0xca, 0xb8, 0x8b,
+    0x48, 0xbe, 0x70, 0x6b, 0xd0, 0xfc, 0x25, 0x13, 0x6f, 0x2d, 0x8e, 0x3e, 0x55, 0xfd, 0x68,
+    0xae, 0xfd, 0xd6, 0x69, 0x86, 0x8d, 0x99, 0xde, 0x8f, 0xba, 0x3e, 0x95, 0xe5, 0x5e, 0x3b,
+    0xb9, 0x09, 0x3c, 0x69, 0x9f, 0xf9, 0x67, 0x90, 0x3f, 0x13, 0xfe, 0x15, 0xea, 0x6e, 0x76,
+    0xa3, 0x1f, 0x41, 0x9a, 0xf1, 0x6f, 0x1c, 0xcb, 0x9d, 0x66, 0x45, 0x27, 0x84, 0x55, 0x1f,
+    0xa6, 0x7f, 0xad, 0x72, 0xe1, 0x95, 0xe6, 0x39, 0x3b, 0x53, 0x93, 0x38, 0x0d, 0x52, 0x63,
+    0x83, 0xea, 0x7b, 0x56, 0x04, 0x50, 0x99, 0xe6, 0xe7, 0xee, 0x8e, 0xa6, 0xb5, 0xaf, 0x83,
+    0x4d, 0x36, 0xd1, 0xf4, 0xa4, 0x8e, 0x15, 0x89, 0x36, 0x81, 0xc7, 0x7f, 0x7a, 0xf4, 0x1a,
+    0xb9, 0xe7, 0xa9, 0xf2, 0xaf, 0x36, 0x31, 0x23, 0x0a, 0xa0, 0x01, 0x80, 0x3a, 0x0a, 0xd2,
+    0xd2, 0xec, 0x92, 0xf6, 0xed, 0x21, 0x62, 0x00, 0x35, 0x4b, 0xf9, 0xd3, 0xe1, 0x95, 0xe0,
+    0x70, 0xc8, 0x48, 0x3e, 0xb4, 0x3b, 0xf4, 0x21, 0x49, 0x5e, 0xec, 0xd7, 0xd7, 0xf4, 0x58,
+    0xb4, 0xd6, 0x50, 0x8e, 0x1b, 0x23, 0xb5, 0x61, 0x31, 0x58, 0x63, 0x2c, 0x6a, 0xdd, 0xcd,
+    0xec, 0xb3, 0x8d, 0xd2, 0xb9, 0x38, 0xf5, 0xac, 0x2b, 0xdb, 0xa2, 0xe7, 0x6a, 0xd4, 0xdf,
+    0x95, 0x6a, 0x69, 0x65, 0x52, 0x5a, 0x6c, 0x53, 0xbe, 0xb8, 0x69, 0x58, 0xf3, 0xc9, 0xfd,
+    0x2b, 0x3e, 0x3b, 0x67, 0x9a, 0x60, 0xa8, 0x32, 0x6a, 0xe2, 0xc2, 0xd2, 0xbe, 0xd5, 0x19,
+    0x26, 0xb6, 0x2d, 0x2c, 0xd6, 0x04, 0xce, 0x39, 0x3d, 0x4f, 0xad, 0x61, 0xc8, 0xea, 0x3b,
+    0xb3, 0x79, 0x4d, 0x41, 0x0c, 0xb4, 0xb4, 0x58, 0x63, 0x03, 0xf3, 0x3e, 0xb5, 0x60, 0xfa,
+    0x0a, 0x7b, 0x7a, 0x0a, 0x69, 0x00, 0x0e, 0x6b, 0xa1, 0x24, 0x8e, 0x66, 0xdb, 0x77, 0x60,
+    0xa3, 0x1c, 0xfe, 0x55, 0x30, 0x4c, 0x82, 0x4d, 0x46, 0x8a, 0x7a, 0x9a, 0x6b, 0xcb, 0xb9,
+    0x82, 0x29, 0xe0, 0x75, 0xa0, 0x9d, 0xd9, 0xd0, 0x5b, 0xf8, 0x46, 0xf3, 0x51, 0xd0, 0x5b,
+    0x56, 0xb5, 0xdb, 0x2c, 0x51, 0x12, 0xaf, 0x1a, 0x9f, 0x9d, 0x71, 0xd7, 0x8e, 0xe3, 0x04,
+    0x56, 0x3a, 0x5a, 0x15, 0x6e, 0x45, 0x77, 0xbf, 0x0d, 0x75, 0xa5, 0xb4, 0xd4, 0x1e, 0xc2,
+    0x56, 0xc4, 0x77, 0x58, 0xd9, 0x9e, 0xce, 0x3b, 0x7e, 0x23, 0xfa, 0x57, 0x55, 0xe2, 0x2f,
+    0x05, 0x5a, 0x6a, 0x9b, 0xee, 0x6c, 0xc2, 0xdb, 0xdd, 0xf5, 0x20, 0x0f, 0x91, 0xcf, 0xbf,
+    0xa1, 0xf7, 0xac, 0x1d, 0x5e, 0x49, 0xf2, 0xc8, 0xed, 0x8e, 0x17, 0xda, 0xd2, 0x53, 0xa7,
+    0xbf, 0x54, 0x79, 0x2c, 0x4a, 0x54, 0x8a, 0xef, 0x3c, 0x05, 0xa8, 0xf9, 0x1a, 0x8c, 0x96,
+    0x8e, 0xdf, 0x2c, 0xeb, 0x91, 0xfe, 0xf0, 0xff, 0x00, 0xeb, 0x66, 0xb9, 0x7b, 0xbd, 0x32,
+    0xe3, 0x4f, 0xb9, 0x6b, 0x7b, 0x98, 0x5a, 0x39, 0x17, 0xa8, 0x23, 0xf9, 0x7a, 0x8a, 0x92,
+    0xc2, 0x67, 0xb4, 0xbc, 0x8a, 0x78, 0xfe, 0xf4, 0x6c, 0x18, 0x55, 0xc9, 0x73, 0x46, 0xc4,
+    0xd1, 0x6e, 0x9c, 0xd3, 0x67, 0xaa, 0x78, 0xa4, 0x99, 0x3c, 0x2b, 0x7c, 0x07, 0x40, 0x83,
+    0xf9, 0x83, 0x5e, 0x1d, 0x78, 0x4f, 0x35, 0xee, 0xea, 0xf1, 0x6a, 0x7a, 0x64, 0x91, 0x67,
+    0x31, 0xdc, 0xc2, 0x40, 0x3f, 0x51, 0x5e, 0x21, 0xaa, 0xdb, 0x3d, 0xad, 0xd4, 0xd0, 0x48,
+    0x30, 0xf1, 0xb9, 0x56, 0xfa, 0x8e, 0x2b, 0x2c, 0x3e, 0x97, 0x46, 0xf8, 0xf5, 0x7b, 0x49,
+    0x1c, 0xd5, 0xdb, 0x6d, 0x0c, 0x49, 0xe9, 0x5c, 0xf4, 0xac, 0x5d, 0xd9, 0x8f, 0x73, 0x5b,
+    0x5a, 0xa3, 0x61, 0xb6, 0x0f, 0xa9, 0xac, 0x67, 0x5c, 0x13, 0x4a, 0xb3, 0xbb, 0xb1, 0x8d,
+    0x25, 0xee, 0x92, 0x5b, 0x27, 0x56, 0xfc, 0x05, 0x6c, 0x40, 0x9b, 0x23, 0x03, 0xf1, 0xaa,
+    0x16, 0xb1, 0xfd, 0xc0, 0x6b, 0x4a, 0xae, 0x9c, 0x6c, 0x85, 0x36, 0x01, 0x77, 0x4a, 0x3d,
+    0x05, 0x32, 0xf2, 0x6d, 0xab, 0xb4, 0x1e, 0x7a, 0x0a, 0x99, 0x46, 0xd5, 0x2d, 0x59, 0xf2,
+    0x93, 0x24, 0x84, 0xd5, 0xcb, 0x44, 0x4c, 0x55, 0xd9, 0x06, 0xda, 0x5c, 0x71, 0x52, 0x84,
+    0xf6, 0xa6, 0x4a, 0x30, 0x98, 0x1d, 0x4d, 0x65, 0xcb, 0x63, 0x52, 0xac, 0xa3, 0xcc, 0x90,
+    0x01, 0xdb, 0x8a, 0x8e, 0xfa, 0x2d, 0xb0, 0x2b, 0x01, 0xf7, 0x4d, 0x5c, 0x82, 0x1e, 0x4b,
+    0x11, 0x4e, 0x9e, 0x1f, 0x32, 0x17, 0x4f, 0x51, 0x51, 0xc9, 0x78, 0xb0, 0xe6, 0xb3, 0x33,
+    0x63, 0x3b, 0xa3, 0xaa, 0x92, 0x0d, 0xb2, 0x1f, 0xce, 0xa7, 0xb7, 0x38, 0xca, 0x9e, 0xa2,
+    0x99, 0x72, 0xb8, 0x60, 0x6b, 0x09, 0x6b, 0x1b, 0x97, 0xd4, 0x73, 0xfc, 0xf1, 0x67, 0xda,
+    0xa7, 0xb2, 0xf9, 0xa2, 0xfa, 0x1a, 0xaf, 0x11, 0xdd, 0x19, 0x1e, 0x95, 0x2d, 0x8b, 0xec,
+    0x69, 0x14, 0xfd, 0x69, 0xc1, 0xfb, 0xc9, 0x8a, 0x5b, 0x16, 0x27, 0x6c, 0x0f, 0xa7, 0x35,
+    0x96, 0xc7, 0x24, 0x9f, 0x5a, 0xb9, 0x73, 0x27, 0xc8, 0x7d, 0xea, 0x95, 0x2a, 0xaf, 0x5b,
+    0x04, 0x55, 0x90, 0x52, 0x52, 0xd1, 0x59, 0x14, 0x25, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51,
+    0x40, 0x05, 0x28, 0x19, 0x38, 0x14, 0xb8, 0xfc, 0xe9, 0xea, 0xb8, 0x14, 0xec, 0x00, 0x06,
+    0x05, 0x2d, 0x2e, 0x28, 0xab, 0x42, 0x03, 0x49, 0x4b, 0x49, 0x48, 0x04, 0x3c, 0xfd, 0x28,
+    0xa5, 0xa4, 0xa0, 0x67, 0x55, 0x7f, 0x68, 0xf1, 0x85, 0xb8, 0xdb, 0xf7, 0x38, 0x7f, 0x75,
+    0xaa, 0x7a, 0x5c, 0x86, 0xda, 0xf2, 0x4b, 0x22, 0x7e, 0x46, 0xf9, 0xe3, 0xae, 0xb1, 0x95,
+    0x1d, 0x0a, 0xb0, 0xc8, 0x23, 0x04, 0x57, 0x1f, 0xa8, 0x42, 0xf6, 0x92, 0xef, 0x5f, 0xbf,
+    0x6c, 0xfc, 0x1f, 0x55, 0xed, 0xfa, 0x57, 0x6c, 0xb4, 0x7c, 0xc8, 0xe7, 0x8e, 0xab, 0x95,
+    0x9d, 0x34, 0x9a, 0x4d, 0xbd, 0xf5, 0xb8, 0x12, 0x0d, 0xae, 0x39, 0x57, 0x5e, 0xaa, 0x6b,
+    0x06, 0x7b, 0x7b, 0x8b, 0x0b, 0xc5, 0x59, 0x1b, 0xcb, 0xb8, 0x1f, 0xea, 0xa6, 0x1d, 0x1c,
+    0x7a, 0x1f, 0xf0, 0xad, 0xeb, 0x3b, 0xe1, 0x24, 0x48, 0xc0, 0xfc, 0xac, 0x01, 0x15, 0x66,
+    0xe6, 0x28, 0x2f, 0xad, 0x8c, 0x53, 0x00, 0xca, 0x7f, 0x30, 0x7d, 0x45, 0x36, 0xaf, 0xa9,
+    0x10, 0x95, 0xb4, 0x65, 0x7d, 0x33, 0x57, 0x5b, 0xb5, 0x30, 0xcc, 0x02, 0x4e, 0xa3, 0x0e,
+    0x87, 0xb8, 0xf5, 0x1e, 0xd5, 0xcd, 0xdc, 0xee, 0xd3, 0xee, 0xdc, 0x2f, 0xde, 0xb5, 0x98,
+    0x48, 0x9f, 0xee, 0xf5, 0xfe, 0x55, 0x2d, 0xc4, 0x13, 0x5a, 0x5d, 0x2c, 0x4c, 0xe4, 0x4a,
+    0xbc, 0xc1, 0x37, 0xf7, 0x87, 0xa1, 0xa8, 0xaf, 0xe6, 0x5b, 0xa9, 0xa1, 0x99, 0xd7, 0x6b,
+    0x48, 0xa6, 0x19, 0x97, 0xd0, 0xf6, 0xa9, 0x93, 0xd0, 0xd2, 0x2a, 0xcf, 0x4d, 0x8e, 0xf6,
+    0x19, 0x16, 0x68, 0x52, 0x54, 0x3f, 0x2b, 0xa8, 0x61, 0xf8, 0xd5, 0x6d, 0x56, 0xcf, 0xed,
+    0xda, 0x64, 0xf0, 0x7f, 0x11, 0x5c, 0xa7, 0xb3, 0x0e, 0x45, 0x52, 0xf0, 0xbd, 0xc3, 0x4d,
+    0xa3, 0xac, 0x4e, 0x72, 0xf6, 0xec, 0x63, 0x3f, 0x87, 0x4a, 0xdb, 0xc5, 0x5a, 0xd5, 0x0a,
+    0xc7, 0x97, 0x5f, 0xa7, 0x98, 0xf6, 0xf7, 0x00, 0x63, 0xcd, 0x01, 0x5b, 0xd8, 0xff, 0x00,
+    0x9f, 0xe5, 0x57, 0x3c, 0x49, 0x6b, 0xf6, 0x4d, 0x66, 0x22, 0xa3, 0x0a, 0xf1, 0x26, 0x3f,
+    0x01, 0x8f, 0xe9, 0x53, 0xeb, 0x56, 0x7e, 0x4c, 0xd7, 0xd0, 0x28, 0xe1, 0x1f, 0xce, 0x8f,
+    0x8e, 0xc7, 0x9f, 0xf1, 0xab, 0x5e, 0x24, 0x0b, 0x7b, 0xa0, 0xe9, 0xfa, 0x8a, 0x72, 0xc0,
+    0x00, 0xdf, 0x88, 0xe7, 0xf5, 0x15, 0x84, 0xe3, 0xa3, 0xfb, 0xcd, 0x2f, 0xaa, 0x1f, 0x6c,
+    0x3c, 0xab, 0x4b, 0x2b, 0xd0, 0x7f, 0xd5, 0x4c, 0x32, 0x7d, 0x8f, 0x06, 0xbb, 0xe8, 0x1f,
+    0x18, 0x23, 0xf0, 0xae, 0x03, 0x4c, 0x3f, 0x6a, 0xf0, 0xfd, 0xc4, 0x3d, 0x59, 0x41, 0x20,
+    0x7e, 0xb5, 0xd2, 0x69, 0x3a, 0xa2, 0xcf, 0xa7, 0x5b, 0xbb, 0x1f, 0x9b, 0x60, 0x0d, 0xf5,
+    0x1c, 0x56, 0xcb, 0x54, 0x8c, 0xd3, 0xb3, 0x77, 0x3d, 0x33, 0x45, 0xd7, 0xda, 0xca, 0xce,
+    0x44, 0x40, 0x37, 0x30, 0xea, 0x7b, 0x53, 0x5b, 0x52, 0x69, 0xdc, 0xb4, 0x8e, 0x58, 0x9f,
+    0x53, 0x5c, 0x6c, 0x17, 0x80, 0xf4, 0x6c, 0x55, 0xe8, 0xae, 0x88, 0xef, 0x59, 0xba, 0x6a,
+    0xf7, 0x3a, 0x95, 0x66, 0xd5, 0x8e, 0xf3, 0x44, 0xd5, 0x4c, 0x57, 0x02, 0x26, 0x6c, 0xc6,
+    0xfc, 0x60, 0xf6, 0xa5, 0xd6, 0xf4, 0xe2, 0x6f, 0x95, 0xa2, 0x5c, 0xac, 0xbd, 0x38, 0xef,
+    0x5c, 0xb5, 0x9d, 0xd9, 0x59, 0x51, 0xb3, 0xd0, 0xd7, 0xa3, 0x47, 0x71, 0x1c, 0x96, 0x29,
+    0x70, 0xfd, 0x97, 0x76, 0x6b, 0x19, 0xfb, 0x8e, 0xe8, 0xea, 0xa6, 0xf9, 0xe3, 0x66, 0x50,
+    0xb6, 0xd3, 0xec, 0xb4, 0xbb, 0x51, 0x35, 0xd6, 0xd2, 0xf8, 0xcf, 0x35, 0xca, 0xf8, 0x87,
+    0x5a, 0x17, 0x24, 0xa4, 0x48, 0x14, 0x74, 0x14, 0xed, 0x63, 0x55, 0x7b, 0xb9, 0x99, 0x89,
+    0xc2, 0xff, 0x00, 0x08, 0xf4, 0x15, 0xcd, 0x4f, 0x26, 0x4e, 0x6b, 0x4a, 0x70, 0xd6, 0xec,
+    0xc6, 0xad, 0x4d, 0x39, 0x63, 0xb1, 0x4a, 0x45, 0x24, 0xe7, 0xbd, 0x73, 0x7e, 0x2e, 0xb4,
+    0x92, 0x4d, 0x29, 0x6e, 0x62, 0x07, 0xcc, 0xb6, 0x90, 0x3f, 0x1e, 0x9d, 0xeb, 0xa4, 0x77,
+    0x24, 0xd4, 0x2c, 0xab, 0x22, 0x95, 0x70, 0x19, 0x48, 0xc1, 0x07, 0xb8, 0xae, 0x86, 0xae,
+    0xac, 0x71, 0x3d, 0xce, 0x5b, 0xc2, 0x81, 0xb5, 0x2b, 0xeb, 0xbd, 0x4e, 0x6e, 0x5f, 0x0b,
+    0x1a, 0xfb, 0x7a, 0xff, 0x00, 0x21, 0x5d, 0xca, 0xc4, 0xa1, 0x70, 0x07, 0x18, 0xac, 0x5d,
+    0x3b, 0x4c, 0xb6, 0xd2, 0xd2, 0x44, 0xb5, 0x56, 0x55, 0x91, 0xb7, 0x10, 0x4e, 0x6a, 0xf8,
+    0x91, 0xc0, 0xc0, 0x63, 0x8a, 0x12, 0x69, 0x6a, 0x34, 0xd1, 0xcc, 0xce, 0xc0, 0x78, 0x87,
+    0x50, 0x39, 0xe8, 0x15, 0x47, 0xd0, 0x01, 0x50, 0x4e, 0x4e, 0x5b, 0x15, 0x5e, 0xf6, 0x43,
+    0x1f, 0x8a, 0xae, 0xe2, 0x3d, 0x1d, 0x43, 0x0f, 0xc8, 0x54, 0xce, 0xdb, 0x54, 0xb1, 0xec,
+    0x33, 0x57, 0x07, 0x74, 0x61, 0x35, 0xef, 0x5c, 0xa5, 0xa2, 0x59, 0xff, 0x00, 0x68, 0xeb,
+    0xed, 0x24, 0x83, 0x30, 0xda, 0x73, 0x8f, 0x56, 0xed, 0xfe, 0x7d, 0xab, 0xb7, 0xae, 0x73,
+    0xc1, 0x83, 0x76, 0x9d, 0x73, 0x26, 0xd1, 0x96, 0x9c, 0x92, 0x7d, 0x78, 0x15, 0xd2, 0x54,
+    0xd3, 0xda, 0xfd, 0xcd, 0x25, 0xb9, 0x43, 0x5a, 0x24, 0x68, 0x97, 0xb8, 0xeb, 0xe4, 0xb7,
+    0xf2, 0xae, 0x03, 0x4e, 0xc0, 0xb0, 0xce, 0x7f, 0x88, 0xe6, 0xbd, 0x26, 0x78, 0x96, 0x7b,
+    0x79, 0x21, 0x6f, 0xba, 0xea, 0x54, 0xfe, 0x35, 0xe6, 0x4b, 0x6b, 0x75, 0x15, 0xeb, 0xe8,
+    0xfb, 0x71, 0x2b, 0xca, 0x14, 0x13, 0xe9, 0xeb, 0xf4, 0xc7, 0x35, 0x15, 0x5f, 0x2c, 0x93,
+    0x2a, 0x1d, 0x4b, 0x1a, 0x66, 0x9f, 0x37, 0x88, 0x35, 0x20, 0x83, 0x2b, 0x6b, 0x19, 0xcb,
+    0xbf, 0xa0, 0xff, 0x00, 0x13, 0x5e, 0x8f, 0x6f, 0x6f, 0x15, 0xac, 0x09, 0x0c, 0x28, 0x12,
+    0x34, 0x18, 0x00, 0x55, 0x7d, 0x33, 0x4e, 0x87, 0x4b, 0xb1, 0x4b, 0x68, 0x40, 0xc2, 0x8c,
+    0xb3, 0x77, 0x63, 0xdc, 0xd5, 0xd1, 0x57, 0x4e, 0x1c, 0xaa, 0xef, 0x71, 0x49, 0xdd, 0x8e,
+    0x15, 0xe7, 0xde, 0x3b, 0xb6, 0xf2, 0xf5, 0x68, 0x67, 0x03, 0x89, 0x63, 0xc1, 0xfa, 0x83,
+    0xff, 0x00, 0xea, 0xaf, 0x41, 0x02, 0xb9, 0x7f, 0x1d, 0x5a, 0xf9, 0xba, 0x4c, 0x57, 0x00,
+    0x73, 0x0c, 0x9c, 0x9f, 0x63, 0xfe, 0x45, 0x15, 0xe3, 0x7a, 0x6c, 0xa8, 0xee, 0x79, 0xe5,
+    0x2d, 0x14, 0x57, 0x96, 0x6c, 0x14, 0x51, 0x45, 0x00, 0x14, 0x55, 0xad, 0x3a, 0xd0, 0xdf,
+    0xea, 0x36, 0xf6, 0xa0, 0xed, 0xf3, 0x5c, 0x2e, 0x7d, 0x05, 0x76, 0x37, 0xfe, 0x03, 0x82,
+    0x1b, 0x09, 0x65, 0xb5, 0xb8, 0x95, 0xa6, 0x45, 0x2c, 0x15, 0x80, 0xc3, 0x63, 0xb5, 0x6b,
+    0x0a, 0x32, 0x9a, 0xba, 0x25, 0xc9, 0x23, 0x87, 0x57, 0x65, 0xef, 0x41, 0x72, 0x69, 0xa4,
+    0x60, 0xe2, 0x8a, 0xce, 0xec, 0xa1, 0x55, 0x99, 0x4e, 0x54, 0x90, 0x7d, 0xa9, 0xcf, 0x23,
+    0xca, 0x41, 0x73, 0xb8, 0x8e, 0xe6, 0x99, 0x4b, 0x45, 0xc0, 0x07, 0x5a, 0xf6, 0x9d, 0x1d,
+    0x36, 0xe8, 0xb6, 0x43, 0xd2, 0x14, 0xfe, 0x55, 0xe2, 0xea, 0xac, 0xcc, 0x02, 0x82, 0x4f,
+    0xa0, 0xaf, 0x71, 0xb2, 0x4d, 0x96, 0x36, 0xeb, 0x8c, 0x62, 0x35, 0x1f, 0xa5, 0x76, 0x61,
+    0x16, 0xec, 0x89, 0xee, 0x4c, 0x06, 0x29, 0x1e, 0x18, 0xa6, 0x5d, 0xb2, 0xc4, 0x92, 0x2f,
+    0xa3, 0x28, 0x22, 0x9d, 0x4b, 0x8a, 0xed, 0x15, 0x8a, 0x2d, 0xa0, 0xe9, 0x2e, 0xdb, 0x8e,
+    0x9d, 0x6d, 0x9f, 0x68, 0xc0, 0xa8, 0x5f, 0xc3, 0x3a, 0x4c, 0x87, 0x3f, 0x65, 0xdb, 0xfe,
+    0xeb, 0x11, 0x5b, 0x01, 0x30, 0x39, 0xa7, 0x05, 0xf4, 0x15, 0x3a, 0x0a, 0xc8, 0xe7, 0xdb,
+    0xc1, 0xba, 0x64, 0x9d, 0x04, 0xc9, 0xf4, 0x7a, 0xd7, 0xd2, 0xf4, 0xb8, 0x74, 0x9b, 0x6f,
+    0x22, 0x07, 0x95, 0x90, 0x9c, 0xfe, 0xf1, 0xb3, 0xf9, 0x55, 0xbc, 0xd2, 0xd2, 0x0b, 0x0f,
+    0x02, 0x9c, 0x2a, 0x3c, 0xd4, 0xd0, 0x28, 0x92, 0x4c, 0x1f, 0xca, 0x82, 0xac, 0x47, 0x24,
+    0x51, 0xca, 0x31, 0x22, 0x2b, 0x0f, 0x71, 0x54, 0xe4, 0xd2, 0xa3, 0xce, 0xe8, 0x24, 0x78,
+    0x9b, 0xdb, 0x91, 0x5a, 0xb3, 0xc6, 0x23, 0x50, 0x71, 0x82, 0x7b, 0x54, 0x19, 0xa1, 0x31,
+    0x4a, 0x09, 0xee, 0x65, 0x4d, 0xfd, 0xa7, 0x6c, 0x3f, 0xd4, 0xad, 0xca, 0x0f, 0xee, 0x1c,
+    0x35, 0x67, 0x3f, 0x89, 0x2d, 0xa2, 0x7d, 0x93, 0xc3, 0x3c, 0x2f, 0xe8, 0xe9, 0x5d, 0x3e,
+    0x6a, 0x39, 0xed, 0xad, 0xee, 0x93, 0x65, 0xc4, 0x31, 0xca, 0xa7, 0xb3, 0xa8, 0x34, 0x68,
+    0x47, 0x23, 0xee, 0x72, 0xed, 0xe2, 0x54, 0x62, 0x4c, 0x36, 0xb7, 0x12, 0x2f, 0xf7, 0x95,
+    0x69, 0xbf, 0xf0, 0x94, 0xdb, 0xa7, 0xfa, 0xeb, 0x6b, 0x84, 0xfa, 0x8a, 0xd1, 0x9f, 0xc2,
+    0x76, 0x9b, 0xfc, 0xcb, 0x29, 0xa6, 0xb4, 0x93, 0xfd, 0x86, 0xc8, 0xfc, 0xaa, 0x3f, 0xb0,
+    0xea, 0xd6, 0x9f, 0x7a, 0x28, 0x6f, 0x23, 0x1f, 0xc5, 0xd1, 0xa9, 0x59, 0x92, 0xd3, 0x43,
+    0x20, 0xf1, 0x16, 0x9d, 0x72, 0xe0, 0x23, 0xc8, 0x87, 0xd5, 0x90, 0x81, 0xf9, 0xd6, 0xee,
+    0x9d, 0xab, 0xc9, 0x6e, 0xeb, 0x25, 0xbd, 0xca, 0x9f, 0x65, 0x6c, 0xd6, 0x37, 0x9b, 0x65,
+    0x29, 0xf2, 0xee, 0xad, 0xc4, 0x6d, 0xdc, 0x3a, 0xd4, 0xab, 0xa5, 0xd9, 0x37, 0xcd, 0x10,
+    0xd9, 0x9e, 0x8d, 0x19, 0xa1, 0xae, 0x8c, 0x4a, 0x4f, 0x78, 0x9e, 0x9b, 0xa5, 0x78, 0xa6,
+    0x2b, 0x85, 0x09, 0x76, 0x36, 0x39, 0xfe, 0x3c, 0x70, 0x69, 0xba, 0xc7, 0x83, 0xf4, 0xed,
+    0x5d, 0xfe, 0xdb, 0x68, 0xe6, 0xce, 0xf4, 0xf2, 0x2e, 0x20, 0xe8, 0xff, 0x00, 0xef, 0x0e,
+    0x87, 0xf9, 0xd7, 0x9c, 0x24, 0x17, 0xf6, 0xe7, 0xfd, 0x1a, 0xe4, 0x48, 0xbf, 0xdd, 0x7e,
+    0x0d, 0x6a, 0x69, 0xfe, 0x2d, 0xd4, 0x74, 0x87, 0x0b, 0x71, 0x0b, 0x08, 0xfb, 0x81, 0xca,
+    0x9a, 0xc5, 0xd2, 0x69, 0xf3, 0x53, 0x67, 0x42, 0xae, 0x9a, 0xe5, 0xa8, 0x8b, 0x57, 0x70,
+    0xea, 0x1a, 0x33, 0x88, 0xf5, 0x58, 0x71, 0x1e, 0x70, 0xb7, 0x51, 0x8c, 0xc6, 0xdf, 0x5f,
+    0xee, 0xfe, 0x34, 0xf0, 0xca, 0xca, 0x19, 0x48, 0x20, 0xf4, 0x22, 0xba, 0x1b, 0x4f, 0x1b,
+    0x68, 0xb7, 0xf0, 0x14, 0xb9, 0x91, 0x50, 0x30, 0xc3, 0x2b, 0x8c, 0xa9, 0xae, 0x4f, 0x59,
+    0xf2, 0xed, 0xb5, 0x01, 0x71, 0xa0, 0xa3, 0x49, 0x64, 0xe3, 0xe7, 0x8c, 0x29, 0xd8, 0x1b,
+    0xfd, 0x9f, 0x4a, 0xb8, 0x49, 0xbd, 0x24, 0xac, 0xc2, 0x56, 0x8a, 0xbc, 0x5d, 0xd7, 0xe2,
+    0x5b, 0xa6, 0xe2, 0xab, 0xdb, 0x5f, 0x47, 0x72, 0x31, 0xca, 0x48, 0x3a, 0xa3, 0x75, 0xa9,
+    0xc9, 0xab, 0xb0, 0x26, 0x9a, 0xd0, 0x69, 0x15, 0x19, 0xa9, 0x09, 0xa8, 0xcd, 0x03, 0x1a,
+    0x69, 0xc3, 0xb5, 0x34, 0xd2, 0xad, 0x0d, 0x01, 0x72, 0xd2, 0x53, 0x1b, 0x8a, 0xdb, 0x5b,
+    0x71, 0x72, 0x81, 0x80, 0xe6, 0xb9, 0xe0, 0x08, 0xe6, 0xb5, 0xf4, 0xfb, 0xd3, 0x13, 0x00,
+    0x7a, 0x56, 0x53, 0x5d, 0x51, 0xac, 0x1f, 0x46, 0x69, 0x43, 0x68, 0x4c, 0x65, 0x18, 0x56,
+    0x65, 0xd5, 0x91, 0x49, 0x08, 0xc5, 0x74, 0xb6, 0xef, 0x1c, 0xca, 0x19, 0x4f, 0x5a, 0x26,
+    0xb6, 0x47, 0x70, 0x4a, 0xe6, 0xb0, 0xe6, 0xb3, 0x3a, 0x1c, 0x2e, 0x8e, 0x44, 0xe9, 0xf2,
+    0xbf, 0x44, 0x3f, 0x95, 0x53, 0xb8, 0xb6, 0x78, 0xb8, 0x65, 0xc5, 0x77, 0x52, 0xbc, 0x36,
+    0xf1, 0x92, 0x70, 0x31, 0x5c, 0xbe, 0xab, 0x72, 0x93, 0xc8, 0x4a, 0x8c, 0x0a, 0xd6, 0x12,
+    0x6d, 0x99, 0x54, 0xa6, 0xa2, 0x8c, 0x17, 0x5e, 0x2a, 0x13, 0xc0, 0x39, 0xed, 0x56, 0x5e,
+    0xa8, 0xde, 0xc9, 0xe5, 0x5b, 0x4a, 0xde, 0x82, 0xb7, 0x48, 0xe6, 0x96, 0x8a, 0xe7, 0x21,
+    0x7f, 0x20, 0x9f, 0x54, 0x9a, 0x52, 0x7e, 0x58, 0xc6, 0x05, 0x72, 0x3a, 0xb4, 0x9e, 0x6d,
+    0xe1, 0xf4, 0x51, 0x9a, 0xe8, 0x66, 0x9c, 0x15, 0x70, 0x0e, 0x4b, 0x36, 0x5a, 0xb9, 0x6b,
+    0x86, 0xdf, 0x73, 0x23, 0x7b, 0xe2, 0xb3, 0xc4, 0x3f, 0x75, 0x23, 0x1a, 0x4b, 0x56, 0xd8,
+    0xf5, 0xf9, 0x6d, 0xdf, 0xd4, 0xe0, 0x51, 0xa5, 0x43, 0xf6, 0x8d, 0x52, 0x14, 0xec, 0x5b,
+    0x27, 0xe8, 0x29, 0x8e, 0x71, 0x09, 0xad, 0x3f, 0x0b, 0xc4, 0x1f, 0x50, 0x91, 0xcf, 0xf0,
+    0x21, 0xc7, 0xe3, 0x5c, 0xf0, 0x57, 0x9c, 0x51, 0xac, 0xdd, 0xa2, 0xd9, 0xb3, 0x77, 0xf3,
+    0xc5, 0x3f, 0xd1, 0x85, 0x71, 0x0f, 0xf7, 0x8d, 0x76, 0xc4, 0xef, 0x49, 0x7d, 0xd9, 0x85,
+    0x71, 0x92, 0x2e, 0x1c, 0x8f, 0x7a, 0xd7, 0x16, 0xb6, 0x66, 0x74, 0x34, 0xba, 0x25, 0xb1,
+    0xff, 0x00, 0x8f, 0x84, 0xfa, 0xd7, 0x5b, 0x6a, 0x3f, 0x70, 0xb5, 0xca, 0x59, 0x0f, 0xdf,
+    0xa7, 0xd6, 0xba, 0xeb, 0x51, 0xfb, 0x85, 0xf6, 0xaa, 0xc2, 0xec, 0xc9, 0xc4, 0x6c, 0x44,
+    0xc3, 0x32, 0xb7, 0xd6, 0xa0, 0x31, 0x9d, 0xe4, 0x55, 0xff, 0x00, 0x2b, 0xf7, 0x84, 0xfb,
+    0xd2, 0x34, 0x39, 0x94, 0xd7, 0x4d, 0x8c, 0x54, 0xd2, 0x2a, 0x79, 0x59, 0xc5, 0x27, 0x95,
+    0xf3, 0x55, 0xf1, 0x08, 0xa0, 0x41, 0xcd, 0x16, 0x0f, 0x6a, 0x57, 0x8a, 0x1e, 0x7a, 0x53,
+    0x75, 0x38, 0x97, 0xf7, 0x60, 0x01, 0x9c, 0x7f, 0x5a, 0xd1, 0x8e, 0x30, 0x3a, 0x0a, 0xab,
+    0x7b, 0xf3, 0x4c, 0x07, 0xa0, 0xa6, 0xd6, 0x82, 0x8c, 0x9b, 0x95, 0xc4, 0xd2, 0xa0, 0xc3,
+    0x96, 0xc7, 0x41, 0x8a, 0xd8, 0x55, 0xc9, 0xc0, 0xeb, 0x55, 0xac, 0x21, 0xdb, 0x0e, 0x4f,
+    0x7a, 0xd2, 0x8a, 0x3c, 0x36, 0x4f, 0x1e, 0xd4, 0x2d, 0x03, 0xe2, 0x77, 0x24, 0xd3, 0x6d,
+    0xbc, 0xcb, 0xb5, 0x38, 0xef, 0xd6, 0xbd, 0x47, 0xc2, 0x31, 0x85, 0x99, 0x98, 0x7f, 0x79,
+    0x07, 0xeb, 0x5e, 0x7d, 0xa5, 0x28, 0xf3, 0x41, 0xfd, 0x2b, 0xd1, 0xfc, 0x31, 0xf2, 0x92,
+    0x4f, 0x4d, 0xc9, 0xfc, 0xcd, 0x73, 0xe2, 0x1f, 0xba, 0xce, 0xfc, 0x2c, 0x6c, 0x74, 0xda,
+    0xbd, 0xb2, 0xdc, 0x5a, 0x30, 0x23, 0x82, 0x0a, 0x9f, 0xa1, 0xaf, 0x2a, 0xd4, 0x2c, 0xd9,
+    0x65, 0x65, 0x2b, 0x86, 0x07, 0x06, 0xbd, 0x8a, 0x44, 0x12, 0x44, 0xc8, 0x7b, 0x8c, 0x57,
+    0x03, 0xae, 0x59, 0x05, 0xb8, 0x67, 0xc7, 0xde, 0xe4, 0x8f, 0x7a, 0xe6, 0xc3, 0xce, 0xce,
+    0xc6, 0xb6, 0xe6, 0x87, 0xa1, 0xc7, 0xdb, 0xc1, 0x87, 0xe4, 0x60, 0x57, 0xa5, 0x78, 0x68,
+    0x23, 0xc1, 0x01, 0x41, 0x81, 0x93, 0xfa, 0x0a, 0xe1, 0x4d, 0xb9, 0xdf, 0x5e, 0x8b, 0xe1,
+    0xeb, 0x73, 0x0d, 0xb4, 0x4a, 0x7f, 0x86, 0x31, 0x9f, 0xa9, 0xe6, 0xb4, 0xc4, 0x4b, 0xdd,
+    0x1d, 0x25, 0xca, 0xa4, 0x6b, 0x5d, 0xbe, 0xdb, 0x59, 0x0f, 0xa8, 0xc7, 0xe7, 0x5e, 0x11,
+    0xe2, 0xab, 0x81, 0x3e, 0xad, 0x74, 0xe0, 0xe4, 0x19, 0x08, 0x1f, 0x41, 0xc5, 0x7b, 0x56,
+    0xb5, 0x72, 0x2d, 0xec, 0xd9, 0xb8, 0xf9, 0x15, 0xa4, 0x3f, 0x80, 0xaf, 0x0b, 0xbe, 0x05,
+    0xe5, 0x69, 0x1f, 0xa9, 0x39, 0xa5, 0x84, 0x5b, 0xb3, 0x1a, 0xda, 0x52, 0x4b, 0xb9, 0x82,
+    0xd0, 0xed, 0xcb, 0x1e, 0xa7, 0xf4, 0xaa, 0xcc, 0x73, 0x57, 0x6e, 0x0f, 0x6a, 0xa6, 0x45,
+    0x76, 0x9e, 0x63, 0x23, 0x38, 0x51, 0x93, 0x46, 0x78, 0xc9, 0xa7, 0xe0, 0x0e, 0x4d, 0x67,
+    0xdd, 0xdd, 0x63, 0x28, 0x9d, 0x68, 0x6e, 0xc3, 0x8c, 0x5c, 0x9d, 0x90, 0xcb, 0xcb, 0xbe,
+    0x76, 0x29, 0xaa, 0x0a, 0x8d, 0x23, 0xe0, 0x7e, 0x74, 0xf5, 0x46, 0x91, 0xbf, 0x99, 0xad,
+    0x2b, 0x6b, 0x60, 0x8a, 0x09, 0x1f, 0x4a, 0xca, 0xce, 0x4c, 0xea, 0x6d, 0x53, 0x88, 0x5a,
+    0xda, 0x2c, 0x4b, 0x92, 0x39, 0xa9, 0xd8, 0xf6, 0xa7, 0x31, 0xc0, 0xe2, 0x9a, 0x00, 0xc6,
+    0x4d, 0x5d, 0xad, 0xa1, 0xcc, 0xdb, 0x93, 0xbb, 0x1a, 0x78, 0x14, 0x22, 0x16, 0xf9, 0x8d,
+    0x3f, 0x66, 0x4f, 0xb5, 0x47, 0x71, 0x30, 0x8d, 0x30, 0x3a, 0xd0, 0x0b, 0x5d, 0x11, 0x15,
+    0xcc, 0xfb, 0x06, 0xc5, 0x3f, 0x31, 0xfd, 0x2a, 0x28, 0x5b, 0x91, 0x55, 0xdb, 0x2c, 0xd9,
+    0xea, 0x4d, 0x4b, 0x10, 0x39, 0xcf, 0x6a, 0x46, 0xfc, 0xa9, 0x46, 0xc6, 0xdd, 0x9c, 0x8d,
+    0x1b, 0x2b, 0xa3, 0x15, 0x60, 0x72, 0x08, 0xea, 0x0d, 0x7b, 0x4f, 0x84, 0xfc, 0x49, 0x1e,
+    0xb9, 0x62, 0xb1, 0xca, 0xc0, 0x5e, 0xc4, 0x31, 0x22, 0xff, 0x00, 0x7c, 0x7f, 0x78, 0x57,
+    0x86, 0x41, 0x26, 0x2b, 0x63, 0x4e, 0xd4, 0x27, 0xb1, 0xb9, 0x8e, 0xe6, 0xda, 0x42, 0x92,
+    0xa1, 0xc8, 0x22, 0xb3, 0xab, 0x4d, 0x4d, 0x15, 0x86, 0xae, 0xe8, 0xcb, 0xc8, 0xf6, 0xed,
+    0x57, 0x47, 0xb4, 0xd6, 0x2d, 0xbc, 0xab, 0x84, 0xf9, 0x87, 0xdc, 0x90, 0x7d, 0xe4, 0x3e,
+    0xdf, 0xe1, 0x5e, 0x6b, 0xab, 0x68, 0x97, 0x3a, 0x3d, 0xcf, 0x97, 0x30, 0xca, 0x1f, 0xb9,
+    0x20, 0x1c, 0x30, 0xff, 0x00, 0x3d, 0xab, 0xb8, 0xf0, 0xf7, 0x8b, 0xac, 0xf5, 0x98, 0x15,
+    0x24, 0x65, 0x86, 0xec, 0x0f, 0x9a, 0x32, 0x78, 0x6f, 0x75, 0xff, 0x00, 0x0a, 0xd7, 0xbd,
+    0xb4, 0xb7, 0xd4, 0xac, 0xde, 0x09, 0x94, 0x3c, 0x6e, 0x3a, 0x8e, 0xa0, 0xfa, 0x8f, 0x7a,
+    0xe4, 0x84, 0xe5, 0x4d, 0xda, 0x5b, 0x1e, 0xac, 0xe9, 0xc2, 0xbc, 0x79, 0xa3, 0xb9, 0xca,
+    0x78, 0x56, 0xfc, 0xc9, 0xa7, 0x98, 0x09, 0xf9, 0xe1, 0x38, 0x1f, 0x43, 0xd2, 0xb9, 0x7f,
+    0x1f, 0x59, 0x79, 0x5a, 0xa0, 0xbb, 0x55, 0xf9, 0x6e, 0x53, 0x71, 0xff, 0x00, 0x78, 0x70,
+    0x7f, 0xa1, 0xfc, 0x6b, 0x46, 0xde, 0x39, 0x3c, 0x3f, 0xe2, 0x43, 0x69, 0x33, 0x7c, 0x8f,
+    0xf2, 0x86, 0xec, 0xc0, 0xf4, 0x35, 0x77, 0xc5, 0xb6, 0xdf, 0x6d, 0xd0, 0x1d, 0xc0, 0xcb,
+    0xdb, 0xb8, 0x90, 0x7d, 0x0f, 0x07, 0xfc, 0x6b, 0x75, 0xa4, 0xee, 0xba, 0x9c, 0xd3, 0x5c,
+    0xf4, 0x5c, 0x5e, 0xe8, 0xf1, 0x0b, 0xc4, 0x2d, 0x23, 0x13, 0xde, 0xb3, 0x9a, 0x23, 0x9e,
+    0x95, 0xd1, 0xdd, 0xdb, 0x82, 0x4f, 0x15, 0x9e, 0xb6, 0xc4, 0xca, 0x07, 0x61, 0xc9, 0xad,
+    0x27, 0x0b, 0x9c, 0x90, 0x9a, 0xb1, 0x14, 0x71, 0x94, 0xda, 0x40, 0xab, 0x4b, 0x97, 0x20,
+    0x01, 0x52, 0x6c, 0x00, 0xd4, 0xb1, 0x28, 0x1c, 0xd5, 0x5a, 0xc4, 0x4a, 0x64, 0x73, 0x8d,
+    0xb1, 0xec, 0x1d, 0xea, 0xa0, 0xb7, 0xab, 0x92, 0xb0, 0xe5, 0x8d, 0x39, 0x24, 0x41, 0x19,
+    0xc8, 0xe6, 0x82, 0x63, 0x26, 0x96, 0x85, 0x3f, 0x28, 0x0a, 0xa9, 0x28, 0x0c, 0xe7, 0x15,
+    0x6e, 0xe2, 0x60, 0xaa, 0x71, 0xd4, 0xd5, 0x34, 0x6c, 0xbe, 0x7b, 0x0a, 0x89, 0x5b, 0x63,
+    0x68, 0x5e, 0xd7, 0x65, 0x85, 0x50, 0x88, 0x05, 0x31, 0x88, 0xa6, 0x3c, 0xb5, 0x04, 0x93,
+    0x61, 0x49, 0xcd, 0x26, 0xec, 0x0a, 0x2c, 0xcd, 0x93, 0x11, 0xde, 0xbe, 0x3a, 0x13, 0x9a,
+    0x7d, 0xc2, 0xee, 0x83, 0x3e, 0x95, 0x15, 0xc1, 0xcb, 0xab, 0x7e, 0x15, 0x62, 0x3f, 0x9e,
+    0x12, 0x3d, 0x45, 0x72, 0x2d, 0x6e, 0x8d, 0x4a, 0x50, 0xb6, 0x1f, 0x1e, 0xb4, 0xf5, 0x3b,
+    0x27, 0x3e, 0xf5, 0x0f, 0xdd, 0x7f, 0xa1, 0xa9, 0x65, 0xfe, 0x17, 0x15, 0x09, 0xe8, 0x50,
+    0x4e, 0xd9, 0x20, 0x54, 0x34, 0xe9, 0x0f, 0xce, 0x69, 0xb5, 0x32, 0x77, 0x60, 0x14, 0x51,
+    0x45, 0x20, 0x0a, 0x4a, 0x5a, 0x28, 0x01, 0x29, 0xc0, 0x77, 0xa0, 0x0a, 0x78, 0x14, 0xd2,
+    0x01, 0x14, 0x77, 0xa7, 0x81, 0x46, 0x29, 0x6a, 0x92, 0x10, 0x52, 0x52, 0xd1, 0x40, 0x09,
+    0x48, 0x69, 0x69, 0x07, 0x34, 0x00, 0x53, 0x1c, 0xf6, 0xa7, 0xd4, 0x4c, 0x08, 0x3c, 0xd2,
+    0x60, 0x7a, 0x50, 0x6a, 0xc9, 0xd5, 0xe0, 0x05, 0xd2, 0x42, 0x38, 0x90, 0x18, 0xdb, 0xfa,
+    0x7f, 0x5a, 0xd1, 0x0d, 0x55, 0xf5, 0x25, 0xf3, 0x2c, 0x24, 0xc7, 0xde, 0x51, 0xbc, 0x7d,
+    0x47, 0x35, 0xe8, 0x3d, 0x8e, 0x48, 0xbb, 0x33, 0x2f, 0x45, 0x76, 0x36, 0xcf, 0x01, 0x3f,
+    0x34, 0x2e, 0x57, 0xf0, 0xad, 0x78, 0xe4, 0x61, 0xd6, 0xb1, 0xb4, 0xe6, 0x09, 0xac, 0x30,
+    0x07, 0xe5, 0x9e, 0x2c, 0x8f, 0xa8, 0xad, 0x9c, 0x51, 0x0f, 0x86, 0xc2, 0xab, 0xa4, 0x82,
+    0xf6, 0xd1, 0x6f, 0xed, 0x4c, 0x64, 0xe1, 0xc7, 0x28, 0xde, 0x86, 0xb9, 0x79, 0xf7, 0xcf,
+    0x0c, 0x80, 0x8d, 0xb7, 0x30, 0x9f, 0x9d, 0x7d, 0x71, 0xde, 0xba, 0xd8, 0x9b, 0xb5, 0x60,
+    0xf8, 0x8a, 0xd1, 0xad, 0xe7, 0x4d, 0x42, 0x0e, 0x37, 0x7c, 0xaf, 0x8f, 0x5a, 0x9a, 0x8b,
+    0x4b, 0x97, 0x46, 0x5d, 0x0d, 0x0f, 0x0b, 0x5c, 0x62, 0xfe, 0x54, 0xfe, 0x19, 0xe2, 0x12,
+    0x0f, 0xa8, 0xe0, 0xff, 0x00, 0x4a, 0xeb, 0x2b, 0xcf, 0xfc, 0x3f, 0x72, 0x23, 0xbe, 0xb1,
+    0x94, 0xf0, 0x3c, 0xd6, 0x88, 0xfb, 0x06, 0xff, 0x00, 0x22, 0xbd, 0x03, 0x8a, 0x20, 0xee,
+    0xae, 0x68, 0xf7, 0x39, 0x9f, 0x11, 0xc4, 0x13, 0x51, 0xb6, 0x98, 0xfd, 0xd9, 0x63, 0x68,
+    0x9b, 0xf0, 0xe4, 0x7f, 0x33, 0x59, 0x36, 0x9b, 0xee, 0x7c, 0x3b, 0x79, 0x60, 0x79, 0x6b,
+    0x76, 0x25, 0x7e, 0x9d, 0x7f, 0xc6, 0xb6, 0xbc, 0x50, 0xdb, 0xac, 0x44, 0x8b, 0xd6, 0x19,
+    0x03, 0xff, 0x00, 0x8d, 0x65, 0x69, 0x4e, 0xb0, 0xeb, 0x92, 0x21, 0xfb, 0x97, 0x30, 0xfe,
+    0xa3, 0xff, 0x00, 0xad, 0x49, 0xad, 0x7f, 0xae, 0xa4, 0xde, 0xf1, 0xd3, 0xa0, 0xcf, 0x0a,
+    0xcd, 0x99, 0x1e, 0x12, 0x78, 0x74, 0xe9, 0xf4, 0xad, 0x3d, 0x0d, 0x42, 0xb5, 0xe5, 0xa9,
+    0xe0, 0xc3, 0x29, 0xc7, 0xd0, 0xd6, 0x06, 0x94, 0xe6, 0xcf, 0x59, 0xd8, 0x78, 0x09, 0x29,
+    0x53, 0xf4, 0xad, 0xa7, 0x7f, 0xb1, 0x78, 0x9d, 0xb9, 0xc2, 0xdc, 0x47, 0xfa, 0x8a, 0x29,
+    0xbf, 0x75, 0x0a, 0xa2, 0xd5, 0x9b, 0x25, 0x9a, 0x03, 0x90, 0x6b, 0x42, 0xce, 0xf4, 0x36,
+    0x03, 0x1a, 0xc6, 0x69, 0xf7, 0x1c, 0x1a, 0x40, 0xe6, 0x36, 0x0c, 0xa6, 0xb6, 0xb5, 0xcc,
+    0x14, 0xdc, 0x5e, 0x87, 0x6b, 0x6d, 0x36, 0x19, 0x79, 0xae, 0xe4, 0x5f, 0x15, 0xf0, 0xb7,
+    0x07, 0x9f, 0xbb, 0xf8, 0x57, 0x97, 0x69, 0x97, 0xbe, 0x61, 0x55, 0x27, 0x9a, 0xed, 0x2e,
+    0x6e, 0xc4, 0x5a, 0x1c, 0x71, 0x67, 0x93, 0x5c, 0xf5, 0x23, 0xaa, 0x3d, 0x2a, 0x15, 0x34,
+    0x6c, 0xc7, 0xb8, 0xb8, 0x2c, 0xc7, 0x9a, 0xce, 0x91, 0xf3, 0x4e, 0x92, 0x5c, 0x92, 0x73,
+    0x55, 0xd9, 0xb2, 0x6b, 0x54, 0x8c, 0x65, 0x21, 0x09, 0xe6, 0x93, 0x34, 0xdc, 0xe6, 0x93,
+    0x35, 0x66, 0x57, 0x24, 0xcd, 0x2d, 0x47, 0xcd, 0x2e, 0x4f, 0x7a, 0x02, 0xe7, 0x27, 0xe2,
+    0x94, 0xfb, 0x1e, 0xb3, 0x67, 0x7f, 0x8f, 0x91, 0xc7, 0x96, 0xff, 0x00, 0xe7, 0xe8, 0x7f,
+    0x4a, 0x1f, 0xe6, 0x8d, 0xb1, 0xdc, 0x71, 0x5b, 0xba, 0xd6, 0x9e, 0xba, 0xae, 0x99, 0x25,
+    0xb7, 0x01, 0xfe, 0xf4, 0x64, 0xf6, 0x61, 0xd2, 0xb9, 0x2d, 0x2e, 0xe9, 0x99, 0x5a, 0xd2,
+    0x70, 0x56, 0xe2, 0x13, 0xb4, 0xa9, 0xea, 0x71, 0x53, 0x17, 0xcb, 0x2b, 0x3e, 0xa1, 0x25,
+    0x75, 0x75, 0xd0, 0xdb, 0xf0, 0x4b, 0x0f, 0xec, 0x99, 0xd7, 0xba, 0xcc, 0x73, 0xf9, 0x0a,
+    0xe8, 0xf1, 0x5c, 0x8f, 0x85, 0x65, 0x16, 0xda, 0xbd, 0xf5, 0x8b, 0x1c, 0x07, 0xfd, 0xe2,
+    0x0f, 0x5f, 0xf3, 0x9a, 0xeb, 0xe9, 0xd3, 0xf8, 0x6c, 0x39, 0x6e, 0x00, 0x55, 0x49, 0x74,
+    0xcb, 0x69, 0x75, 0x28, 0x6f, 0xd9, 0x3f, 0x7f, 0x12, 0x95, 0x04, 0x77, 0x1e, 0xf5, 0x70,
+    0x51, 0x57, 0x6b, 0x88, 0x29, 0x45, 0x26, 0x33, 0x4a, 0x33, 0x4c, 0x07, 0x55, 0x3d, 0x52,
+    0xd0, 0x5f, 0x69, 0x77, 0x36, 0xc4, 0x72, 0xe8, 0x40, 0xfa, 0xf6, 0xab, 0x94, 0x51, 0xb9,
+    0x67, 0x8a, 0xb2, 0x95, 0x62, 0xa4, 0x60, 0x83, 0x82, 0x29, 0x2b, 0x67, 0xc5, 0x16, 0x3f,
+    0x61, 0xd7, 0xa7, 0x50, 0x30, 0x92, 0x7e, 0xf1, 0x7f, 0x1e, 0xbf, 0xae, 0x6b, 0x1a, 0xbc,
+    0x99, 0xc7, 0x96, 0x4d, 0x1a, 0xa7, 0x75, 0x70, 0xa2, 0x9c, 0xb1, 0xbb, 0x9c, 0x22, 0x33,
+    0x7d, 0x05, 0x5a, 0x8b, 0x4b, 0xbb, 0x97, 0xa4, 0x7b, 0x47, 0xab, 0x1c, 0x51, 0x18, 0x4a,
+    0x5b, 0x21, 0xdc, 0xd1, 0xf0, 0x7c, 0x5e, 0x6f, 0x89, 0xad, 0xbf, 0xd8, 0xdc, 0xdf, 0xa1,
+    0xaf, 0x55, 0xc5, 0x70, 0x9e, 0x0d, 0xd2, 0x64, 0xb5, 0xd5, 0xcc, 0xf2, 0x30, 0x38, 0x88,
+    0x8c, 0x01, 0xeb, 0x8a, 0xef, 0xb1, 0x5e, 0x8d, 0x08, 0x38, 0x42, 0xcc, 0xc5, 0xb4, 0xd9,
+    0xe4, 0x1e, 0x23, 0xb2, 0x16, 0x1a, 0xed, 0xd4, 0x2a, 0x30, 0x85, 0xb7, 0xaf, 0xd0, 0xf3,
+    0x59, 0x8a, 0x8c, 0xe7, 0x0a, 0xa4, 0xfd, 0x05, 0x7a, 0x9e, 0xbd, 0xa4, 0x5b, 0xdd, 0x5c,
+    0xc5, 0x72, 0xe8, 0x0b, 0x63, 0x69, 0x38, 0xcd, 0x53, 0x8a, 0xc2, 0x08, 0xbe, 0xec, 0x43,
+    0xf1, 0xac, 0xde, 0x13, 0x9a, 0x4d, 0xdc, 0x97, 0x59, 0x47, 0x4b, 0x1c, 0x1c, 0x1a, 0x4d,
+    0xed, 0xc6, 0x36, 0x5b, 0xb6, 0x3d, 0x5b, 0x81, 0x5a, 0x96, 0xfe, 0x18, 0x98, 0xe0, 0xcc,
+    0x47, 0xd0, 0x1a, 0xec, 0x56, 0x20, 0x3b, 0x0a, 0x90, 0x28, 0x1d, 0xab, 0x58, 0xe1, 0x29,
+    0xad, 0xf5, 0x33, 0x75, 0xe4, 0xf6, 0x30, 0x2d, 0xb4, 0x06, 0x42, 0xa1, 0x02, 0x2f, 0x3f,
+    0x8d, 0x7a, 0x0a, 0x2e, 0xd4, 0x55, 0xf4, 0x18, 0xac, 0x28, 0x06, 0xe9, 0xe3, 0x5f, 0x56,
+    0x15, 0xbf, 0x5b, 0x72, 0xa8, 0xe8, 0x8b, 0xa5, 0x27, 0x2b, 0xb6, 0x3b, 0x14, 0xa2, 0x92,
+    0x8a, 0x0d, 0x89, 0x47, 0x4a, 0x75, 0x34, 0x74, 0xa7, 0x0a, 0x80, 0x16, 0x8c, 0x56, 0xb5,
+    0xa6, 0x9c, 0x24, 0x55, 0x1b, 0x37, 0xb1, 0x19, 0xa8, 0xef, 0xec, 0x45, 0xb7, 0x21, 0x4a,
+    0x91, 0xd4, 0x52, 0xe6, 0x57, 0xb1, 0x5c, 0x8e, 0xd7, 0x33, 0xa9, 0x54, 0x95, 0x39, 0x14,
+    0x94, 0xb8, 0xaa, 0x11, 0x21, 0x72, 0xdd, 0x49, 0x3f, 0x5a, 0x4c, 0x52, 0x62, 0x97, 0x14,
+    0x00, 0x9c, 0xe7, 0x8a, 0x78, 0x5f, 0x7a, 0x6e, 0x69, 0xf9, 0xa0, 0x12, 0x14, 0x71, 0x4e,
+    0xcd, 0x32, 0x97, 0x34, 0x8a, 0x12, 0x58, 0x21, 0xb8, 0x5d, 0xb2, 0xc6, 0xae, 0x3d, 0xc5,
+    0x67, 0x49, 0xa1, 0x46, 0x09, 0x6b, 0x59, 0xe4, 0x85, 0xbd, 0x33, 0x91, 0x5a, 0x79, 0xa5,
+    0x0d, 0x42, 0x6c, 0x89, 0x42, 0x32, 0xdd, 0x18, 0x86, 0x2d, 0x4a, 0xd8, 0xfe, 0xf1, 0x12,
+    0x64, 0x1f, 0xc4, 0xbd, 0x6a, 0xc4, 0x57, 0x70, 0xb8, 0xd8, 0xe4, 0xa9, 0xfe, 0xeb, 0xd6,
+    0xa0, 0x61, 0x51, 0x4b, 0x04, 0x13, 0x8f, 0xde, 0x46, 0xad, 0xef, 0x46, 0x8c, 0x9e, 0x46,
+    0xb6, 0x65, 0x61, 0x6b, 0x6e, 0x7e, 0x61, 0x14, 0x67, 0xdc, 0x0a, 0xdd, 0xd2, 0x35, 0x51,
+    0xa7, 0xa8, 0x88, 0xa2, 0xbc, 0x5f, 0xdd, 0xc6, 0x31, 0x58, 0x0d, 0xa6, 0xb4, 0x67, 0x75,
+    0xb4, 0xec, 0x9e, 0xc7, 0x91, 0x4d, 0xf3, 0xae, 0xa0, 0x3f, 0xbf, 0x83, 0x70, 0x1f, 0xc4,
+    0x94, 0xa5, 0x0e, 0x64, 0x09, 0xb8, 0xeb, 0x63, 0xb7, 0xbb, 0xd2, 0xb4, 0x6f, 0x11, 0x47,
+    0xbe, 0x26, 0x16, 0xf7, 0x5d, 0x9d, 0x38, 0x39, 0xf7, 0x1d, 0xeb, 0x96, 0xbf, 0xb4, 0xd4,
+    0x74, 0x19, 0x7c, 0xbb, 0xe8, 0xcc, 0xb0, 0x7f, 0x0c, 0xe9, 0xc8, 0x3f, 0x5a, 0x82, 0xdb,
+    0x53, 0x8f, 0x78, 0xd9, 0x29, 0x53, 0xe8, 0xdc, 0x56, 0xfd, 0xae, 0xb8, 0xc6, 0x23, 0x05,
+    0xd2, 0x89, 0xe0, 0x61, 0x82, 0xaf, 0xcf, 0x15, 0x9a, 0xe6, 0x86, 0x9b, 0xa3, 0x4f, 0x76,
+    0x7a, 0xad, 0x19, 0x8d, 0x1c, 0xb1, 0xcc, 0x9b, 0xa3, 0x60, 0xc3, 0xda, 0x94, 0xd5, 0xab,
+    0xcf, 0x0f, 0x43, 0x31, 0x6b, 0xbd, 0x0e, 0x70, 0x8d, 0xd5, 0xa0, 0x63, 0xfc, 0xab, 0x21,
+    0x2f, 0x1e, 0x19, 0x8d, 0xbd, 0xec, 0x66, 0x19, 0x87, 0x1c, 0x8c, 0x03, 0x5a, 0xa6, 0xa5,
+    0xb1, 0x37, 0x6b, 0x49, 0x16, 0xea, 0x48, 0x70, 0x1b, 0x9a, 0x8f, 0x39, 0xa3, 0xa1, 0xa0,
+    0xb2, 0xe3, 0xb2, 0xe2, 0x88, 0x9f, 0x06, 0xa9, 0x97, 0xcf, 0x7a, 0x91, 0x1f, 0xd6, 0xa5,
+    0xa1, 0xdc, 0xdf, 0xd3, 0xef, 0x1a, 0x27, 0x19, 0x3c, 0x77, 0xae, 0x8d, 0x64, 0x0f, 0x18,
+    0x22, 0xb8, 0x88, 0xa4, 0xc1, 0x15, 0xd3, 0x69, 0x97, 0x22, 0x5b, 0x72, 0x84, 0xf2, 0x2b,
+    0x0a, 0x90, 0xea, 0x74, 0xd2, 0x9f, 0x43, 0x3b, 0x52, 0xb9, 0x69, 0x24, 0x2b, 0x9e, 0x07,
+    0x4a, 0xc4, 0x99, 0xba, 0xd6, 0x86, 0xa2, 0xd8, 0x9d, 0x86, 0x7b, 0xd6, 0x4c, 0xad, 0x93,
+    0x5a, 0xc2, 0x3a, 0x18, 0xcd, 0xea, 0x40, 0xe7, 0x9a, 0xe7, 0x7c, 0x55, 0x78, 0xd6, 0xba,
+    0x53, 0x04, 0x3f, 0x3b, 0xf0, 0x2b, 0xa0, 0x63, 0x93, 0x5c, 0x5f, 0x8d, 0xa4, 0x27, 0xec,
+    0xf1, 0x8e, 0x85, 0xb9, 0xad, 0x1e, 0x89, 0xb3, 0x9e, 0x5a, 0xe8, 0x73, 0xc0, 0x94, 0xb5,
+    0x62, 0x7a, 0xe2, 0xb0, 0x73, 0x96, 0x27, 0xd5, 0x8d, 0x6d, 0x4e, 0xc0, 0x59, 0xb8, 0x3e,
+    0x95, 0x8a, 0xa0, 0x9d, 0x95, 0xcb, 0x5d, 0xea, 0x90, 0xe2, 0x3a, 0x5f, 0xf5, 0x75, 0xd0,
+    0xf8, 0x56, 0x02, 0x20, 0xb9, 0x98, 0x8e, 0xa4, 0x28, 0xac, 0x54, 0x80, 0xce, 0x4a, 0x8e,
+    0xc3, 0x35, 0xd6, 0x68, 0x10, 0x79, 0x7a, 0x40, 0xff, 0x00, 0x68, 0x93, 0x55, 0x87, 0x85,
+    0xe7, 0x72, 0x2b, 0x3f, 0x76, 0xc4, 0x56, 0xeb, 0x91, 0x27, 0xfb, 0xe6, 0xb9, 0x4b, 0x98,
+    0xb1, 0x71, 0x20, 0xc7, 0x47, 0x35, 0xd8, 0xda, 0xa6, 0x7c, 0xcf, 0xf7, 0xab, 0x9f, 0xd4,
+    0x2d, 0xf6, 0x6a, 0x13, 0x0f, 0xf6, 0xb3, 0xf9, 0xd6, 0xb8, 0x88, 0xde, 0x28, 0x8a, 0x4f,
+    0xde, 0x68, 0xa5, 0x6c, 0x98, 0x95, 0x0f, 0xbd, 0x75, 0x10, 0x11, 0x1a, 0xe1, 0xb3, 0x82,
+    0x78, 0xac, 0x28, 0x61, 0xe4, 0x1c, 0x57, 0x4a, 0x91, 0xe6, 0x35, 0xe3, 0xb0, 0xa2, 0x84,
+    0x6c, 0x85, 0x5d, 0xe8, 0x89, 0x63, 0x4d, 0xc7, 0x77, 0xad, 0x38, 0xc7, 0x86, 0xa9, 0x60,
+    0x5c, 0xaf, 0xd2, 0xa5, 0x64, 0xe6, 0xba, 0x4e, 0x5b, 0x15, 0x76, 0x60, 0x52, 0x84, 0xa9,
+    0x99, 0x40, 0xa4, 0xdb, 0x40, 0xec, 0x35, 0x46, 0x05, 0x57, 0x16, 0xfb, 0xee, 0x37, 0xbf,
+    0x3e, 0xd5, 0x7d, 0x63, 0xf9, 0x69, 0xd1, 0xc5, 0xcf, 0x1d, 0xfb, 0xd2, 0x1d, 0x99, 0x34,
+    0x11, 0x6d, 0x8c, 0x64, 0x73, 0x53, 0x01, 0x8c, 0xd3, 0x94, 0x60, 0x00, 0x3b, 0x53, 0x4f,
+    0x5a, 0x46, 0xc9, 0x58, 0xbb, 0x60, 0xdb, 0x5b, 0x3d, 0xeb, 0xd0, 0xbc, 0x3f, 0x2e, 0x54,
+    0xa0, 0xfe, 0xee, 0x6b, 0xcd, 0xed, 0x5c, 0x2c, 0x83, 0x9e, 0x2b, 0xb8, 0xf0, 0xec, 0xff,
+    0x00, 0xbf, 0x8f, 0xd0, 0xf1, 0xfa, 0x56, 0x15, 0xd5, 0xe2, 0x76, 0x61, 0x65, 0xaa, 0x3d,
+    0x29, 0x58, 0x32, 0x86, 0x1d, 0x08, 0xc8, 0xac, 0x2d, 0x6a, 0xd4, 0x3b, 0x37, 0xbf, 0xcc,
+    0x3f, 0xad, 0x6b, 0x59, 0xbe, 0xfb, 0x54, 0x3e, 0x83, 0x15, 0x06, 0xa6, 0x9b, 0xa3, 0x46,
+    0xed, 0xca, 0x9f, 0xc6, 0xbc, 0xe8, 0xbb, 0x3b, 0x9b, 0x53, 0xd2, 0x7c, 0xa7, 0x14, 0x96,
+    0x7e, 0x65, 0xda, 0x26, 0x3e, 0x52, 0xc0, 0x13, 0xed, 0x5d, 0xce, 0x9d, 0x1e, 0xd8, 0x0b,
+    0x63, 0xef, 0x1f, 0xd0, 0x7f, 0x93, 0x58, 0xb0, 0xda, 0x05, 0x9c, 0x30, 0x1c, 0xf4, 0x02,
+    0xb7, 0xa4, 0x61, 0x6b, 0x69, 0xc1, 0xe5, 0x46, 0x07, 0xb9, 0xab, 0xab, 0x2b, 0xe8, 0x5c,
+    0xd5, 0x97, 0x2a, 0xdd, 0x9c, 0xcf, 0x8b, 0xaf, 0x42, 0x58, 0x4e, 0x33, 0xf7, 0xc8, 0x8c,
+    0x7d, 0x3b, 0xff, 0x00, 0x9f, 0x7a, 0xf2, 0x4b, 0xf7, 0xe4, 0xfa, 0xd7, 0x73, 0xe2, 0xdb,
+    0xdd, 0xd3, 0x08, 0x01, 0xe2, 0x31, 0xcf, 0xd4, 0xd7, 0x9f, 0x5d, 0xc9, 0x96, 0x35, 0xdb,
+    0x42, 0x3c, 0xb1, 0x39, 0x31, 0x52, 0x57, 0xb2, 0xe8, 0x66, 0xcf, 0xd6, 0xa0, 0x38, 0x1d,
+    0x6a, 0x59, 0x0f, 0x73, 0x59, 0xf7, 0x57, 0x05, 0x46, 0xd5, 0xfb, 0xc6, 0xb7, 0x3c, 0xe4,
+    0x9c, 0x9d, 0x88, 0xae, 0xee, 0xb1, 0xf2, 0x2f, 0x5a, 0xce, 0x0a, 0x64, 0x6c, 0x75, 0x26,
+    0xa5, 0xd8, 0x59, 0xbd, 0x49, 0xad, 0x1b, 0x2b, 0x2f, 0xe2, 0x61, 0xcd, 0x43, 0xd4, 0xe9,
+    0x56, 0xa6, 0x86, 0x5a, 0xda, 0x6d, 0x50, 0x48, 0xff, 0x00, 0xeb, 0xd5, 0xa6, 0x52, 0x2b,
+    0x52, 0x0b, 0x12, 0xc3, 0x81, 0x53, 0x36, 0x96, 0xe0, 0x67, 0x6d, 0x1c, 0xc9, 0x68, 0x62,
+    0xe3, 0x29, 0x6a, 0xcc, 0x22, 0xbe, 0xd4, 0xbb, 0x7d, 0x6a, 0xfc, 0xd6, 0xa5, 0x0d, 0x56,
+    0x64, 0x03, 0xad, 0x52, 0x21, 0xa6, 0x8a, 0xd2, 0x38, 0x45, 0x27, 0x35, 0x9c, 0xee, 0x64,
+    0x90, 0x81, 0xc9, 0xf5, 0xf4, 0xab, 0xd7, 0x31, 0xf9, 0xab, 0x8c, 0xe3, 0xde, 0x98, 0x90,
+    0x04, 0x50, 0x00, 0x00, 0x52, 0x7a, 0x9a, 0x41, 0xa8, 0xab, 0x95, 0x56, 0x13, 0x8e, 0x6a,
+    0x50, 0x98, 0xe9, 0x56, 0x36, 0x01, 0xda, 0x82, 0xa3, 0xb5, 0x03, 0x73, 0xb8, 0xc8, 0xb8,
+    0x35, 0x72, 0x17, 0xc5, 0x54, 0xc8, 0x1d, 0x3f, 0x2a, 0x95, 0x18, 0xf5, 0xef, 0x41, 0x9b,
+    0xde, 0xe6, 0x9c, 0x53, 0x15, 0x60, 0xe8, 0xc5, 0x5c, 0x72, 0x08, 0x35, 0xda, 0xf8, 0x7f,
+    0xc7, 0x6d, 0x69, 0xfb, 0x8d, 0x45, 0x37, 0xa9, 0xe0, 0x4a, 0x3a, 0xfe, 0x35, 0xe7, 0xab,
+    0x21, 0x15, 0x2f, 0x9a, 0x08, 0xf9, 0xaa, 0x25, 0x05, 0x25, 0x66, 0x6d, 0x4a, 0xb4, 0xa9,
+    0xbb, 0xc5, 0x9d, 0xd7, 0x8a, 0xee, 0x7e, 0xd9, 0xf6, 0x6d, 0x42, 0x37, 0x56, 0x03, 0xe5,
+    0xdc, 0xbf, 0x98, 0xad, 0xbb, 0x09, 0xe2, 0xbe, 0x81, 0x03, 0xe0, 0xc7, 0x71, 0x1e, 0xd6,
+    0xfc, 0x45, 0x79, 0x7c, 0x77, 0xf2, 0xc5, 0x0b, 0xdb, 0xef, 0x26, 0x17, 0xea, 0xa7, 0xb1,
+    0xf5, 0xae, 0xa3, 0xc3, 0x37, 0xe5, 0xec, 0xda, 0x22, 0xdf, 0x34, 0x4d, 0x91, 0xf4, 0x35,
+    0x9c, 0xa1, 0x68, 0x9d, 0x54, 0xab, 0xf3, 0x4f, 0xd4, 0xe4, 0xf5, 0x8b, 0x46, 0xb0, 0xbf,
+    0xb8, 0xb5, 0x90, 0x7c, 0xd1, 0xb9, 0x5f, 0xc2, 0xb2, 0x80, 0x0a, 0xa5, 0xbd, 0x6b, 0xb8,
+    0xf8, 0x91, 0x6a, 0x22, 0xb8, 0xb6, 0xd5, 0x11, 0x72, 0x97, 0x51, 0x65, 0xb1, 0xfd, 0xe1,
+    0xd6, 0xbc, 0xde, 0x6d, 0x59, 0x14, 0x63, 0xca, 0x6c, 0x0a, 0xb5, 0x35, 0xca, 0x9b, 0x39,
+    0xa7, 0x4a, 0x51, 0x9b, 0x8a, 0x2e, 0x16, 0xa4, 0xf3, 0xb0, 0x31, 0xda, 0xb3, 0x7f, 0xb5,
+    0xa0, 0x63, 0x83, 0xb9, 0x4f, 0xb8, 0xa9, 0x3e, 0xd0, 0xae, 0xb9, 0x46, 0x04, 0x7b, 0x1a,
+    0x14, 0xd3, 0xd9, 0x8f, 0xd9, 0xbe, 0xa4, 0x93, 0xcf, 0x96, 0x55, 0x1f, 0x5a, 0x8d, 0xa7,
+    0x38, 0xeb, 0x50, 0x17, 0xcb, 0x13, 0x55, 0xae, 0x26, 0xc2, 0xed, 0x07, 0x93, 0x59, 0xca,
+    0x76, 0x35, 0x50, 0x42, 0xcd, 0x70, 0x59, 0x89, 0xcf, 0x1d, 0xa9, 0xd1, 0x92, 0x13, 0xeb,
+    0x54, 0x94, 0xef, 0x70, 0x2a, 0xd1, 0x6a, 0xca, 0x32, 0xbe, 0xa5, 0x58, 0x73, 0x3f, 0xbd,
+    0x41, 0x33, 0xfc, 0x94, 0xa5, 0xaa, 0xb4, 0xaf, 0x96, 0xc7, 0xa5, 0x4c, 0xe5, 0xa0, 0xd2,
+    0x18, 0xc0, 0xb8, 0xc7, 0x7a, 0x96, 0xd5, 0xb8, 0xc5, 0x36, 0x2f, 0xbc, 0x0d, 0x11, 0x9d,
+    0xb7, 0x0c, 0xa3, 0xa1, 0xe6, 0xb3, 0x5a, 0x3b, 0x8c, 0x86, 0xe5, 0x76, 0x4c, 0xd4, 0x7d,
+    0xe8, 0x48, 0xf4, 0xab, 0x37, 0xf1, 0xe0, 0x2b, 0x8a, 0xa9, 0x19, 0xe7, 0x07, 0xbd, 0x4b,
+    0x56, 0x95, 0x81, 0x6c, 0x30, 0x9c, 0xd1, 0x4a, 0x46, 0x09, 0x14, 0x95, 0x03, 0x0a, 0x28,
+    0xa2, 0x80, 0x0a, 0x05, 0x18, 0xa7, 0x81, 0x4d, 0x20, 0x14, 0x0a, 0x70, 0x14, 0x01, 0x4b,
+    0x54, 0x01, 0x45, 0x14, 0x53, 0x10, 0x51, 0x45, 0x21, 0xa4, 0x02, 0x1e, 0x4e, 0x3b, 0x52,
+    0xd1, 0x8e, 0x29, 0xad, 0xcf, 0x1f, 0x9d, 0x00, 0x2f, 0x5e, 0x69, 0x8f, 0xd4, 0x53, 0xfa,
+    0x0a, 0x8c, 0x82, 0x4e, 0x4d, 0x26, 0x33, 0xd0, 0x41, 0xa5, 0x60, 0x1d, 0x19, 0x4f, 0x71,
+    0x8a, 0xe6, 0x6d, 0x7c, 0x47, 0x22, 0x61, 0x6e, 0x50, 0x38, 0xfe, 0xf2, 0xf0, 0x6b, 0x72,
+    0xd3, 0x50, 0xb6, 0xbc, 0x1f, 0xb9, 0x90, 0x13, 0xfd, 0xd3, 0xc1, 0xae, 0xd8, 0xd4, 0x8c,
+    0xb6, 0x38, 0xe5, 0x09, 0x47, 0x73, 0x0a, 0x19, 0x7c, 0xab, 0x9b, 0x26, 0x27, 0x94, 0x94,
+    0xc6, 0x7f, 0x95, 0x74, 0xb8, 0xc5, 0x71, 0xb7, 0xb9, 0x8f, 0x5a, 0x91, 0x72, 0x70, 0x26,
+    0xce, 0x3f, 0x1a, 0xed, 0x71, 0xf2, 0xd1, 0x4a, 0x57, 0xba, 0x2a, 0xb2, 0xd9, 0x8d, 0x53,
+    0x83, 0x45, 0xf4, 0x2b, 0x75, 0x65, 0x24, 0x2c, 0x3e, 0xf0, 0xe3, 0xeb, 0xda, 0x97, 0x14,
+    0xa4, 0x13, 0xc5, 0x6a, 0xd5, 0xcc, 0x53, 0xb1, 0xc4, 0x45, 0x33, 0x5a, 0x4b, 0xe5, 0x1c,
+    0x86, 0x49, 0x55, 0xbf, 0x23, 0x5e, 0x8b, 0xf6, 0x96, 0xd8, 0x39, 0xce, 0x46, 0x6b, 0x87,
+    0xd7, 0x2c, 0xc9, 0xd5, 0x18, 0xa8, 0xc0, 0x65, 0x07, 0xf1, 0xae, 0xaa, 0xcc, 0xb4, 0x96,
+    0x70, 0x16, 0xeb, 0xe5, 0x8f, 0xe5, 0x58, 0xd2, 0x4d, 0x37, 0x16, 0x6f, 0x51, 0xdd, 0x26,
+    0x84, 0xbe, 0x4f, 0xb4, 0x5a, 0xcd, 0x19, 0x19, 0xdc, 0xa4, 0x57, 0x35, 0x14, 0x8c, 0x89,
+    0x61, 0x73, 0xde, 0x27, 0x08, 0xdf, 0x4e, 0x95, 0xd7, 0x15, 0x00, 0x73, 0x5c, 0xcc, 0x91,
+    0xa2, 0xc5, 0x7b, 0x08, 0xfe, 0x07, 0x2c, 0x3f, 0x9d, 0x69, 0x34, 0x4d, 0x37, 0xba, 0x65,
+    0x5b, 0xf4, 0x30, 0xeb, 0x72, 0x38, 0xe8, 0xf8, 0x6a, 0xd7, 0xd6, 0xc1, 0x68, 0x6c, 0x2f,
+    0xd7, 0xaa, 0xb0, 0x0c, 0x7e, 0xbf, 0xe4, 0xd6, 0x56, 0xa9, 0x30, 0x75, 0xb5, 0xb9, 0x1f,
+    0xc4, 0xb8, 0x35, 0xaa, 0x1b, 0xed, 0xbe, 0x17, 0x9d, 0x07, 0x2d, 0x10, 0xc8, 0xfe, 0x7f,
+    0xe3, 0x59, 0xad, 0xe4, 0x97, 0xa9, 0xa3, 0xd9, 0x36, 0x3d, 0x66, 0x19, 0x07, 0x35, 0x75,
+    0x18, 0x32, 0xf3, 0x58, 0x30, 0x48, 0x64, 0x82, 0x37, 0xf5, 0x51, 0x57, 0xad, 0xe7, 0x3d,
+    0x09, 0xe6, 0xb7, 0x4e, 0xe6, 0x73, 0xa7, 0xd8, 0xd4, 0xb0, 0xb8, 0xf2, 0x2f, 0x14, 0x1e,
+    0x99, 0xae, 0xb6, 0x6b, 0xff, 0x00, 0xb4, 0x46, 0xa1, 0x7a, 0x01, 0x5c, 0x0c, 0xd2, 0x15,
+    0x65, 0x71, 0xeb, 0x5d, 0x06, 0x99, 0x71, 0xe7, 0x42, 0x32, 0x69, 0x49, 0x5f, 0x51, 0xc1,
+    0xb8, 0xe9, 0xdc, 0xd2, 0x24, 0x9a, 0x4a, 0x32, 0x69, 0x29, 0x22, 0xc3, 0x02, 0x96, 0x92,
+    0x96, 0x98, 0x85, 0xa3, 0x14, 0x94, 0xb4, 0xc0, 0x36, 0x8a, 0xe7, 0xb5, 0xff, 0x00, 0x0f,
+    0x35, 0xeb, 0x0b, 0xeb, 0x13, 0xb2, 0xf5, 0x3b, 0x74, 0x12, 0x0f, 0xf1, 0xae, 0x84, 0xf0,
+    0x72, 0x3f, 0x11, 0x4b, 0x49, 0xa5, 0x25, 0x66, 0x07, 0x9a, 0x0d, 0x41, 0xe0, 0xbf, 0x82,
+    0xec, 0xa1, 0x8e, 0xee, 0xdd, 0xb6, 0xcb, 0x19, 0xe3, 0x23, 0xbd, 0x7a, 0x34, 0x13, 0x25,
+    0xc4, 0x11, 0xcd, 0x19, 0xca, 0x3a, 0x86, 0x06, 0xb3, 0xb5, 0x7f, 0x0f, 0x59, 0xea, 0xff,
+    0x00, 0x3c, 0x80, 0xc7, 0x38, 0x18, 0x12, 0xa7, 0x5f, 0xc7, 0xd6, 0x99, 0xa0, 0xe9, 0x77,
+    0xba, 0x4c, 0x72, 0xdb, 0x4f, 0x70, 0x93, 0x5b, 0xe7, 0x31, 0x60, 0x1c, 0xad, 0x4c, 0x54,
+    0x94, 0xb5, 0xd8, 0x6e, 0xc6, 0xc5, 0x2d, 0x25, 0x2e, 0x2b, 0x52, 0x45, 0x14, 0xea, 0x4c,
+    0x53, 0x82, 0x9a, 0x77, 0x2a, 0xc2, 0x52, 0x85, 0x34, 0xf0, 0x29, 0x68, 0x19, 0xcd, 0x78,
+    0xab, 0x45, 0x4d, 0x41, 0x20, 0xb8, 0x39, 0xdd, 0x19, 0x2a, 0x71, 0xdc, 0x1f, 0xf3, 0xfa,
+    0xd6, 0x1c, 0x3a, 0x0c, 0x11, 0xe0, 0x94, 0x5c, 0xfb, 0xf3, 0x5d, 0xf4, 0xf1, 0x09, 0xe0,
+    0x78, 0xcf, 0x71, 0x58, 0x82, 0x15, 0x53, 0xf7, 0x46, 0x68, 0x54, 0xe2, 0xdd, 0xda, 0xd4,
+    0xca, 0xa4, 0xa5, 0x1d, 0x11, 0x99, 0x0e, 0x9d, 0x1a, 0x81, 0x85, 0xfe, 0x95, 0x72, 0x3b,
+    0x45, 0x5f, 0xe1, 0x15, 0x6b, 0x81, 0x46, 0xea, 0xd1, 0x23, 0x16, 0xdb, 0xdd, 0x96, 0xf4,
+    0xb8, 0xc2, 0xce, 0xe4, 0x0c, 0x7c, 0xb5, 0xab, 0x59, 0x9a, 0x6b, 0x66, 0x59, 0x07, 0xb5,
+    0x69, 0x52, 0x67, 0x45, 0x25, 0xee, 0x90, 0xde, 0xa6, 0xfb, 0x66, 0xe3, 0x95, 0xe6, 0xb1,
+    0x8b, 0x01, 0x5b, 0xd2, 0x28, 0x78, 0xd9, 0x7d, 0x46, 0x2b, 0x87, 0xb8, 0xd4, 0x5a, 0x39,
+    0x1d, 0x3b, 0xa9, 0x20, 0xd0, 0x9a, 0x4b, 0x52, 0x6a, 0x45, 0xb7, 0xa1, 0xb0, 0x66, 0x03,
+    0xbd, 0x42, 0xf7, 0x6a, 0x3f, 0x88, 0x56, 0x04, 0x9a, 0x83, 0xb7, 0x7a, 0xae, 0xf7, 0x4c,
+    0x7a, 0xb7, 0x1e, 0xe6, 0xa5, 0xd5, 0x8a, 0x12, 0xa2, 0xde, 0xec, 0xeb, 0xb4, 0xab, 0x81,
+    0x71, 0xa9, 0xc4, 0x8a, 0x73, 0x8c, 0x93, 0xf8, 0x57, 0x51, 0x5c, 0x3f, 0x83, 0x88, 0x9f,
+    0x53, 0x9a, 0x40, 0xc0, 0xf9, 0x71, 0x76, 0xf5, 0x27, 0xff, 0x00, 0xd7, 0x5d, 0xbe, 0x68,
+    0x52, 0xe6, 0x57, 0x36, 0x84, 0x54, 0x74, 0x1d, 0xda, 0x8a, 0x40, 0x4f, 0x6a, 0x5c, 0x1e,
+    0xf4, 0xcb, 0x24, 0x4e, 0x56, 0x9c, 0x29, 0x91, 0xfa, 0x53, 0xea, 0x5e, 0xe0, 0x74, 0xde,
+    0x1e, 0xd4, 0xe1, 0x85, 0x8a, 0xdc, 0x75, 0xc6, 0x01, 0xa8, 0x7c, 0x43, 0xa8, 0xc5, 0x75,
+    0x30, 0x58, 0x71, 0xb7, 0xb9, 0xf5, 0xac, 0x10, 0x68, 0xa8, 0xe4, 0x5c, 0xd7, 0x35, 0xf6,
+    0x8f, 0x97, 0x94, 0x70, 0x19, 0xa7, 0xaa, 0xe4, 0x81, 0x4d, 0x4a, 0xb3, 0x6e, 0x9b, 0xa4,
+    0x1e, 0xf5, 0x44, 0x24, 0x0d, 0x03, 0x2a, 0x06, 0xf5, 0xa8, 0x48, 0xad, 0xfb, 0xcb, 0x4d,
+    0xb6, 0x8a, 0xc0, 0x71, 0x8a, 0xc3, 0x75, 0xc1, 0xa5, 0x19, 0x5c, 0xb9, 0x46, 0xc4, 0x47,
+    0x8a, 0x50, 0x68, 0x6a, 0x6d, 0x51, 0x99, 0x26, 0x68, 0xcd, 0x30, 0x1e, 0x28, 0x06, 0x81,
+    0xdc, 0x7e, 0x68, 0xcd, 0x37, 0xad, 0x14, 0x08, 0x76, 0x69, 0x77, 0x1a, 0x65, 0x14, 0x0c,
+    0x90, 0x35, 0x1b, 0xa9, 0x99, 0xa2, 0x90, 0x11, 0xcd, 0x6d, 0x04, 0xe3, 0xe7, 0x41, 0x9f,
+    0x51, 0xc1, 0xaa, 0xc6, 0xd2, 0x7b, 0x73, 0x9b, 0x69, 0xc9, 0x1f, 0xdc, 0x7a, 0xbb, 0x45,
+    0x32, 0x5c, 0x53, 0x2a, 0x47, 0xaa, 0x5c, 0x5a, 0x38, 0x32, 0xc4, 0xe8, 0x47, 0xf1, 0xa7,
+    0x4a, 0xd6, 0x5d, 0x4f, 0x4e, 0xd6, 0x22, 0x10, 0x5f, 0x2a, 0x39, 0xec, 0xfd, 0x18, 0x55,
+    0x43, 0xcd, 0x56, 0x96, 0xc6, 0x09, 0x79, 0x29, 0xb4, 0xfa, 0xaf, 0x14, 0x9c, 0x53, 0x17,
+    0xbc, 0xbc, 0xcb, 0x33, 0xe9, 0x37, 0x76, 0x0a, 0x64, 0xb3, 0x90, 0x5d, 0xda, 0xff, 0x00,
+    0x77, 0xf8, 0x96, 0xa1, 0x86, 0xe1, 0x26, 0x1f, 0x29, 0x21, 0x87, 0x55, 0x3c, 0x11, 0x51,
+    0x44, 0x75, 0x0b, 0x16, 0xcd, 0xb5, 0xc1, 0x75, 0xfe, 0xeb, 0xd5, 0x7b, 0xeb, 0xbf, 0x3d,
+    0x84, 0x92, 0xc0, 0xd6, 0xd7, 0x03, 0xf8, 0xd0, 0x70, 0x7e, 0xb4, 0xd2, 0x7d, 0x44, 0xdf,
+    0x29, 0xa3, 0x4a, 0xa7, 0x15, 0x9b, 0x6d, 0xa8, 0x86, 0x21, 0x26, 0x20, 0x1e, 0xce, 0x3a,
+    0x1a, 0xbe, 0x0f, 0x71, 0x4e, 0xc5, 0x46, 0x49, 0xea, 0x8b, 0x28, 0xf5, 0xad, 0xa6, 0xdc,
+    0xec, 0x7c, 0x13, 0x58, 0x6a, 0xdd, 0xaa, 0xcd, 0xb4, 0xbb, 0x24, 0x1c, 0xd4, 0x4a, 0x3a,
+    0x1a, 0xc6, 0x56, 0x65, 0xbd, 0x46, 0x4d, 0xd3, 0x31, 0xac, 0xb7, 0x3d, 0x6a, 0xcd, 0xdc,
+    0xbb, 0x9f, 0x22, 0xa9, 0x9a, 0x22, 0xb4, 0x26, 0x4f, 0x51, 0xbd, 0xeb, 0x84, 0xf1, 0x5c,
+    0x9e, 0x6d, 0xfa, 0xc6, 0x48, 0xf9, 0x46, 0x7f, 0x3a, 0xee, 0x98, 0x80, 0xa4, 0xfb, 0x57,
+    0x99, 0xea, 0xd7, 0x06, 0xe7, 0xc4, 0x17, 0x00, 0x72, 0xb1, 0xfc, 0xa2, 0x89, 0x3d, 0x3d,
+    0x4c, 0xde, 0xe8, 0xa7, 0x20, 0xcc, 0x64, 0x11, 0xd6, 0xb2, 0xca, 0x81, 0x29, 0x00, 0x74,
+    0x35, 0xd0, 0x5d, 0x44, 0x23, 0xb4, 0xe9, 0xcd, 0x62, 0xc7, 0x19, 0x2d, 0x93, 0xeb, 0x58,
+    0xd7, 0x8e, 0xa9, 0x04, 0x65, 0x74, 0x68, 0xe9, 0x30, 0x6e, 0x13, 0x31, 0x1d, 0x14, 0x01,
+    0x5d, 0x2e, 0x96, 0x80, 0x69, 0x90, 0x8f, 0x63, 0xfc, 0xcd, 0x66, 0xe8, 0xb0, 0x66, 0xd6,
+    0x73, 0x8e, 0x73, 0x8a, 0xde, 0xd3, 0xe1, 0xc5, 0x94, 0x43, 0xda, 0xba, 0x69, 0x46, 0xd1,
+    0x46, 0x13, 0x77, 0x93, 0x45, 0x0b, 0x48, 0xf1, 0xbb, 0xeb, 0x59, 0x9a, 0xb5, 0xb6, 0x2f,
+    0x77, 0x63, 0xef, 0x28, 0x35, 0xbd, 0x0c, 0x78, 0x91, 0xc6, 0x3b, 0xd5, 0x6d, 0x4e, 0xdf,
+    0x77, 0x96, 0xd8, 0xf5, 0x15, 0xa4, 0xa3, 0x75, 0x63, 0x38, 0x3e, 0x57, 0x73, 0x0e, 0x28,
+    0x3d, 0xab, 0x7a, 0x08, 0xff, 0x00, 0xd1, 0xe3, 0xfa, 0x55, 0x28, 0xa1, 0xc0, 0xe9, 0x5a,
+    0x76, 0xe3, 0xf7, 0x20, 0x7a, 0x50, 0x95, 0x82, 0x72, 0xe6, 0x63, 0xa3, 0x5c, 0x64, 0x54,
+    0x84, 0x73, 0x48, 0xa3, 0x06, 0x9e, 0x46, 0x38, 0xa0, 0x49, 0x68, 0x40, 0xe3, 0x2c, 0x2a,
+    0x48, 0xe1, 0x3d, 0x4d, 0x48, 0x90, 0xfc, 0xd9, 0x6a, 0x97, 0x81, 0xc5, 0x03, 0x51, 0xee,
+    0x31, 0x94, 0x05, 0xc5, 0x11, 0x8e, 0x45, 0x39, 0xf8, 0xe4, 0xd3, 0x44, 0x98, 0x3c, 0x0a,
+    0x45, 0x75, 0x2c, 0x76, 0xa8, 0x64, 0x7d, 0xa3, 0xde, 0x9a, 0x67, 0xec, 0x45, 0x43, 0x23,
+    0x82, 0x72, 0x69, 0x03, 0x65, 0x8b, 0x66, 0x39, 0xc9, 0xae, 0xaf, 0x48, 0xbe, 0x10, 0xba,
+    0x30, 0x39, 0x20, 0x83, 0x5c, 0x42, 0xdc, 0x61, 0xb0, 0xb5, 0xb7, 0xa5, 0x4c, 0x44, 0x8a,
+    0x73, 0xd6, 0xa6, 0x6a, 0xe8, 0xd2, 0x8c, 0xec, 0xf4, 0x3d, 0xbb, 0x4b, 0x94, 0x3c, 0x6c,
+    0xa0, 0xf0, 0x70, 0xc3, 0xfc, 0xfe, 0x55, 0x26, 0xa3, 0xff, 0x00, 0x1e, 0xeb, 0xfe, 0xf0,
+    0xfe, 0xb5, 0x8f, 0xe1, 0xeb, 0x9d, 0xf6, 0xf6, 0xe7, 0x3f, 0xc3, 0xb0, 0xfe, 0x1d, 0x3f,
+    0xa5, 0x6a, 0xea, 0x4d, 0xfb, 0xb4, 0x5f, 0x53, 0x9f, 0xf3, 0xf9, 0xd7, 0x93, 0x35, 0x66,
+    0xd1, 0xe9, 0x5a, 0xf5, 0x53, 0xee, 0x47, 0x61, 0x1e, 0xf9, 0x4c, 0x87, 0xa2, 0xff, 0x00,
+    0x3a, 0x35, 0x5b, 0x81, 0x1a, 0xe0, 0x9f, 0x95, 0x14, 0xbb, 0x73, 0x57, 0x2d, 0xe3, 0x10,
+    0x5b, 0x80, 0x78, 0x3d, 0x5a, 0xb9, 0x6f, 0x11, 0xde, 0x95, 0xb5, 0x90, 0xe7, 0x0d, 0x29,
+    0xc0, 0x1e, 0xc3, 0xfc, 0x8a, 0x70, 0x5c, 0xd2, 0x05, 0x2b, 0xcd, 0xcf, 0xa2, 0x38, 0x0d,
+    0x6e, 0xe9, 0xa5, 0x9a, 0x47, 0x63, 0xcb, 0x12, 0x4d, 0x72, 0xd7, 0x0f, 0x92, 0x6b, 0x63,
+    0x51, 0x97, 0x2e, 0x49, 0x35, 0xcf, 0x5d, 0x4a, 0x06, 0x40, 0xeb, 0x5e, 0xa4, 0x55, 0x91,
+    0xe5, 0xd7, 0x95, 0xd9, 0x4e, 0xe6, 0x6c, 0x70, 0x3a, 0x9e, 0x95, 0x47, 0xcb, 0x67, 0x6e,
+    0xe4, 0x9a, 0xb0, 0x7e, 0x66, 0xcf, 0x7a, 0x9e, 0x28, 0xc0, 0xfa, 0xf7, 0x35, 0x46, 0x49,
+    0xf2, 0xa2, 0x2b, 0x7b, 0x40, 0xa7, 0x27, 0xad, 0x6b, 0x5a, 0x44, 0xbb, 0x85, 0x54, 0x04,
+    0x2d, 0x5b, 0xb5, 0x7c, 0x38, 0x26, 0x93, 0xd8, 0x49, 0xdd, 0xea, 0x75, 0xda, 0x4d, 0x8a,
+    0x48, 0x01, 0x20, 0x56, 0xad, 0xce, 0x9c, 0x8b, 0x11, 0x38, 0x15, 0x8f, 0xa6, 0x6a, 0x0b,
+    0x18, 0x03, 0x35, 0xa3, 0x75, 0xaa, 0xa1, 0x84, 0x8d, 0xdd, 0xab, 0x92, 0x5c, 0xd7, 0x3d,
+    0x08, 0x38, 0xf2, 0x9c, 0xbe, 0xa9, 0x12, 0xc6, 0xc6, 0xb9, 0xc9, 0x8e, 0x58, 0xfa, 0x7a,
+    0x56, 0xe6, 0xa7, 0x71, 0xe6, 0xb1, 0x24, 0xd6, 0x14, 0x9c, 0x93, 0x5d, 0x10, 0xd8, 0xe1,
+    0xab, 0x6b, 0x90, 0x91, 0x93, 0x9e, 0xf4, 0x84, 0x53, 0xf1, 0x4c, 0x92, 0x48, 0xe1, 0x5d,
+    0xd2, 0x3a, 0xa8, 0xf5, 0x27, 0x15, 0x46, 0x68, 0x31, 0x48, 0x6a, 0x8c, 0x9a, 0xdd, 0x84,
+    0x67, 0x1e, 0x69, 0x6f, 0xf7, 0x45, 0x53, 0xbd, 0xd7, 0xa1, 0x36, 0xac, 0x2d, 0x99, 0xbc,
+    0xc3, 0xc0, 0x24, 0x63, 0x15, 0x9b, 0xab, 0x04, 0xb7, 0x34, 0x54, 0xe6, 0xfa, 0x16, 0x6f,
+    0x75, 0x5b, 0x7b, 0x22, 0x54, 0xfe, 0xf2, 0x4f, 0xee, 0xaf, 0x6a, 0xa0, 0x35, 0x5d, 0x46,
+    0xe8, 0xe6, 0xde, 0x10, 0x8b, 0xeb, 0x8c, 0xd5, 0x1d, 0x2a, 0xdd, 0x2e, 0xaf, 0x01, 0x99,
+    0xbb, 0xf7, 0xef, 0x5d, 0xb2, 0x59, 0x43, 0x12, 0x0f, 0x2d, 0x40, 0xc0, 0xe3, 0x15, 0x9c,
+    0x5c, 0xaa, 0x6b, 0x7b, 0x23, 0x69, 0x28, 0xc3, 0x4b, 0x5d, 0x9c, 0xda, 0x41, 0xad, 0x4b,
+    0xc9, 0x91, 0x80, 0xfc, 0xaa, 0xca, 0xd9, 0x6a, 0xdd, 0xe7, 0x27, 0xd8, 0xb5, 0x6d, 0x14,
+    0x97, 0xb1, 0xa5, 0x89, 0x67, 0x57, 0x3b, 0xc0, 0x23, 0xd4, 0x55, 0xa8, 0x25, 0xd5, 0x91,
+    0xce, 0xdf, 0x43, 0x1c, 0x9d, 0x4a, 0xdf, 0x99, 0x13, 0x70, 0xf5, 0x03, 0x35, 0xd2, 0x78,
+    0x62, 0xfc, 0xad, 0xe2, 0x82, 0x71, 0xe6, 0xa1, 0x04, 0x7b, 0xd4, 0x63, 0x6b, 0x0c, 0x11,
+    0x55, 0x9d, 0x85, 0xa5, 0xfc, 0x12, 0xa1, 0xe3, 0x20, 0xfe, 0xb4, 0xed, 0xa5, 0x87, 0x7b,
+    0x35, 0x23, 0xd1, 0xb5, 0xe8, 0x3f, 0xb5, 0x7e, 0x1f, 0xc8, 0xd8, 0xdd, 0x25, 0x94, 0xbb,
+    0x80, 0x1d, 0x71, 0xdf, 0xf9, 0x9f, 0xca, 0xbc, 0xce, 0x6b, 0x38, 0x24, 0x40, 0x56, 0x35,
+    0xe4, 0x77, 0x15, 0xe9, 0xfe, 0x1b, 0xba, 0x8a, 0xe6, 0x3b, 0xfd, 0x2e, 0x63, 0x84, 0xba,
+    0x87, 0x00, 0xfb, 0x9e, 0x3f, 0xad, 0x79, 0x24, 0xfa, 0x83, 0xe9, 0xd7, 0x4f, 0x6f, 0x34,
+    0x67, 0x6a, 0xb1, 0x5f, 0xa5, 0x67, 0x07, 0x6b, 0xa6, 0x74, 0x62, 0x23, 0xcd, 0xcb, 0x25,
+    0xdb, 0xf2, 0x15, 0xb4, 0x8b, 0x39, 0x06, 0x24, 0x81, 0x73, 0xea, 0x38, 0xaa, 0x17, 0x3e,
+    0x1e, 0x08, 0x0b, 0xd9, 0xc8, 0xca, 0xdd, 0x76, 0x93, 0xd6, 0xb7, 0x21, 0xbe, 0xb7, 0xbb,
+    0x4f, 0xdd, 0xb8, 0x27, 0xd2, 0x91, 0xdb, 0x60, 0x39, 0xe9, 0x4d, 0xc6, 0x2f, 0xa1, 0x82,
+    0x72, 0x5d, 0x4e, 0x36, 0xe2, 0x4b, 0xab, 0x6f, 0x92, 0x58, 0xb0, 0xde, 0xbd, 0xaa, 0x83,
+    0x4a, 0xee, 0x49, 0x26, 0xbb, 0x77, 0x7b, 0x6b, 0xa0, 0x52, 0x40, 0xad, 0xf5, 0xac, 0x7b,
+    0xdd, 0x01, 0x0e, 0x5e, 0xd9, 0xb6, 0x9f, 0xee, 0x9e, 0x95, 0xcf, 0x52, 0x94, 0xba, 0x33,
+    0x58, 0xd4, 0x5d, 0x4c, 0x34, 0x5b, 0x85, 0xf9, 0x95, 0x5b, 0xf2, 0xa7, 0x79, 0xd3, 0x27,
+    0xdf, 0x53, 0xf8, 0x8c, 0x55, 0xe0, 0xcf, 0x6d, 0x22, 0xad, 0xc2, 0x60, 0x0e, 0xe2, 0xb5,
+    0x02, 0x59, 0xdf, 0x45, 0xf2, 0x11, 0x9f, 0x51, 0xd4, 0x52, 0x54, 0xfb, 0x32, 0x9c, 0xac,
+    0x60, 0x0b, 0x85, 0x60, 0x73, 0xc1, 0xa8, 0x7a, 0x9a, 0xbd, 0x7b, 0xa5, 0xbc, 0x24, 0xb2,
+    0x8d, 0xcb, 0xea, 0x2a, 0x80, 0xcc, 0x6d, 0x86, 0x15, 0x12, 0xe6, 0x5b, 0x94, 0x9a, 0x7b,
+    0x13, 0x27, 0x19, 0x34, 0xd6, 0x18, 0x91, 0x5f, 0xf0, 0x34, 0xf1, 0xd0, 0x53, 0x1f, 0x95,
+    0x34, 0x74, 0x02, 0xec, 0xeb, 0xe6, 0xda, 0xe6, 0xb2, 0x87, 0x06, 0xb5, 0xad, 0xdb, 0x7c,
+    0x18, 0x3e, 0x95, 0x99, 0x32, 0x6c, 0x95, 0x85, 0x15, 0x3a, 0x31, 0x21, 0x24, 0x1c, 0x86,
+    0xf5, 0xa6, 0x53, 0xfe, 0xf4, 0x47, 0xda, 0x99, 0x59, 0xb2, 0x82, 0x94, 0x0c, 0x9a, 0x4a,
+    0x92, 0x35, 0xcf, 0x34, 0x25, 0x70, 0x00, 0xb4, 0xec, 0x53, 0x8f, 0x02, 0xa1, 0x2e, 0x73,
+    0x91, 0x54, 0xf4, 0x02, 0x5a, 0x5a, 0x6a, 0x02, 0x79, 0x34, 0xea, 0x68, 0x02, 0x92, 0x8a,
+    0x5a, 0x60, 0x25, 0x14, 0xa1, 0x49, 0xa7, 0x84, 0x02, 0x84, 0xae, 0x22, 0x3c, 0x1a, 0x02,
+    0x63, 0xad, 0x4b, 0xc0, 0xa8, 0x64, 0x93, 0x1c, 0x0a, 0x1a, 0x4b, 0x70, 0x11, 0xb1, 0xd3,
+    0xb5, 0x46, 0x4d, 0x21, 0x39, 0xa3, 0x19, 0xac, 0xdb, 0x19, 0xd7, 0x5c, 0xe8, 0x76, 0xb7,
+    0x64, 0x95, 0x5f, 0x29, 0xcf, 0x75, 0xe9, 0xf9, 0x56, 0x25, 0xd6, 0x8b, 0x7d, 0x60, 0xde,
+    0x62, 0x82, 0xc8, 0x39, 0x0f, 0x1f, 0x6a, 0xec, 0xe3, 0x88, 0xf7, 0xab, 0x2a, 0xbc, 0x63,
+    0x15, 0xd9, 0x2a, 0x71, 0x91, 0x84, 0x65, 0x24, 0x79, 0xd8, 0x8e, 0x79, 0xee, 0x04, 0xcf,
+    0x96, 0x62, 0x41, 0x24, 0xf7, 0xaf, 0x44, 0x85, 0x63, 0x9a, 0x04, 0x75, 0x20, 0x82, 0x3a,
+    0xd6, 0x35, 0xd5, 0xbc, 0x49, 0x75, 0x26, 0x14, 0x2f, 0x3d, 0x29, 0xab, 0x7f, 0xfd, 0x9d,
+    0x26, 0xde, 0x9e, 0xab, 0xeb, 0x55, 0x08, 0x72, 0xab, 0xdc, 0x52, 0x97, 0x31, 0xb6, 0x60,
+    0x03, 0x9a, 0x02, 0x28, 0xa6, 0x41, 0x7f, 0x0d, 0xec, 0x3e, 0x64, 0x2d, 0x91, 0xdc, 0x77,
+    0x14, 0xd6, 0x90, 0xe7, 0x15, 0x68, 0xcd, 0xd9, 0x18, 0xda, 0xeb, 0xc7, 0x15, 0xca, 0x31,
+    0xea, 0x53, 0xfa, 0xd5, 0xeb, 0x0b, 0x8d, 0xd6, 0x10, 0xb0, 0xfe, 0xed, 0x60, 0x78, 0xa1,
+    0xdb, 0xed, 0x10, 0x73, 0xfc, 0x27, 0xf9, 0xd6, 0x96, 0x8a, 0x4b, 0x69, 0x30, 0xe7, 0xb6,
+    0x7f, 0x9d, 0x4c, 0x65, 0x79, 0xb8, 0x95, 0x35, 0xfb, 0xb4, 0xcd, 0x17, 0x94, 0x9a, 0xc0,
+    0x9b, 0xe5, 0xd6, 0x6e, 0x23, 0xcf, 0x12, 0x44, 0x0d, 0x6e, 0x1a, 0xc3, 0xbf, 0xc2, 0x6b,
+    0x90, 0x37, 0xf7, 0xa3, 0x22, 0xaa, 0x7d, 0x08, 0xa3, 0xb9, 0x4e, 0x58, 0xcc, 0xbe, 0x1f,
+    0x53, 0xd4, 0xc4, 0xc7, 0xf9, 0xd6, 0xa7, 0x86, 0xa5, 0x12, 0x24, 0xb0, 0x37, 0x49, 0x12,
+    0xab, 0x59, 0xa8, 0x97, 0x4b, 0xb9, 0x8f, 0xb1, 0x77, 0x15, 0x5f, 0x41, 0x9b, 0xc9, 0xba,
+    0x88, 0x93, 0xfc, 0x58, 0x3f, 0xe7, 0xf1, 0xac, 0x96, 0x92, 0x8b, 0xee, 0x8d, 0xde, 0xb1,
+    0x68, 0x9a, 0xcd, 0x4a, 0xc6, 0xd0, 0xf7, 0x8d, 0xd9, 0x3f, 0x5a, 0xb5, 0xe5, 0x48, 0xa3,
+    0x76, 0x0d, 0x38, 0xa0, 0xb7, 0xd7, 0x6e, 0x90, 0x8e, 0x18, 0x89, 0x07, 0xe3, 0x5a, 0xec,
+    0xd1, 0x18, 0xb9, 0x03, 0xa5, 0x6d, 0x05, 0xa1, 0x13, 0xa9, 0x6b, 0x18, 0x52, 0x4e, 0x48,
+    0x00, 0xd6, 0xfe, 0x87, 0x28, 0xd8, 0x01, 0xac, 0x69, 0xad, 0x8c, 0x92, 0xfc, 0x83, 0x8a,
+    0xd5, 0xb0, 0xb5, 0x92, 0x25, 0xeb, 0x4f, 0x5e, 0xa2, 0x9c, 0x95, 0x95, 0x8e, 0x8b, 0xcc,
+    0x5f, 0x5a, 0x50, 0xc0, 0xf4, 0x35, 0x97, 0xb2, 0x4f, 0x5a, 0x37, 0x4a, 0x9c, 0x83, 0x45,
+    0x89, 0xf6, 0x86, 0xb5, 0x15, 0x9d, 0x1d, 0xee, 0x0e, 0x1e, 0xa5, 0x96, 0xfe, 0x34, 0x4c,
+    0xe4, 0x53, 0xb1, 0x4a, 0x68, 0xb9, 0x90, 0x3a, 0xd3, 0x4c, 0xa8, 0x3b, 0x8a, 0xc5, 0x92,
+    0xfe, 0x59, 0x4e, 0x23, 0x04, 0xd3, 0x16, 0x2b, 0xb9, 0x0f, 0x42, 0x3e, 0xb4, 0xec, 0x4f,
+    0xb4, 0xec, 0x6e, 0x89, 0x90, 0xff, 0x00, 0x15, 0x3c, 0x10, 0x7a, 0x1a, 0xc8, 0x8e, 0xce,
+    0xe0, 0x72, 0xd2, 0x63, 0xe9, 0x57, 0x61, 0x0d, 0x17, 0x04, 0x93, 0x45, 0x86, 0xa6, 0xfa,
+    0xa2, 0xe6, 0x28, 0xdb, 0x44, 0x6c, 0x18, 0x54, 0x94, 0x8d, 0x06, 0x63, 0x9e, 0x94, 0xbb,
+    0x69, 0xd4, 0x53, 0x01, 0xcb, 0x19, 0x3d, 0x05, 0x26, 0x08, 0x38, 0xad, 0x4d, 0x3e, 0x4b,
+    0x75, 0x8d, 0xbc, 0xc0, 0x33, 0x54, 0xae, 0x0a, 0x99, 0x89, 0x4e, 0x94, 0x26, 0x53, 0x5a,
+    0x5c, 0x86, 0x96, 0x8c, 0x51, 0x54, 0x21, 0x6b, 0x1b, 0x51, 0x65, 0xb6, 0xb8, 0x24, 0x9c,
+    0x06, 0xe4, 0x56, 0xcd, 0x64, 0xf8, 0x82, 0xc9, 0xee, 0xf4, 0xe6, 0x68, 0xce, 0x24, 0x8b,
+    0xe6, 0x1e, 0xe3, 0xb8, 0xa6, 0x99, 0x33, 0x8f, 0x32, 0x32, 0x65, 0xd4, 0x63, 0x4f, 0xe2,
+    0x15, 0x4a, 0x6d, 0x65, 0x57, 0x38, 0x61, 0x59, 0x7f, 0x64, 0x79, 0x0f, 0x2e, 0xe7, 0xd8,
+    0x0a, 0x7a, 0xe9, 0x3b, 0x8e, 0x4c, 0x4c, 0x7e, 0xa6, 0xa7, 0x9a, 0x6f, 0x64, 0x4a, 0xa7,
+    0x05, 0xbb, 0x3a, 0x2f, 0x0b, 0xea, 0x2b, 0x75, 0xa8, 0x4f, 0x1e, 0xec, 0x9f, 0x2f, 0x3f,
+    0xad, 0x75, 0x79, 0xae, 0x4f, 0xc3, 0x36, 0x3f, 0x65, 0xd4, 0x59, 0xb6, 0x22, 0xee, 0x8c,
+    0x8e, 0x3e, 0xa2, 0xba, 0xdc, 0x55, 0x2b, 0xdb, 0xde, 0x34, 0x8d, 0xad, 0xee, 0x87, 0xe1,
+    0x5e, 0x79, 0xae, 0xd8, 0x4d, 0x1e, 0xb3, 0x70, 0x10, 0x85, 0x46, 0x6d, 0xc3, 0x8c, 0xf5,
+    0xaf, 0x45, 0x02, 0xb1, 0x35, 0x98, 0x47, 0xda, 0x52, 0x4c, 0x72, 0xcb, 0x8f, 0xca, 0x87,
+    0x15, 0x2d, 0x18, 0xa7, 0x27, 0x15, 0xcc, 0x71, 0x49, 0xa5, 0xcd, 0x20, 0xe5, 0xa4, 0xfe,
+    0x55, 0x3a, 0x68, 0x68, 0x47, 0xce, 0x17, 0xf1, 0x39, 0xad, 0xc0, 0x9e, 0xd4, 0xbb, 0x0d,
+    0x0a, 0x8c, 0x17, 0x43, 0x9d, 0xd7, 0x93, 0xd8, 0xd1, 0xf0, 0xa6, 0x9b, 0x15, 0x9c, 0x17,
+    0x0e, 0x8a, 0x32, 0xe4, 0x0c, 0x81, 0x8e, 0x9f, 0xfe, 0xba, 0xe8, 0x82, 0x81, 0xda, 0xa9,
+    0xe9, 0x51, 0xf9, 0x5a, 0x7c, 0x63, 0xb9, 0xcb, 0x1a, 0xbb, 0x45, 0xad, 0xa2, 0x3a, 0xe1,
+    0xf0, 0xab, 0x8e, 0x18, 0xc7, 0x14, 0xc6, 0x39, 0x34, 0xe0, 0x69, 0x9d, 0xcd, 0x08, 0xa1,
+    0x41, 0xe4, 0x54, 0x95, 0x18, 0x1c, 0xd4, 0x82, 0x86, 0x02, 0x83, 0x4b, 0x49, 0x4b, 0x48,
+    0x07, 0xa7, 0x5a, 0xb9, 0x6a, 0x71, 0x22, 0x9f, 0x7a, 0xa4, 0x9c, 0x1a, 0xb7, 0x01, 0xc3,
+    0x0a, 0x4c, 0xa8, 0x9d, 0x35, 0xd3, 0x87, 0xd3, 0x54, 0x7a, 0x0a, 0xe6, 0x64, 0xea, 0x6b,
+    0x7f, 0x97, 0xb0, 0xfa, 0x0a, 0xc1, 0x98, 0x61, 0xdb, 0xeb, 0x59, 0xc0, 0xd6, 0xa6, 0xa5,
+    0x76, 0xe8, 0x69, 0x82, 0x9c, 0xe7, 0x9c, 0x53, 0x2b, 0x53, 0x16, 0x3a, 0x92, 0x80, 0x68,
+    0xa0, 0x42, 0x82, 0x45, 0x2e, 0x69, 0xb4, 0x53, 0x01, 0xd4, 0xa2, 0x9b, 0x4b, 0x40, 0x0b,
+    0x4b, 0x9a, 0x6e, 0x68, 0xcd, 0x20, 0x16, 0x96, 0x9b, 0x9a, 0x5c, 0xd0, 0x31, 0x69, 0xa4,
+    0xd2, 0xd2, 0x1a, 0x00, 0x69, 0x34, 0x84, 0x06, 0x04, 0x11, 0x91, 0xe8, 0x68, 0xa2, 0x98,
+    0x8a, 0xd2, 0x58, 0x5b, 0xc9, 0xc8, 0x5d, 0xa7, 0xfd, 0x9a, 0x75, 0xbd, 0xbb, 0x5b, 0x82,
+    0xbe, 0x69, 0x65, 0xec, 0x08, 0xe9, 0x53, 0xd1, 0x4e, 0xe2, 0xe5, 0x49, 0xdc, 0x29, 0xf1,
+    0xbe, 0xd6, 0xa6, 0x52, 0x17, 0x0b, 0xde, 0x90, 0xef, 0x62, 0x49, 0x1f, 0x2d, 0x93, 0x50,
+    0x3c, 0xe8, 0xbd, 0x4d, 0x53, 0xba, 0xbb, 0x00, 0x90, 0x0e, 0x7e, 0x95, 0x9c, 0xf2, 0xb3,
+    0x9c, 0x93, 0x54, 0xa2, 0x67, 0x3a, 0xa9, 0x1a, 0xb3, 0x5d, 0xc7, 0xe5, 0x30, 0xcf, 0x6a,
+    0xf3, 0x8b, 0x45, 0x37, 0x3a, 0xa5, 0xc4, 0xb8, 0xe1, 0xa4, 0x27, 0xf5, 0xae, 0xae, 0xe1,
+    0x8a, 0xdb, 0xc8, 0xde, 0x8a, 0x4d, 0x60, 0xe8, 0x70, 0x70, 0xee, 0x47, 0x7a, 0x4e, 0x3e,
+    0xf2, 0x33, 0xf6, 0x8d, 0xc5, 0xb1, 0x75, 0x28, 0xf1, 0x6e, 0x06, 0x2b, 0x2a, 0x28, 0x79,
+    0x15, 0xd1, 0x5f, 0xc5, 0xba, 0x36, 0x1e, 0xd5, 0x42, 0x0b, 0x7e, 0x47, 0x14, 0x4a, 0x9f,
+    0x34, 0xae, 0x2a, 0x73, 0x4a, 0x3a, 0x9a, 0x9a, 0x2c, 0x24, 0x5a, 0x4b, 0xc7, 0xf1, 0x7f,
+    0x41, 0x5b, 0x16, 0x88, 0x05, 0xaa, 0x67, 0xd2, 0xaa, 0xe9, 0x51, 0xed, 0xb7, 0x71, 0xfe,
+    0xd5, 0x5f, 0xb7, 0x4c, 0x42, 0xa3, 0xd2, 0xb4, 0xd8, 0x23, 0xab, 0xb9, 0x58, 0x26, 0x27,
+    0x6f, 0x73, 0x4c, 0xbd, 0x8b, 0x75, 0xbe, 0x71, 0xd0, 0xd5, 0xa7, 0x4c, 0x4b, 0x9a, 0x49,
+    0x23, 0xdf, 0x13, 0x2f, 0xb5, 0x02, 0x71, 0xd1, 0xa3, 0x15, 0x13, 0x23, 0xa5, 0x5b, 0x81,
+    0x08, 0x8c, 0x8c, 0x77, 0xab, 0xb6, 0x3a, 0x6b, 0xdc, 0x1c, 0x28, 0xcd, 0x6d, 0xc7, 0xe1,
+    0xc9, 0x55, 0x09, 0x2a, 0x40, 0x22, 0x93, 0x92, 0x44, 0xd3, 0xa5, 0x27, 0xa9, 0xce, 0x22,
+    0x16, 0x38, 0x15, 0x60, 0x44, 0x14, 0x64, 0xd5, 0xd9, 0xec, 0xfe, 0xce, 0xd8, 0xc5, 0x52,
+    0x91, 0xb3, 0xc7, 0x6a, 0x37, 0x2d, 0xc7, 0x97, 0x71, 0xac, 0xdd, 0xa9, 0xb8, 0xc9, 0xa5,
+    0x03, 0x3d, 0x2a, 0x58, 0xe2, 0x2e, 0x76, 0xa8, 0xc9, 0x34, 0x12, 0x95, 0xc8, 0x7c, 0xac,
+    0xf2, 0x4d, 0x21, 0x50, 0x38, 0x15, 0xa6, 0xfa, 0x55, 0xd2, 0x45, 0xe6, 0x18, 0x8e, 0xdc,
+    0x7a, 0x56, 0x6b, 0xe5, 0x4e, 0x08, 0xc1, 0xf4, 0xa5, 0x7b, 0x8d, 0xab, 0x11, 0x30, 0x02,
+    0xab, 0x4a, 0x09, 0x3c, 0x1a, 0xb2, 0xdc, 0x9a, 0x8a, 0x41, 0xc5, 0x23, 0x39, 0x22, 0x08,
+    0xc1, 0x06, 0xb6, 0x74, 0xe6, 0x21, 0x97, 0x15, 0x94, 0x83, 0x9a, 0xd4, 0xb0, 0xfb, 0xc3,
+    0xeb, 0x43, 0x2a, 0x96, 0xe7, 0xa7, 0x78, 0x66, 0x73, 0xf6, 0x72, 0x3a, 0xed, 0x60, 0xc3,
+    0xfc, 0xfe, 0x15, 0xd4, 0x1c, 0x5d, 0x5f, 0x0c, 0x72, 0x89, 0xfa, 0xff, 0x00, 0x93, 0x5c,
+    0x5f, 0x85, 0xd8, 0x93, 0x20, 0xed, 0xb3, 0xfa, 0x8a, 0xee, 0x6c, 0x23, 0xd9, 0x06, 0xe3,
+    0xd5, 0xf9, 0xfc, 0x2b, 0xcb, 0xac, 0xbd, 0xe3, 0xd7, 0xbd, 0xa9, 0xa9, 0x75, 0x16, 0xfa,
+    0x5f, 0x2e, 0x02, 0xa3, 0xef, 0x3f, 0x03, 0xfa, 0xd7, 0x9c, 0x78, 0x96, 0xfc, 0x3c, 0xac,
+    0x01, 0xf9, 0x54, 0x6d, 0x15, 0xd7, 0x6b, 0xb7, 0xeb, 0x02, 0x48, 0xe5, 0xb1, 0xfc, 0x0b,
+    0xfd, 0x6b, 0xca, 0x35, 0xab, 0xe3, 0x2c, 0x8c, 0x14, 0xf1, 0x5a, 0xe1, 0xe1, 0x77, 0x73,
+    0x2a, 0xb2, 0xf6, 0x74, 0xec, 0x63, 0xea, 0x17, 0x5c, 0xb6, 0x2b, 0x0e, 0x47, 0x2c, 0xc6,
+    0xad, 0x5c, 0xb9, 0x24, 0xd5, 0x64, 0x4e, 0x77, 0x11, 0xcd, 0x77, 0x1e, 0x53, 0x95, 0xdd,
+    0xd8, 0x47, 0x1e, 0x39, 0x3d, 0x6a, 0x5c, 0xe3, 0xa5, 0x00, 0x13, 0x4e, 0xc0, 0x1d, 0x68,
+    0x20, 0x40, 0x33, 0xc9, 0xa7, 0x2c, 0x85, 0x69, 0xa5, 0xa9, 0x94, 0x01, 0xa1, 0x0d, 0xe3,
+    0x27, 0x43, 0x52, 0xb5, 0xf3, 0x30, 0xe4, 0xd6, 0x5e, 0xec, 0x74, 0xa5, 0xdf, 0xc5, 0x4f,
+    0x2a, 0x2d, 0x4d, 0x93, 0x4d, 0x31, 0x73, 0x54, 0xe6, 0x95, 0x22, 0x46, 0x92, 0x46, 0x0a,
+    0xa3, 0xa9, 0x34, 0xf6, 0x6a, 0xe5, 0xef, 0xae, 0xff, 0x00, 0xb4, 0xf5, 0x15, 0xb6, 0xde,
+    0x56, 0x05, 0x38, 0xe3, 0xf8, 0x8d, 0x4c, 0xe7, 0xc8, 0xbc, 0xca, 0x84, 0x39, 0xd9, 0x3c,
+    0xfa, 0xd5, 0xc5, 0xd4, 0x86, 0x1b, 0x08, 0x8e, 0x3a, 0x6f, 0x23, 0xfc, 0xe2, 0x88, 0xb4,
+    0x09, 0xee, 0xb1, 0x2d, 0xe5, 0xc1, 0x24, 0xf6, 0x07, 0x35, 0xb9, 0x61, 0x69, 0x04, 0x16,
+    0xc1, 0x63, 0x8d, 0x47, 0xf5, 0xa9, 0xd2, 0xd1, 0xf1, 0xf7, 0xf8, 0xf4, 0x06, 0xa3, 0xd9,
+    0xdf, 0x59, 0xbb, 0x97, 0xcf, 0x6d, 0x20, 0x8a, 0x36, 0x9a, 0x1e, 0x9f, 0x07, 0xdf, 0x88,
+    0x39, 0xec, 0x5b, 0x9a, 0xb1, 0x26, 0x85, 0xa7, 0x4c, 0x38, 0x40, 0xbf, 0xee, 0xd5, 0xaf,
+    0x25, 0x90, 0x70, 0xb4, 0xd6, 0x90, 0xaf, 0x51, 0x55, 0xcb, 0x1d, 0xac, 0x2e, 0x69, 0x75,
+    0x31, 0x27, 0xf0, 0x90, 0x52, 0x5e, 0xd6, 0xe9, 0x90, 0xf6, 0x04, 0x7f, 0x5a, 0xae, 0x6d,
+    0xb5, 0xdb, 0x1e, 0x63, 0x9f, 0xce, 0x51, 0xd8, 0x9c, 0xd6, 0xfb, 0x5d, 0x6c, 0x19, 0xcd,
+    0x43, 0xfd, 0xa4, 0x80, 0x91, 0x22, 0x1c, 0x7a, 0xd4, 0x7b, 0x38, 0xad, 0xb4, 0x2d, 0x54,
+    0x6c, 0xcd, 0xb7, 0xf1, 0x21, 0x89, 0xbc, 0xbb, 0xf8, 0x1e, 0x26, 0xfe, 0xf0, 0x1c, 0x56,
+    0xc4, 0x37, 0xd6, 0xf7, 0x4b, 0xba, 0x09, 0x95, 0xfe, 0x86, 0xaa, 0x4c, 0x2d, 0x2f, 0x54,
+    0xab, 0x05, 0x71, 0xe8, 0x7a, 0xd6, 0x2d, 0xd6, 0x86, 0xd1, 0x31, 0x96, 0xca, 0x52, 0x08,
+    0xe8, 0xa4, 0xff, 0x00, 0x5a, 0x96, 0xe7, 0x1f, 0x31, 0xae, 0x57, 0xe4, 0x74, 0xcf, 0x70,
+    0xca, 0x79, 0x5c, 0xfb, 0x8a, 0xa1, 0x7b, 0x79, 0x1c, 0xa5, 0x50, 0x12, 0x1c, 0x1c, 0xe0,
+    0xd6, 0x0d, 0xbe, 0xab, 0x75, 0x6f, 0x27, 0x97, 0x71, 0xb8, 0x91, 0xc1, 0xdd, 0xd6, 0xaf,
+    0x3d, 0xcc, 0x77, 0x2b, 0xb9, 0x78, 0x61, 0x4d, 0x54, 0x4f, 0x61, 0x38, 0xb5, 0xb9, 0xdb,
+    0x69, 0x5a, 0x93, 0x41, 0x71, 0x69, 0x74, 0x0f, 0x20, 0x0a, 0xca, 0xf1, 0x5d, 0x8c, 0x4f,
+    0xe2, 0x6d, 0x46, 0x30, 0x46, 0xd9, 0x1f, 0xce, 0x43, 0xec, 0xc3, 0x70, 0xfe, 0x75, 0x4e,
+    0xc6, 0xeb, 0xfd, 0x12, 0x3e, 0x7e, 0xeb, 0x62, 0x9f, 0xe2, 0x8b, 0xa6, 0x77, 0xd3, 0xef,
+    0x10, 0xe1, 0xda, 0xd8, 0x23, 0x9f, 0x52, 0xa4, 0xaf, 0xf2, 0x02, 0x93, 0xde, 0xe6, 0xd7,
+    0xbc, 0x2c, 0x72, 0xd7, 0x36, 0x57, 0x36, 0x72, 0x6e, 0x8c, 0x91, 0x8e, 0x84, 0x1a, 0x9a,
+    0xd7, 0x5e, 0x75, 0xfd, 0xd5, 0xd8, 0xe3, 0xa6, 0xea, 0xb4, 0xba, 0x9a, 0x4a, 0x36, 0xcc,
+    0x00, 0x35, 0x9d, 0x7b, 0x6b, 0x1c, 0x84, 0xb2, 0x70, 0x7b, 0x56, 0x4d, 0x35, 0xac, 0x49,
+    0xbd, 0xf4, 0x91, 0x62, 0xea, 0x20, 0x4f, 0x9f, 0x6e, 0xfd, 0x79, 0xc0, 0x35, 0x1c, 0x3a,
+    0xac, 0xd1, 0x7c, 0xaf, 0xf3, 0x8f, 0xd6, 0xa8, 0x5b, 0xdc, 0x49, 0x6c, 0xfe, 0x5b, 0x74,
+    0xf4, 0xab, 0x12, 0x22, 0x4c, 0xbb, 0xe3, 0xeb, 0xe9, 0x42, 0x95, 0xf5, 0x43, 0xb5, 0xb4,
+    0x66, 0x81, 0xba, 0xb7, 0xbb, 0x4d, 0xa7, 0x1c, 0xf6, 0x35, 0x97, 0x71, 0x69, 0x25, 0xb3,
+    0xf9, 0xb6, 0xcc, 0x47, 0xb0, 0x3d, 0x2a, 0x03, 0x95, 0x3e, 0x86, 0xa6, 0x4b, 0xa7, 0x5e,
+    0x0f, 0x22, 0xa5, 0xc9, 0x4b, 0x71, 0xf2, 0xb5, 0xb1, 0x3d, 0xbe, 0xac, 0xce, 0xbe, 0x5c,
+    0xc0, 0x67, 0xa6, 0x7d, 0x6a, 0x3b, 0x98, 0x03, 0x0c, 0x81, 0xc7, 0x6a, 0xaf, 0x70, 0xa9,
+    0x2f, 0xce, 0x9c, 0x1a, 0x2d, 0xef, 0x1a, 0x3f, 0xdd, 0xcb, 0xca, 0xfa, 0xd2, 0xe6, 0xe9,
+    0x20, 0xb7, 0x54, 0x42, 0xdb, 0xa3, 0xe3, 0x14, 0xdf, 0x37, 0x3d, 0x45, 0x68, 0x4b, 0x02,
+    0xba, 0x6e, 0x8f, 0x91, 0x54, 0x24, 0x88, 0xa9, 0xe9, 0xcd, 0x44, 0xa2, 0xd6, 0xc5, 0x26,
+    0x99, 0x6a, 0xc5, 0xf8, 0x2b, 0xe9, 0x51, 0x5f, 0x26, 0x24, 0xdd, 0x4d, 0xb4, 0x6d, 0x93,
+    0x01, 0xeb, 0x56, 0x2f, 0x97, 0x28, 0x0d, 0x1b, 0xc0, 0x3a, 0x94, 0x63, 0x3f, 0x36, 0x0f,
+    0x43, 0xc5, 0x34, 0x8c, 0x12, 0x29, 0x07, 0x06, 0xa4, 0x94, 0x72, 0x18, 0x74, 0x22, 0xb3,
+    0xe8, 0x51, 0x1d, 0x4e, 0xa3, 0x0a, 0x2a, 0x15, 0x19, 0x60, 0x2a, 0x76, 0x38, 0x14, 0xe3,
+    0xdc, 0x08, 0xe4, 0x6e, 0xd4, 0xd4, 0x19, 0x6a, 0x4e, 0x49, 0xa9, 0xa3, 0x4c, 0x0f, 0x7a,
+    0x16, 0xac, 0x05, 0xa3, 0x19, 0xa7, 0x05, 0xa7, 0x85, 0xad, 0x52, 0x15, 0xc6, 0x05, 0xa5,
+    0x0b, 0xcd, 0x38, 0xe0, 0x71, 0x49, 0xbb, 0x03, 0x8a, 0x76, 0x48, 0x42, 0xf0, 0x05, 0x34,
+    0xb5, 0x34, 0xb5, 0x44, 0xef, 0x8e, 0x07, 0x5a, 0x97, 0x2b, 0x0e, 0xc2, 0xc9, 0x26, 0x38,
+    0x1d, 0x6a, 0x2e, 0xb4, 0x75, 0xa7, 0xac, 0x64, 0xd6, 0x7a, 0xb1, 0x8d, 0x0b, 0x9e, 0x95,
+    0x2a, 0x47, 0x52, 0x2c, 0x60, 0x54, 0x81, 0x79, 0xab, 0x8c, 0x04, 0xd9, 0xde, 0x86, 0x02,
+    0x83, 0x30, 0x15, 0x4f, 0xcc, 0x63, 0xdf, 0x14, 0xa0, 0xd7, 0x59, 0xce, 0xe4, 0x73, 0x9a,
+    0x9e, 0xa2, 0xcd, 0xaa, 0x49, 0x12, 0xe4, 0xfc, 0xe1, 0x6b, 0x77, 0x51, 0xd3, 0xd7, 0x50,
+    0xb6, 0xdb, 0x9d, 0x92, 0x81, 0xf2, 0xb0, 0xfe, 0x46, 0xb9, 0x25, 0xfd, 0xfe, 0xb4, 0x3f,
+    0xda, 0x9b, 0xfa, 0xd7, 0x72, 0x0d, 0x67, 0x06, 0xe5, 0x7b, 0x95, 0x3f, 0x76, 0xd6, 0x38,
+    0x8b, 0x5b, 0xab, 0x9d, 0x1e, 0xfc, 0x86, 0x04, 0x10, 0x70, 0xe8, 0x7b, 0x8a, 0xec, 0xed,
+    0xee, 0x23, 0xba, 0x81, 0x66, 0x8d, 0xb2, 0xac, 0x2b, 0x37, 0x5c, 0xd3, 0x16, 0xf6, 0xdc,
+    0xcd, 0x18, 0xc4, 0xf1, 0x8c, 0xff, 0x00, 0xbc, 0x3d, 0x2b, 0x27, 0xc3, 0xd7, 0xe6, 0x0b,
+    0xaf, 0xb3, 0x39, 0xfd, 0xdc, 0x9d, 0x3d, 0x9a, 0x94, 0x5b, 0xa7, 0x2e, 0x57, 0xb3, 0x14,
+    0x92, 0x9c, 0x79, 0x96, 0xe4, 0x9e, 0x29, 0xff, 0x00, 0x8f, 0x88, 0x3f, 0xdd, 0x3f, 0xce,
+    0xb5, 0x74, 0x4e, 0x34, 0x98, 0x7f, 0x1f, 0xe7, 0x58, 0xde, 0x27, 0x7d, 0xd7, 0xf1, 0xaf,
+    0xf7, 0x52, 0xb7, 0x74, 0xa5, 0xdb, 0xa5, 0x5b, 0x8c, 0x7f, 0x05, 0x54, 0x3f, 0x8b, 0x26,
+    0x29, 0xff, 0x00, 0x0d, 0x16, 0x8d, 0x73, 0x3a, 0xfc, 0xaf, 0x16, 0xa3, 0x0b, 0x2e, 0x32,
+    0xa9, 0xc7, 0xe7, 0x5d, 0x39, 0xae, 0x43, 0x5f, 0x93, 0x7e, 0xa6, 0x54, 0x74, 0x45, 0x0b,
+    0x55, 0x5d, 0xda, 0x04, 0x50, 0x5e, 0xf1, 0xa5, 0xa2, 0xa9, 0xfe, 0xcd, 0xdc, 0x7f, 0x89,
+    0xc9, 0xac, 0xd8, 0x07, 0x93, 0x79, 0x32, 0x74, 0x2b, 0x25, 0x6d, 0xe9, 0x11, 0x31, 0xd2,
+    0x60, 0x20, 0x75, 0x04, 0xfe, 0xb5, 0x8b, 0xaa, 0xa3, 0x5a, 0xea, 0xe4, 0x8c, 0x80, 0xf8,
+    0x26, 0xa6, 0x7a, 0x42, 0x2c, 0xda, 0x2e, 0xf2, 0x68, 0xda, 0xd4, 0x1b, 0xfe, 0x26, 0x16,
+    0x77, 0x1f, 0xf3, 0xda, 0x1c, 0x13, 0xee, 0x2a, 0x64, 0x2f, 0x31, 0x0a, 0xa0, 0x91, 0xed,
+    0x55, 0x6e, 0x49, 0x93, 0x4d, 0xb1, 0x94, 0x0c, 0x98, 0xa6, 0xd8, 0x7e, 0x87, 0xff, 0x00,
+    0xd7, 0x5d, 0x2d, 0x95, 0xa0, 0x54, 0x04, 0xf4, 0xad, 0xa2, 0xf7, 0x33, 0x96, 0x89, 0x22,
+    0xb5, 0xbd, 0xb3, 0x20, 0x19, 0x53, 0x9a, 0xd1, 0x48, 0xdb, 0x68, 0xc0, 0xa9, 0xc2, 0xaa,
+    0xf4, 0x02, 0x97, 0x76, 0x29, 0xb6, 0x42, 0x8f, 0x72, 0x31, 0x0b, 0x9a, 0x5f, 0x21, 0xb1,
+    0xc9, 0x02, 0x9d, 0xe6, 0x01, 0x47, 0x99, 0x9a, 0x07, 0x64, 0x55, 0x96, 0xc1, 0x5c, 0xf2,
+    0xc7, 0xf0, 0xa8, 0xc5, 0x84, 0x61, 0xbe, 0x60, 0x5b, 0xeb, 0x5a, 0x00, 0xe6, 0x91, 0x87,
+    0x14, 0xee, 0x2e, 0x54, 0x24, 0x50, 0xc6, 0x80, 0x00, 0xa2, 0xa5, 0xc0, 0x15, 0x18, 0x38,
+    0x14, 0x85, 0xc9, 0x38, 0x14, 0x14, 0xac, 0x89, 0x77, 0x01, 0x4d, 0x2c, 0x0d, 0x69, 0xda,
+    0xe8, 0x17, 0x17, 0x36, 0xde, 0x70, 0x07, 0x18, 0xac, 0xab, 0x88, 0x5e, 0xda, 0x62, 0x8d,
+    0xd4, 0x50, 0x9a, 0x1c, 0x93, 0x4a, 0xec, 0x72, 0x39, 0x53, 0xcd, 0x59, 0x12, 0x8c, 0x55,
+    0x0d, 0xdc, 0x50, 0xae, 0x73, 0xd6, 0x98, 0x94, 0xac, 0x5e, 0x32, 0xfa, 0x54, 0x4d, 0x2b,
+    0x53, 0x43, 0x0c, 0x75, 0xa3, 0x70, 0x3d, 0xe9, 0x8d, 0xb1, 0xc2, 0xe1, 0xc7, 0x6a, 0x7a,
+    0x5c, 0xe4, 0xf3, 0x4c, 0xc0, 0x34, 0x18, 0xd4, 0xd3, 0x0b, 0xb2, 0xe2, 0x4a, 0xad, 0xde,
+    0xa4, 0x18, 0xac, 0xf0, 0x85, 0x4f, 0x06, 0xac, 0xc5, 0x29, 0xe8, 0x68, 0xb1, 0x6a, 0x5d,
+    0xc9, 0xf1, 0x49, 0x81, 0xe9, 0x4e, 0xeb, 0x49, 0x8a, 0x11, 0x76, 0x39, 0xdb, 0xbb, 0x31,
+    0x05, 0xcb, 0x2a, 0x8f, 0x94, 0xf2, 0xbf, 0x4a, 0x88, 0x45, 0x5b, 0xf7, 0x76, 0xe2, 0x68,
+    0xc1, 0xfe, 0x25, 0xaa, 0x22, 0x0c, 0x76, 0xad, 0x13, 0xb9, 0xcb, 0x3a, 0x76, 0x64, 0x5a,
+    0x72, 0xf9, 0x77, 0xb1, 0x9f, 0x5c, 0x8a, 0xdf, 0xac, 0x98, 0xa3, 0x29, 0x22, 0xb6, 0x3a,
+    0x1a, 0xd6, 0xa1, 0x9b, 0x51, 0x56, 0x56, 0x0a, 0xa5, 0xa9, 0xc3, 0xe6, 0x46, 0x87, 0xd0,
+    0xe2, 0xaf, 0x54, 0x57, 0x0a, 0x1a, 0x13, 0xed, 0x49, 0x6e, 0x5c, 0x95, 0xe2, 0xd1, 0x8a,
+    0x20, 0x5a, 0x7a, 0xc2, 0x33, 0x80, 0x2a, 0xde, 0xc1, 0xe9, 0x52, 0x41, 0x10, 0x32, 0x8e,
+    0x38, 0x1c, 0xd5, 0x98, 0x2a, 0x65, 0xf8, 0xc6, 0xc8, 0xd5, 0x47, 0x61, 0x8a, 0x7e, 0xee,
+    0x29, 0x94, 0xb9, 0xac, 0xce, 0xab, 0x0e, 0xc9, 0xa5, 0xc6, 0x79, 0xa6, 0xd2, 0xa9, 0xa0,
+    0x07, 0x01, 0x4e, 0x1c, 0x51, 0x45, 0x48, 0x0f, 0xa2, 0x9a, 0x0d, 0x3a, 0x80, 0x15, 0x7a,
+    0xd5, 0xa8, 0x4f, 0xcc, 0x2a, 0xa2, 0x9f, 0x9a, 0xad, 0xc0, 0x32, 0xe0, 0x50, 0xca, 0x89,
+    0xd0, 0x44, 0xdf, 0xe8, 0x38, 0xf6, 0xac, 0x2b, 0x83, 0x87, 0x3f, 0x5a, 0xe9, 0x21, 0x83,
+    0x16, 0x05, 0x8f, 0x4c, 0x57, 0x39, 0x74, 0x07, 0x9a, 0x71, 0x59, 0x43, 0x73, 0x69, 0xad,
+    0x11, 0x4d, 0xb9, 0x34, 0xda, 0x7b, 0x1a, 0x61, 0xad, 0x8c, 0x18, 0x66, 0x97, 0x34, 0x94,
+    0x50, 0x03, 0xa8, 0xa6, 0xe6, 0x8c, 0xd0, 0x03, 0xb3, 0x46, 0x69, 0x94, 0xb4, 0x00, 0xf1,
+    0xcd, 0x04, 0x62, 0x91, 0x5b, 0x14, 0x8c, 0xe4, 0xd0, 0x03, 0x85, 0x19, 0xa6, 0x64, 0xd1,
+    0x9a, 0x00, 0x7e, 0x68, 0xcd, 0x34, 0x02, 0x69, 0x59, 0x0a, 0xd0, 0x02, 0x13, 0x46, 0x69,
+    0x29, 0x09, 0x14, 0x00, 0xbd, 0x69, 0xaf, 0x20, 0x41, 0x93, 0x46, 0xec, 0x55, 0x1b, 0x97,
+    0x25, 0x88, 0xcd, 0x52, 0x57, 0x26, 0x4e, 0xc8, 0x26, 0xbe, 0x23, 0x21, 0x78, 0xaa, 0x52,
+    0x5c, 0x49, 0x21, 0xe4, 0x9a, 0x53, 0x19, 0x34, 0x79, 0x55, 0x76, 0x47, 0x3b, 0x6d, 0x90,
+    0x9c, 0x93, 0x93, 0x40, 0x15, 0x60, 0x45, 0xed, 0x4e, 0x11, 0x7b, 0x53, 0x17, 0x21, 0x46,
+    0xed, 0x0f, 0xd8, 0xe6, 0x3d, 0xb6, 0x9a, 0xa5, 0xa3, 0xc3, 0xb6, 0xdd, 0xb8, 0xea, 0xd5,
+    0xaf, 0x77, 0x1e, 0x6d, 0x24, 0x18, 0xed, 0x50, 0x69, 0xd0, 0x01, 0x01, 0xe3, 0x1c, 0xd1,
+    0x6e, 0xa1, 0x6f, 0xb2, 0x47, 0x73, 0x16, 0x63, 0x6e, 0x39, 0xaa, 0x51, 0xc4, 0x01, 0x1c,
+    0x56, 0xd4, 0xf1, 0x65, 0x4d, 0x51, 0x11, 0xe3, 0xa5, 0x33, 0x39, 0xc5, 0xa6, 0x5a, 0xd3,
+    0xc0, 0x50, 0xeb, 0xed, 0x9a, 0xb3, 0x0e, 0x77, 0x8f, 0x73, 0x50, 0x5a, 0x80, 0xac, 0x4f,
+    0xe1, 0x53, 0x21, 0xc4, 0x80, 0xf6, 0xcd, 0x26, 0x6b, 0x0d, 0x91, 0x2c, 0x83, 0xf7, 0x9f,
+    0x85, 0x3e, 0x15, 0x05, 0xb1, 0x44, 0xa3, 0x91, 0x4b, 0x19, 0xd8, 0xd9, 0xa9, 0x35, 0xb6,
+    0xa7, 0x57, 0xe1, 0xbb, 0x18, 0xc3, 0x02, 0xc0, 0x13, 0x9a, 0xeb, 0x64, 0xb7, 0x8c, 0xc4,
+    0x46, 0xd0, 0x30, 0x2b, 0x83, 0xd3, 0x75, 0x3f, 0xb3, 0x38, 0xe7, 0x15, 0xbb, 0x2f, 0x88,
+    0x14, 0xc3, 0x8d, 0xd5, 0xcd, 0x38, 0xc9, 0xb3, 0xb2, 0x94, 0xa2, 0xa3, 0x63, 0x0b, 0x5f,
+    0x85, 0x15, 0xdb, 0x6e, 0x2b, 0x96, 0x64, 0x3b, 0xab, 0x67, 0x54, 0xbf, 0x13, 0xb9, 0xe6,
+    0xb2, 0x33, 0x93, 0x9a, 0xde, 0x09, 0xa4, 0x71, 0xd5, 0x6a, 0x52, 0xd0, 0x40, 0xa1, 0x45,
+    0x6a, 0xe8, 0x3e, 0x57, 0xf6, 0x8c, 0x7e, 0x6f, 0xdd, 0xcf, 0x7a, 0xca, 0x66, 0x03, 0xad,
+    0x35, 0x66, 0x64, 0x60, 0xca, 0x70, 0x45, 0x36, 0xae, 0xac, 0x67, 0xb1, 0xec, 0xd7, 0x49,
+    0x64, 0x74, 0xd6, 0xce, 0xcd, 0xbb, 0x78, 0xaf, 0x1f, 0xd4, 0xc2, 0x0b, 0xd9, 0x7c, 0xb3,
+    0xc6, 0x7b, 0x54, 0xcf, 0xae, 0x5d, 0xb4, 0x3e, 0x51, 0x91, 0xb6, 0xfd, 0x6b, 0x35, 0xdc,
+    0xb3, 0x12, 0x4f, 0x26, 0xb3, 0xa7, 0x4d, 0xc7, 0x71, 0xce, 0x69, 0x8d, 0x24, 0x53, 0x1b,
+    0x91, 0x8a, 0x52, 0x69, 0xa0, 0xe4, 0xd6, 0x86, 0x2c, 0x6a, 0xa1, 0x07, 0xd6, 0xb5, 0xb4,
+    0xf8, 0x58, 0x90, 0x48, 0xaa, 0x30, 0xae, 0x5b, 0x35, 0xbf, 0xa6, 0x42, 0x59, 0x90, 0x01,
+    0x92, 0x4f, 0x02, 0xa6, 0x4f, 0x43, 0x5a, 0x51, 0xbb, 0x3b, 0x9f, 0x0c, 0x5a, 0x32, 0xd9,
+    0xf9, 0x98, 0xf9, 0xa5, 0x6d, 0xab, 0x9f, 0x41, 0xfe, 0x7f, 0x4a, 0xec, 0x27, 0x71, 0x6f,
+    0x6d, 0xf2, 0xf5, 0x03, 0x6a, 0xd6, 0x7e, 0x91, 0x6c, 0x21, 0x8d, 0x54, 0x74, 0x8d, 0x02,
+    0x8f, 0xad, 0x45, 0xae, 0xdf, 0x0b, 0x68, 0x24, 0x72, 0x7f, 0xd5, 0xaf, 0x1f, 0xef, 0x1a,
+    0xf3, 0x25, 0xef, 0xcc, 0xf4, 0x9a, 0xd5, 0x47, 0xa2, 0x38, 0x9f, 0x14, 0xea, 0x3b, 0xee,
+    0x1a, 0x25, 0x6f, 0x92, 0x31, 0xb7, 0xf1, 0xef, 0x5c, 0x0d, 0xe4, 0xbb, 0x89, 0xad, 0x7d,
+    0x52, 0xec, 0xbb, 0xb1, 0x27, 0x93, 0xcd, 0x73, 0x77, 0x32, 0xe5, 0x8e, 0x0d, 0x7a, 0x14,
+    0xe3, 0xca, 0xac, 0x79, 0xf8, 0x9a, 0x9c, 0xcc, 0xaf, 0x27, 0x26, 0x85, 0x5c, 0xfd, 0x29,
+    0x00, 0xe7, 0x9a, 0x56, 0x3d, 0x81, 0xe2, 0xb4, 0x38, 0xc4, 0x2e, 0x01, 0xc0, 0xe6, 0x90,
+    0x9c, 0xd1, 0x8c, 0x52, 0x1a, 0x40, 0x06, 0x92, 0x82, 0x6a, 0xa5, 0xed, 0xf4, 0x76, 0x71,
+    0xe5, 0x88, 0xcf, 0x61, 0x49, 0xb4, 0x95, 0xd9, 0x49, 0x36, 0xec, 0x8b, 0x5c, 0x01, 0x93,
+    0x58, 0x77, 0x5a, 0xb4, 0x92, 0xca, 0x61, 0xb4, 0x04, 0x9e, 0x99, 0x5e, 0xa6, 0xaa, 0xdd,
+    0x5f, 0xdd, 0xdd, 0xfc, 0xbe, 0x53, 0x88, 0x4f, 0x65, 0x04, 0x66, 0xad, 0x69, 0xd3, 0xc3,
+    0x6e, 0xbb, 0x05, 0xbb, 0x23, 0x1e, 0xac, 0x47, 0x5a, 0xc1, 0xd4, 0xe7, 0x76, 0x5a, 0x1d,
+    0x11, 0xa7, 0xca, 0xae, 0xd5, 0xd9, 0x08, 0xd2, 0x35, 0x3b, 0x93, 0xbd, 0xe6, 0x75, 0x27,
+    0xb1, 0x6a, 0xae, 0x7c, 0x3d, 0xa8, 0xc4, 0xfb, 0x95, 0x15, 0x88, 0x39, 0x04, 0x35, 0x75,
+    0x09, 0xaa, 0xdb, 0x05, 0x01, 0x9f, 0x6f, 0xd4, 0x53, 0x64, 0xd6, 0xad, 0x50, 0x70, 0xe1,
+    0xbd, 0x80, 0x34, 0x9d, 0x28, 0x3d, 0xc6, 0xa7, 0x3e, 0xc7, 0x39, 0x24, 0xda, 0xbd, 0xa8,
+    0xc1, 0x86, 0x45, 0xc7, 0xf1, 0x28, 0x24, 0x54, 0x71, 0xf8, 0x83, 0x50, 0x87, 0x82, 0xfb,
+    0xb1, 0xfd, 0xe1, 0x5b, 0x27, 0x5f, 0x8d, 0x98, 0x86, 0x84, 0x85, 0xf5, 0x07, 0x34, 0x36,
+    0xa1, 0xa7, 0x5c, 0xae, 0x25, 0x51, 0xf4, 0x74, 0xa8, 0x69, 0xf4, 0x91, 0x57, 0xef, 0x12,
+    0xa5, 0xb7, 0x8b, 0x66, 0x0e, 0x05, 0xc4, 0x28, 0x57, 0xd5, 0x78, 0xad, 0x88, 0x75, 0x7b,
+    0x2b, 0xb0, 0x3e, 0x70, 0xa4, 0xf6, 0x6e, 0x2b, 0x9d, 0xbd, 0xb2, 0xb1, 0x7f, 0x9a, 0xd9,
+    0xc2, 0x9f, 0x40, 0x78, 0xac, 0xa7, 0x57, 0x81, 0xb8, 0x6a, 0x9f, 0x69, 0x38, 0x7c, 0x5a,
+    0x95, 0xcb, 0x19, 0x6c, 0x76, 0xd7, 0x70, 0x09, 0x62, 0x3e, 0x59, 0x15, 0x89, 0x37, 0x99,
+    0x09, 0xda, 0xf9, 0xc5, 0x66, 0x5b, 0xea, 0xb7, 0x10, 0x71, 0xbc, 0xe3, 0xd0, 0xf2, 0x2b,
+    0x45, 0x75, 0x38, 0xee, 0x93, 0x6c, 0x80, 0x02, 0x6a, 0xd5, 0x58, 0xc8, 0x9e, 0x47, 0x12,
+    0x2d, 0xc7, 0x3f, 0x29, 0x22, 0xa4, 0x4b, 0xe9, 0xa3, 0xe0, 0xb6, 0xe1, 0xef, 0x50, 0x4a,
+    0x86, 0x33, 0x94, 0x39, 0x15, 0x09, 0x94, 0x1f, 0xad, 0x27, 0x22, 0xac, 0x99, 0x6a, 0xe9,
+    0xa2, 0xbb, 0x4c, 0xb2, 0xe1, 0xc7, 0x46, 0xaa, 0x0a, 0x5e, 0x07, 0xc1, 0xa9, 0x3c, 0xce,
+    0x69, 0x4e, 0x1c, 0x60, 0xd4, 0x3d, 0x75, 0x43, 0x4a, 0xc6, 0x8d, 0x85, 0xc7, 0xee, 0xdd,
+    0x73, 0xee, 0x29, 0xfa, 0x9d, 0xd7, 0x9b, 0x63, 0x0c, 0x7f, 0xdc, 0x76, 0x3f, 0x98, 0x1f,
+    0xe1, 0x59, 0xd6, 0xac, 0x52, 0x6d, 0xb9, 0xec, 0x45, 0x49, 0x70, 0x77, 0x42, 0x7d, 0xaa,
+    0xaf, 0xa0, 0xb6, 0x65, 0x07, 0x34, 0x2c, 0xcc, 0xa3, 0x19, 0xc8, 0xa5, 0x75, 0xc0, 0x07,
+    0xd6, 0xab, 0x9f, 0x97, 0xe9, 0x59, 0x36, 0xd3, 0x2f, 0x72, 0xc4, 0x8a, 0xb3, 0x2f, 0xbf,
+    0xaf, 0xa5, 0x40, 0xb2, 0x3c, 0x2f, 0x83, 0xc7, 0xf5, 0xa5, 0x57, 0xc7, 0x43, 0x4e, 0x70,
+    0x24, 0x4c, 0x52, 0xdf, 0x55, 0xb8, 0x58, 0x9b, 0x29, 0x70, 0xb9, 0x1c, 0x35, 0x56, 0x65,
+    0x2a, 0x70, 0x6a, 0x25, 0x72, 0x8d, 0x83, 0xc1, 0x15, 0x63, 0xcc, 0x12, 0x2e, 0x18, 0x7c,
+    0xd4, 0xae, 0xa5, 0xea, 0x16, 0xb1, 0x16, 0x69, 0xac, 0xa1, 0x87, 0xbd, 0x3d, 0x86, 0x29,
+    0xb5, 0x23, 0x12, 0x29, 0xde, 0x16, 0xc0, 0x27, 0x1e, 0x95, 0x7b, 0x7a, 0x5c, 0xc5, 0x9c,
+    0x7c, 0xc2, 0xa8, 0x3a, 0xee, 0x19, 0x1d, 0x68, 0x89, 0x99, 0x4f, 0x07, 0x14, 0xe3, 0x26,
+    0xb4, 0x7b, 0x09, 0xab, 0x8e, 0x75, 0xf2, 0xe6, 0x56, 0x1e, 0xb5, 0x7a, 0x51, 0xbe, 0xdf,
+    0x35, 0x46, 0x52, 0x59, 0x72, 0x6a, 0xec, 0x0d, 0xe6, 0x5b, 0x7e, 0x15, 0x4b, 0x76, 0x81,
+    0x99, 0x64, 0x60, 0xd3, 0xf3, 0xba, 0x2c, 0x7a, 0x1c, 0xd3, 0x5f, 0xef, 0x9f, 0xad, 0x20,
+    0x38, 0xcf, 0xb8, 0xac, 0x4a, 0x1f, 0x10, 0xcb, 0xd3, 0x98, 0x16, 0x3e, 0xd4, 0x40, 0x3a,
+    0xd4, 0xa0, 0x0a, 0xb4, 0xb4, 0x10, 0xc4, 0x8b, 0x9c, 0xd4, 0xdb, 0x40, 0xa3, 0x70, 0x03,
+    0x02, 0x98, 0x5e, 0xb4, 0x56, 0x42, 0x1f, 0x90, 0x29, 0xac, 0xf8, 0xa6, 0x16, 0xa6, 0xfb,
+    0xd2, 0x72, 0x1d, 0x87, 0x66, 0x93, 0x34, 0x53, 0x18, 0x93, 0xc0, 0xa9, 0x6c, 0x62, 0x33,
+    0xf6, 0x14, 0xd0, 0xa4, 0xd4, 0x8b, 0x1e, 0x7a, 0xd4, 0xaa, 0x98, 0xa4, 0xa2, 0xd8, 0xae,
+    0x46, 0x91, 0x63, 0xad, 0x4c, 0x16, 0x97, 0x18, 0xa0, 0x9a, 0xd1, 0x45, 0x21, 0x5c, 0x3a,
+    0x53, 0xba, 0x0a, 0x66, 0x72, 0x69, 0x19, 0xf8, 0xa2, 0xe2, 0xb1, 0x7e, 0x3f, 0x11, 0xb8,
+    0xfb, 0xf6, 0xea, 0x7e, 0x8d, 0x8a, 0xb2, 0x3c, 0x47, 0x01, 0x42, 0x0c, 0x52, 0x2b, 0x63,
+    0x8e, 0x86, 0xb2, 0x3c, 0xb4, 0xfe, 0xe8, 0xfc, 0xa8, 0xf2, 0xd3, 0xfb, 0xa3, 0xf2, 0xa1,
+    0x4a, 0x7d, 0xc5, 0xc9, 0x11, 0x34, 0xd9, 0x63, 0x4d, 0x4e, 0x29, 0x66, 0x70, 0xaa, 0x18,
+    0xb1, 0x26, 0xba, 0xf8, 0xb5, 0x1b, 0x49, 0x07, 0xcb, 0x71, 0x1f, 0xe7, 0x8a, 0xe4, 0x4c,
+    0x08, 0x7b, 0x0a, 0x69, 0xb6, 0x5e, 0xc4, 0x8a, 0x20, 0xe5, 0x05, 0x60, 0x94, 0x54, 0x8e,
+    0xe5, 0x5d, 0x1c, 0x7c, 0xae, 0xa7, 0xe8, 0x6b, 0x8c, 0xd5, 0x6d, 0xcd, 0x8e, 0xaa, 0xe5,
+    0x38, 0x19, 0xde, 0xb8, 0xa8, 0x56, 0x39, 0xa3, 0x39, 0x8e, 0x42, 0x3e, 0x87, 0x14, 0xcb,
+    0x89, 0x2e, 0x65, 0xda, 0x66, 0x66, 0x72, 0xa3, 0x00, 0x9e, 0x68, 0xa9, 0x3e, 0x65, 0xb0,
+    0xa1, 0x0e, 0x56, 0x4b, 0xaa, 0xdc, 0x7d, 0xae, 0xfc, 0xc8, 0x3b, 0xaa, 0x8f, 0xd2, 0xbb,
+    0x4b, 0x78, 0xfc, 0xbb, 0x68, 0x93, 0x18, 0xda, 0xa0, 0x7e, 0x95, 0xc1, 0x42, 0xea, 0xb7,
+    0x11, 0xbc, 0xa0, 0x95, 0x0c, 0x09, 0xc7, 0xa5, 0x76, 0x96, 0xda, 0xb5, 0x9d, 0xd6, 0x02,
+    0x4a, 0x03, 0x1f, 0xe1, 0x6e, 0x0d, 0x5d, 0x19, 0x5d, 0xb6, 0xfa, 0x93, 0x55, 0x3b, 0x24,
+    0x8b, 0xbf, 0x2a, 0x23, 0x48, 0xe7, 0xe5, 0x51, 0x93, 0x5e, 0x7f, 0x77, 0x31, 0x9e, 0xee,
+    0x49, 0x4f, 0xf1, 0x31, 0x35, 0xd4, 0xeb, 0xf7, 0xe9, 0x0d, 0x89, 0x85, 0x1c, 0x79, 0x92,
+    0x70, 0x40, 0x3d, 0x05, 0x72, 0x4b, 0xcb, 0x82, 0x41, 0x23, 0x3c, 0xe2, 0xa7, 0x11, 0x2b,
+    0xb5, 0x11, 0xd1, 0x8d, 0x95, 0xcf, 0x45, 0xd2, 0xa1, 0x10, 0xe9, 0x76, 0xc8, 0x47, 0x3e,
+    0x58, 0x27, 0xf1, 0xe6, 0xb9, 0xff, 0x00, 0x18, 0x40, 0x16, 0x6b, 0x69, 0x80, 0xe0, 0x82,
+    0xa6, 0x93, 0xfe, 0x12, 0x4b, 0xc2, 0xa1, 0x6d, 0xed, 0x00, 0x00, 0x60, 0x67, 0x26, 0xa9,
+    0xdf, 0x4d, 0xaa, 0x6a, 0x88, 0xa9, 0x3c, 0x43, 0x6a, 0x9c, 0x80, 0x00, 0x15, 0x73, 0x92,
+    0x94, 0x79, 0x50, 0xa3, 0x16, 0xa5, 0x76, 0x69, 0xe9, 0xee, 0xb2, 0x69, 0x92, 0xa3, 0x1e,
+    0x85, 0x58, 0x57, 0x57, 0x0c, 0x80, 0x44, 0xa7, 0xae, 0x45, 0x79, 0xe4, 0x76, 0x9a, 0x92,
+    0xa6, 0xc5, 0x62, 0xaa, 0x46, 0x08, 0xdd, 0x56, 0x63, 0x5d, 0x62, 0x28, 0xc2, 0x25, 0xd3,
+    0xe0, 0x74, 0x1b, 0xaa, 0xe3, 0x37, 0x6d, 0x62, 0xc2, 0x50, 0xd6, 0xe9, 0x9d, 0xe9, 0x93,
+    0x34, 0xdd, 0xd9, 0x15, 0xc5, 0x47, 0x73, 0xae, 0x44, 0x72, 0x65, 0x2e, 0x3d, 0x0b, 0x0a,
+    0xbb, 0x1e, 0xaf, 0xa9, 0x2f, 0x0f, 0x6a, 0x1b, 0xdf, 0x7d, 0x52, 0x95, 0xfa, 0x32, 0x1c,
+    0x59, 0xd4, 0x64, 0x51, 0xc5, 0x73, 0xeb, 0xad, 0xce, 0xb8, 0xdf, 0x65, 0x2f, 0xe0, 0x41,
+    0xa9, 0xd7, 0x5f, 0x80, 0x7f, 0xac, 0x8e, 0x55, 0xfa, 0xa5, 0x55, 0xd0, 0xad, 0x2e, 0xc6,
+    0xf2, 0xb5, 0x49, 0xda, 0xb1, 0x62, 0xd6, 0x6c, 0x64, 0x3c, 0x5c, 0x05, 0x3f, 0xed, 0x02,
+    0x2a, 0xf4, 0x77, 0x51, 0xc8, 0x32, 0x93, 0x2b, 0x0f, 0x63, 0x9a, 0x68, 0x57, 0xb6, 0xe4,
+    0xcc, 0xc4, 0x13, 0x48, 0xad, 0x86, 0x06, 0x99, 0x9c, 0xf3, 0x9a, 0x29, 0x93, 0x73, 0xaf,
+    0xd3, 0xbc, 0x4a, 0x96, 0xd6, 0x3e, 0x51, 0x1c, 0xe3, 0x15, 0xcd, 0xea, 0x17, 0x3f, 0x6a,
+    0xb9, 0x69, 0x07, 0x73, 0x55, 0x73, 0x45, 0x24, 0xac, 0x5c, 0xaa, 0x39, 0x2b, 0x30, 0xed,
+    0x4c, 0x61, 0x83, 0x9c, 0x9a, 0x7d, 0x38, 0x00, 0x7a, 0xd5, 0x26, 0x67, 0x61, 0x14, 0x9c,
+    0x53, 0xc0, 0xa5, 0x01, 0x69, 0xdc, 0x53, 0x45, 0x24, 0x2a, 0xf1, 0x52, 0x83, 0x51, 0x02,
+    0x31, 0x4e, 0x06, 0x99, 0x48, 0x9d, 0x4d, 0x3f, 0x8e, 0xd5, 0x00, 0x6a, 0x78, 0x90, 0x0e,
+    0xb4, 0x16, 0x9a, 0x2c, 0xa3, 0x71, 0x52, 0x55, 0x21, 0x38, 0x07, 0x3f, 0xd6, 0x9e, 0x2e,
+    0xbf, 0xd9, 0xa2, 0xc5, 0xa9, 0x22, 0xdd, 0x56, 0x96, 0x3d, 0xa7, 0x20, 0x71, 0xfc, 0xa9,
+    0x86, 0xf7, 0x6f, 0x50, 0x05, 0x31, 0xf5, 0x11, 0x8e, 0x10, 0x1a, 0xa4, 0x99, 0x32, 0x94,
+    0x58, 0xb5, 0x75, 0x1b, 0x72, 0x29, 0xf6, 0xac, 0x95, 0xb9, 0x66, 0x6f, 0xbb, 0xc5, 0x5e,
+    0x5b, 0x86, 0x0a, 0x30, 0xa3, 0x15, 0x4d, 0x0a, 0x12, 0x45, 0xba, 0x6c, 0xbf, 0xea, 0x9b,
+    0xe9, 0x55, 0xfe, 0xd4, 0xc3, 0xf8, 0x01, 0xa6, 0x49, 0x76, 0x4a, 0x10, 0x53, 0x00, 0xd0,
+    0x93, 0x2d, 0xc9, 0x09, 0x56, 0xad, 0xd7, 0x0a, 0x5b, 0xd6, 0xb2, 0xcd, 0xfc, 0x4a, 0xf8,
+    0x6c, 0xfe, 0x55, 0x6d, 0x35, 0x38, 0x70, 0x00, 0x53, 0x8f, 0x6a, 0x6e, 0xe4, 0x42, 0x71,
+    0xbe, 0xac, 0xd0, 0xa2, 0xaa, 0xa5, 0xf4, 0x0f, 0xfc, 0x7b, 0x7e, 0xb5, 0x61, 0x59, 0x58,
+    0x65, 0x58, 0x11, 0xec, 0x69, 0x1b, 0x26, 0x9e, 0xc3, 0xe9, 0x45, 0x34, 0x1a, 0x5a, 0x43,
+    0x24, 0x53, 0x4b, 0x51, 0x83, 0x8a, 0x52, 0xfe, 0x94, 0xac, 0x21, 0xf4, 0xe0, 0x6a, 0x09,
+    0x2e, 0xa0, 0x84, 0x7e, 0xf2, 0x55, 0x5f, 0x6c, 0xd5, 0x39, 0x35, 0xbb, 0x34, 0xc8, 0x0c,
+    0xcc, 0x7d, 0x85, 0x16, 0x6c, 0x4e, 0x71, 0x5b, 0xb3, 0x50, 0x70, 0x6a, 0xdd, 0xb1, 0xfd,
+    0xea, 0xd7, 0x39, 0xfd, 0xba, 0x0f, 0xdc, 0xb7, 0x76, 0xfc, 0x6a, 0x7b, 0x6d, 0x66, 0xe3,
+    0x78, 0x2b, 0x66, 0xc7, 0xf3, 0xa1, 0xc5, 0xd8, 0x4a, 0xb4, 0x2f, 0xb9, 0xe8, 0x8f, 0x72,
+    0x13, 0x4e, 0xdb, 0x91, 0xd2, 0xb9, 0x7b, 0x89, 0x37, 0x48, 0xc7, 0x35, 0x4a, 0xe3, 0xc4,
+    0x17, 0x8d, 0x10, 0x51, 0x62, 0xf8, 0xff, 0x00, 0x74, 0xd6, 0x5b, 0x6b, 0x77, 0x00, 0xe5,
+    0xec, 0xdf, 0xf2, 0x3f, 0xe1, 0x51, 0x0a, 0x6d, 0x1a, 0x54, 0xaf, 0x16, 0x6c, 0x31, 0xc9,
+    0xa4, 0xcd, 0x62, 0x9f, 0x10, 0x28, 0xfb, 0xd6, 0xb2, 0x8a, 0x55, 0xf1, 0x1d, 0xa1, 0x38,
+    0x64, 0x91, 0x7f, 0x0a, 0xd3, 0x95, 0x99, 0xfb, 0x48, 0xbe, 0xa6, 0xcf, 0x14, 0x56, 0x62,
+    0x6b, 0xd6, 0x0c, 0x7f, 0xd6, 0x11, 0xf5, 0x5a, 0xb5, 0x1e, 0xa3, 0x67, 0x2f, 0xdc, 0xb8,
+    0x43, 0xf8, 0xd2, 0xb3, 0x1f, 0x34, 0x7b, 0x96, 0x68, 0xa4, 0x0c, 0xac, 0x32, 0xac, 0x0f,
+    0xd0, 0xd2, 0xd2, 0x28, 0x28, 0xa4, 0xe2, 0x8c, 0xd0, 0x03, 0xa9, 0x29, 0x01, 0x27, 0xad,
+    0x2d, 0x00, 0x2d, 0x1c, 0x52, 0x51, 0x40, 0x0e, 0x0d, 0x83, 0x49, 0x24, 0xa5, 0xf8, 0x35,
+    0x1b, 0x38, 0x1d, 0xc0, 0xa8, 0x9a, 0xe6, 0x05, 0xfb, 0xd3, 0x46, 0x3e, 0xac, 0x05, 0x34,
+    0x85, 0x7b, 0x12, 0xf3, 0x48, 0x4e, 0x05, 0x40, 0x6f, 0xed, 0x07, 0x4b, 0x98, 0x49, 0xff,
+    0x00, 0x7c, 0x52, 0x7d, 0xa2, 0x17, 0xfb, 0xb3, 0x46, 0x7e, 0x8c, 0x0d, 0x55, 0x84, 0xda,
+    0x1c, 0xf2, 0x31, 0xe0, 0x71, 0x50, 0x94, 0xcf, 0x6a, 0x9c, 0x05, 0x23, 0x8c, 0x1a, 0x5c,
+    0x01, 0x4c, 0x56, 0xb9, 0x5f, 0xcb, 0xe3, 0xa5, 0x28, 0x8f, 0x3e, 0x95, 0x60, 0x0a, 0x30,
+    0x28, 0xb8, 0x72, 0x90, 0xf9, 0x78, 0xa3, 0xcb, 0xab, 0x01, 0x7d, 0x29, 0x38, 0xa2, 0xe3,
+    0xe5, 0x29, 0xdc, 0x27, 0xee, 0x1f, 0xe9, 0x50, 0xd9, 0x8c, 0x46, 0x47, 0xbd, 0x5b, 0xb9,
+    0x5f, 0xdc, 0x3e, 0x3d, 0x2a, 0xa5, 0xa1, 0xc6, 0xe1, 0x54, 0xb6, 0x32, 0x92, 0xf7, 0xd1,
+    0x34, 0xa3, 0xe5, 0xac, 0xfe, 0xf5, 0xa5, 0x20, 0xe3, 0xbd, 0x53, 0x31, 0x8d, 0xc6, 0x9a,
+    0x14, 0xd0, 0x91, 0x67, 0x20, 0x0a, 0xb7, 0xb4, 0x03, 0x9a, 0x81, 0x30, 0x18, 0x55, 0x83,
+    0x80, 0x33, 0x43, 0x08, 0xad, 0x07, 0xb1, 0xdc, 0xb9, 0xf6, 0xa0, 0x72, 0x33, 0x48, 0x87,
+    0x29, 0x48, 0xad, 0xd4, 0x54, 0xd8, 0xd0, 0x1e, 0x42, 0x98, 0x20, 0xd4, 0x6f, 0x78, 0xd8,
+    0xc6, 0x7f, 0x5a, 0x24, 0xe6, 0x36, 0xf5, 0xaa, 0x25, 0x80, 0xef, 0x4e, 0xc6, 0x73, 0x93,
+    0x44, 0xe1, 0xda, 0x46, 0x24, 0xf4, 0x14, 0xac, 0xe0, 0x70, 0x3a, 0xd5, 0x65, 0x7e, 0xd9,
+    0xc5, 0x3a, 0x8b, 0x10, 0x98, 0xe2, 0xd9, 0x3c, 0xd3, 0x68, 0xa4, 0xa4, 0x26, 0xc0, 0x9a,
+    0x69, 0xa5, 0x34, 0xc6, 0x6c, 0x74, 0xa4, 0x40, 0x8c, 0x68, 0x53, 0xda, 0x9a, 0x4d, 0x33,
+    0x7f, 0x38, 0x14, 0x01, 0x72, 0x16, 0x3b, 0x80, 0x15, 0xd8, 0xf8, 0x56, 0x03, 0x36, 0xa3,
+    0x11, 0x6e, 0x44, 0x63, 0x79, 0xfe, 0x95, 0xc6, 0x5a, 0xf5, 0x15, 0xe8, 0x9e, 0x0e, 0x8b,
+    0xf7, 0x72, 0x4b, 0x8e, 0x58, 0x85, 0x1f, 0x87, 0x26, 0xb1, 0xac, 0xed, 0x13, 0xaf, 0x0a,
+    0xaf, 0x23, 0xbf, 0xb5, 0x61, 0x15, 0xbe, 0x4f, 0x19, 0xf9, 0x8d, 0x71, 0x1e, 0x31, 0xd4,
+    0x30, 0x89, 0x08, 0x3c, 0xb1, 0x2e, 0xd5, 0xd5, 0xcb, 0x30, 0x48, 0x4f, 0x3c, 0x63, 0x15,
+    0xe5, 0xbe, 0x26, 0xbe, 0xf3, 0xf5, 0x29, 0xce, 0x73, 0x83, 0xb7, 0xf2, 0xae, 0x3c, 0x3c,
+    0x79, 0xa5, 0x73, 0xae, 0xab, 0xe4, 0x8b, 0x7d, 0xce, 0x72, 0xfa, 0x72, 0x49, 0xe6, 0xb1,
+    0xdd, 0x8b, 0xb9, 0xab, 0x97, 0x1b, 0x9d, 0x8e, 0x78, 0x15, 0x50, 0x80, 0xbd, 0x2b, 0xbc,
+    0xf2, 0x26, 0xee, 0xc4, 0xa2, 0x8c, 0xd3, 0x4b, 0x50, 0x40, 0xb9, 0xa6, 0xb3, 0x01, 0x51,
+    0xb4, 0xb9, 0xe0, 0x54, 0x12, 0x4a, 0xb1, 0xa9, 0x67, 0x60, 0x00, 0xee, 0x4d, 0x26, 0xcb,
+    0x51, 0x6c, 0x99, 0xa4, 0xae, 0x5e, 0xfe, 0x62, 0xfa, 0xb9, 0x66, 0xe4, 0x2b, 0x01, 0x8a,
+    0xbd, 0x36, 0xb2, 0x81, 0xb6, 0xc1, 0x1b, 0x48, 0x7d, 0x6b, 0x35, 0xed, 0xaf, 0x2e, 0x66,
+    0x69, 0x85, 0xbb, 0xe5, 0x8e, 0x78, 0x15, 0xcb, 0x5a, 0x6a, 0x4a, 0xd1, 0xd4, 0xea, 0xa5,
+    0x0e, 0x5d, 0x59, 0xd6, 0x45, 0x73, 0x6f, 0xf2, 0x8d, 0xc8, 0x33, 0x56, 0x76, 0xc0, 0xcb,
+    0xfc, 0x24, 0x57, 0x21, 0x1d, 0xa6, 0xa6, 0x17, 0xfd, 0x43, 0xe3, 0xdc, 0x52, 0x48, 0xda,
+    0x85, 0xbf, 0xfc, 0xb3, 0x75, 0xf7, 0xaa, 0xf6, 0xda, 0x6a, 0x89, 0xf6, 0x4b, 0xa3, 0x3a,
+    0x89, 0x2c, 0x6c, 0xdf, 0x39, 0x88, 0x7e, 0x07, 0x15, 0x56, 0x4d, 0x2e, 0xd4, 0xf4, 0x0c,
+    0x3f, 0x1a, 0xc0, 0x4d, 0x62, 0xe9, 0x38, 0x66, 0x35, 0x62, 0x3d, 0x69, 0x9b, 0xef, 0xb7,
+    0xe6, 0x2a, 0x7d, 0xac, 0x19, 0x5c, 0x92, 0x45, 0xd7, 0xd2, 0xa0, 0xe7, 0xe7, 0x7f, 0xce,
+    0xa2, 0xfe, 0xce, 0x81, 0x4f, 0x73, 0xf5, 0x34, 0xd1, 0xa8, 0xee, 0xea, 0x41, 0x1e, 0xd4,
+    0xff, 0x00, 0x3c, 0x38, 0xc8, 0x39, 0xa3, 0xdd, 0x17, 0xbc, 0x85, 0xfb, 0x1d, 0xb0, 0x1f,
+    0x73, 0xf5, 0xa8, 0xa4, 0xb2, 0xb7, 0x23, 0x85, 0x00, 0xd3, 0x1e, 0x72, 0x1b, 0x15, 0x1b,
+    0x4f, 0x93, 0xd4, 0xd2, 0x76, 0x05, 0x72, 0xbd, 0xd6, 0x9e, 0x48, 0xdc, 0xac, 0x38, 0x1d,
+    0x00, 0xac, 0xe3, 0x1b, 0xa1, 0xc8, 0xfd, 0x2b, 0x55, 0xa7, 0x6f, 0x5c, 0x8a, 0x86, 0x58,
+    0xd6, 0x51, 0xb9, 0x78, 0x6a, 0xca, 0x70, 0x4f, 0x54, 0x69, 0x19, 0x3e, 0xa5, 0x78, 0xae,
+    0xd8, 0x0d, 0xac, 0x72, 0x2a, 0x46, 0x21, 0xb9, 0x15, 0x0b, 0xc5, 0x93, 0xe8, 0x69, 0xa8,
+    0x59, 0x0f, 0xf4, 0xa9, 0x52, 0x6b, 0x46, 0x55, 0xbb, 0x12, 0xf4, 0xa5, 0x0d, 0x8a, 0x4f,
+    0xbc, 0x29, 0x0a, 0xd5, 0x01, 0x2c, 0x6f, 0xfb, 0xe5, 0x3e, 0xf5, 0x65, 0xfe, 0x64, 0x75,
+    0xfa, 0xd5, 0x11, 0xc1, 0x07, 0xd2, 0xae, 0x6e, 0xf9, 0x8f, 0xbd, 0x52, 0x64, 0x48, 0xa8,
+    0x66, 0xda, 0x9b, 0x48, 0xcd, 0x42, 0x48, 0x61, 0x4e, 0x90, 0x73, 0x8a, 0x8f, 0x18, 0x35,
+    0x94, 0x9b, 0x2d, 0x21, 0xbd, 0x0f, 0xb5, 0x38, 0x31, 0x14, 0xb8, 0xcd, 0x20, 0x5c, 0x71,
+    0x52, 0x31, 0x24, 0x50, 0xc3, 0x70, 0xeb, 0x4c, 0x52, 0x47, 0x5a, 0x98, 0x0c, 0x53, 0x4a,
+    0x8c, 0xd0, 0xd7, 0x50, 0x14, 0x72, 0x31, 0x49, 0xb6, 0x94, 0x1c, 0x52, 0x92, 0x29, 0x80,
+    0x80, 0x73, 0x43, 0x47, 0xb5, 0xbd, 0x8d, 0x1b, 0x85, 0x29, 0x6d, 0xcb, 0xee, 0x29, 0xe8,
+    0x02, 0x15, 0xca, 0x91, 0x52, 0xd8, 0x36, 0x43, 0x27, 0xa5, 0x57, 0xf3, 0x6a, 0x5b, 0x0f,
+    0xf8, 0xfb, 0x23, 0xd4, 0x1a, 0x49, 0xae, 0x64, 0x27, 0xb1, 0x0d, 0xcc, 0x7b, 0x26, 0x3e,
+    0x86, 0xa1, 0xab, 0x97, 0xc0, 0x06, 0x3f, 0x5a, 0xa8, 0x06, 0x4e, 0x2a, 0x24, 0xac, 0xc6,
+    0xb6, 0x15, 0x5f, 0x68, 0x22, 0xa5, 0x46, 0xe3, 0x35, 0x0b, 0x0c, 0x1c, 0x52, 0x06, 0x2b,
+    0xd0, 0xd0, 0x9d, 0x86, 0x4f, 0x9a, 0x29, 0x15, 0xb7, 0x0a, 0x78, 0x5a, 0xb5, 0xa8, 0x86,
+    0xd2, 0xe2, 0x9c, 0x10, 0x9e, 0x82, 0x9d, 0xb7, 0x1f, 0x5a, 0xa5, 0x10, 0xb9, 0x19, 0x04,
+    0xf0, 0x29, 0x56, 0x30, 0x2a, 0x40, 0x29, 0x69, 0xa8, 0x8a, 0xe2, 0x01, 0x8a, 0x3a, 0x50,
+    0x4d, 0x31, 0x9f, 0x14, 0xdb, 0xb0, 0x0e, 0x26, 0xa3, 0x67, 0xc5, 0x31, 0xa4, 0xa4, 0x40,
+    0x4f, 0xcc, 0x6b, 0x37, 0x2b, 0xec, 0x3b, 0x12, 0x03, 0xc5, 0x47, 0x23, 0x60, 0x7b, 0xd3,
+    0x89, 0xa6, 0x79, 0x64, 0xf2, 0x4f, 0x34, 0x9d, 0xc0, 0xb5, 0x4b, 0x51, 0x82, 0x71, 0x4f,
+    0x06, 0xad, 0x31, 0x0e, 0xa5, 0xa6, 0xd1, 0x9c, 0x75, 0xaa, 0xb8, 0x0f, 0xa5, 0xa6, 0x83,
+    0x4b, 0x4c, 0x06, 0xb4, 0x28, 0xfd, 0x47, 0x3e, 0xb5, 0x5d, 0xed, 0x5c, 0x72, 0x87, 0x35,
+    0x6e, 0x96, 0xa5, 0xc5, 0x30, 0x28, 0x46, 0x02, 0xcc, 0x3c, 0xe0, 0x48, 0xcf, 0x39, 0xad,
+    0x88, 0x16, 0xd9, 0xc8, 0x2b, 0x8f, 0xa0, 0xaa, 0xac, 0xaa, 0xe3, 0x0c, 0x01, 0xa8, 0x1e,
+    0xd8, 0xa9, 0xdd, 0x1b, 0x10, 0x68, 0x8d, 0xe1, 0xd2, 0xe0, 0xf5, 0x3a, 0x68, 0xe1, 0x4d,
+    0xa3, 0x1f, 0xa5, 0x29, 0x8b, 0x69, 0xce, 0x0e, 0x2b, 0x9c, 0x87, 0x54, 0xba, 0xb5, 0x21,
+    0x18, 0x96, 0x03, 0xb3, 0x56, 0xcd, 0xae, 0xae, 0xb3, 0x28, 0xdc, 0x30, 0x4f, 0x7a, 0xe8,
+    0x8d, 0x58, 0xcb, 0x43, 0x19, 0x42, 0x48, 0xbc, 0x23, 0x38, 0xe8, 0x33, 0x4d, 0x62, 0xcb,
+    0xd5, 0x57, 0xf0, 0xa1, 0x2e, 0x01, 0x1c, 0x80, 0x47, 0xb5, 0x35, 0x9f, 0x73, 0x13, 0x5a,
+    0x99, 0xa4, 0xef, 0xa8, 0xbe, 0x68, 0xfe, 0xe8, 0xa3, 0xcc, 0x53, 0xfc, 0x34, 0xdc, 0x83,
+    0xd4, 0x55, 0x77, 0x24, 0x39, 0xc5, 0x17, 0x2d, 0x45, 0x32, 0xd6, 0xf4, 0x3d, 0x88, 0xa0,
+    0x3a, 0x83, 0xfe, 0x35, 0x4f, 0xcc, 0x71, 0xe9, 0x48, 0x67, 0x61, 0xd4, 0x11, 0x4b, 0x99,
+    0x0f, 0x90, 0xbf, 0x98, 0x9b, 0xef, 0x22, 0x9a, 0x41, 0x6f, 0x03, 0x36, 0x54, 0x15, 0x3e,
+    0xd5, 0x48, 0x5c, 0x8e, 0xe2, 0x9d, 0xf6, 0xa4, 0x03, 0x39, 0x22, 0x8e, 0x64, 0x2e, 0x47,
+    0xd0, 0xd4, 0x8c, 0x4d, 0x18, 0xf9, 0x26, 0x27, 0xd9, 0xb9, 0xa9, 0xd6, 0xf2, 0x64, 0xfb,
+    0xe8, 0x4f, 0xb8, 0xe6, 0xb1, 0x53, 0x51, 0x65, 0x6e, 0x1b, 0x23, 0xd0, 0xd6, 0x84, 0x37,
+    0xb1, 0xca, 0x06, 0x78, 0x3e, 0x94, 0xd3, 0x4c, 0xca, 0x51, 0x92, 0xd4, 0xd1, 0x4b, 0xf8,
+    0x9b, 0x82, 0x70, 0x7d, 0xea, 0xc2, 0xc8, 0xad, 0xd0, 0x83, 0x59, 0xa5, 0x51, 0xc7, 0x38,
+    0x34, 0xdf, 0x2f, 0x61, 0xca, 0x12, 0xbf, 0x4a, 0x76, 0x27, 0x98, 0xd7, 0x14, 0xf1, 0x8f,
+    0x5a, 0xcb, 0x5b, 0xa9, 0x90, 0x73, 0x86, 0xfa, 0xf1, 0x56, 0x23, 0xbb, 0x57, 0x20, 0x10,
+    0x54, 0xf7, 0xa2, 0xc3, 0x52, 0x45, 0xed, 0xc3, 0xd6, 0x93, 0x70, 0x3d, 0x2a, 0x1f, 0x3a,
+    0x2e, 0xec, 0x29, 0xc2, 0xe2, 0x31, 0xd3, 0xf5, 0xa6, 0x8a, 0xb9, 0x28, 0xcf, 0xa5, 0x48,
+    0x01, 0xf5, 0xaa, 0xa2, 0xf1, 0x09, 0xc0, 0x61, 0x49, 0x2e, 0xa1, 0x14, 0x23, 0x2c, 0xeb,
+    0x4c, 0x77, 0x45, 0xdc, 0x7d, 0x68, 0xca, 0x2f, 0xde, 0xc0, 0xfa, 0xd6, 0x24, 0xda, 0xe2,
+    0xf2, 0x14, 0x9f, 0xc3, 0x8a, 0xa4, 0xfa, 0xac, 0x92, 0x7d, 0xd1, 0x81, 0x42, 0x1d, 0x9f,
+    0x44, 0x74, 0x32, 0xdf, 0x43, 0x17, 0x41, 0x93, 0x54, 0x65, 0xd4, 0xdd, 0xf2, 0x14, 0x85,
+    0x1e, 0xd5, 0x88, 0x6e, 0x19, 0x8e, 0x58, 0xd3, 0x96, 0x40, 0xdc, 0x96, 0x15, 0x69, 0xa0,
+    0x71, 0x97, 0x53, 0x47, 0xcf, 0x2c, 0x72, 0x5f, 0x27, 0xeb, 0x53, 0x47, 0x2a, 0x8e, 0xad,
+    0x54, 0xa3, 0x31, 0xf1, 0xc8, 0x35, 0x7a, 0x11, 0x0e, 0x46, 0x4a, 0xe6, 0xa8, 0xc9, 0xab,
+    0x32, 0xfc, 0x2c, 0x98, 0x04, 0xe7, 0x1f, 0x4a, 0x9b, 0xcf, 0x5f, 0x43, 0x50, 0x09, 0x60,
+    0x18, 0xf9, 0x96, 0x8f, 0x3e, 0x0f, 0xef, 0xad, 0x33, 0x44, 0xed, 0xd4, 0xb1, 0xe7, 0xaf,
+    0xbd, 0x45, 0x73, 0x72, 0x8b, 0x11, 0xe7, 0x93, 0x4d, 0xfb, 0x44, 0x1f, 0xdf, 0x5a, 0xce,
+    0xb9, 0xba, 0x86, 0x59, 0x30, 0x18, 0x6d, 0x1c, 0x50, 0x0e, 0x4e, 0xda, 0x01, 0x90, 0x3b,
+    0x67, 0x35, 0x22, 0x4b, 0xb6, 0xaa, 0x19, 0x11, 0x47, 0xca, 0x57, 0xf3, 0xa8, 0xbc, 0xfc,
+    0x93, 0xf3, 0xe3, 0xe9, 0x4e, 0xe6, 0x6a, 0x0d, 0xec, 0x6e, 0x45, 0x71, 0x14, 0x9c, 0x48,
+    0x80, 0x1f, 0x5a, 0x9f, 0xcb, 0x45, 0xe5, 0x1d, 0x94, 0xfb, 0x1a, 0xe7, 0x0d, 0xc9, 0x41,
+    0x9c, 0x92, 0x69, 0xeb, 0xac, 0xc8, 0x14, 0x2e, 0xdf, 0x6a, 0x57, 0x46, 0x8a, 0x32, 0xec,
+    0x6f, 0x49, 0xa8, 0xcb, 0x6a, 0xb9, 0xde, 0x5c, 0x0e, 0xcd, 0x4d, 0x5f, 0x14, 0x40, 0x17,
+    0x0f, 0x1b, 0x06, 0xff, 0x00, 0x64, 0xe4, 0x56, 0x1b, 0x7d, 0xaa, 0xf7, 0x19, 0x05, 0x57,
+    0xfd, 0xaa, 0x9a, 0x1d, 0x1f, 0x80, 0x5b, 0x27, 0xdf, 0xb5, 0x0f, 0x52, 0xa3, 0x26, 0xb7,
+    0x66, 0x9b, 0x78, 0x90, 0xc9, 0xc4, 0x31, 0x0f, 0x6c, 0xf3, 0x55, 0xa4, 0xbd, 0xbe, 0xb8,
+    0xeb, 0x21, 0x03, 0xd1, 0x78, 0xa9, 0x53, 0x4f, 0x86, 0x35, 0xef, 0x9f, 0x51, 0x51, 0xca,
+    0xbf, 0x67, 0x5d, 0xc0, 0xe4, 0x1f, 0x5a, 0x12, 0x22, 0x72, 0x91, 0x6f, 0x4f, 0xd2, 0xd2,
+    0x73, 0xe6, 0x5d, 0x39, 0x3e, 0x83, 0x35, 0xd0, 0xda, 0x69, 0xfa, 0x5d, 0xbe, 0x18, 0xc4,
+    0x8c, 0xdf, 0xed, 0x0c, 0xd7, 0x22, 0xb7, 0x8c, 0x87, 0x2a, 0xd8, 0xab, 0x03, 0x59, 0x75,
+    0x1c, 0xb7, 0xea, 0x69, 0x35, 0x7e, 0xa5, 0xd3, 0xa9, 0x18, 0xee, 0x8e, 0xe6, 0x3b, 0xab,
+    0x58, 0xfe, 0xe4, 0x4a, 0xa3, 0xd9, 0x40, 0xab, 0x31, 0xdf, 0xc6, 0x39, 0x00, 0x7e, 0x75,
+    0xc0, 0x2f, 0x88, 0xf6, 0x10, 0x01, 0x27, 0xf1, 0xa9, 0x87, 0x89, 0x64, 0x03, 0xee, 0xb7,
+    0xfd, 0xf5, 0x59, 0xfb, 0x33, 0xa1, 0x62, 0x12, 0x3b, 0xd3, 0x7c, 0x18, 0xfd, 0xda, 0x6f,
+    0xdb, 0x07, 0xf7, 0x0d, 0x70, 0xc3, 0xc4, 0x8e, 0x7b, 0x30, 0xfc, 0x68, 0x3e, 0x22, 0x63,
+    0xfc, 0x4d, 0xf9, 0xd1, 0xec, 0xc7, 0xf5, 0x98, 0x9d, 0xac, 0xb7, 0x51, 0xec, 0x3b, 0xa3,
+    0x07, 0xd8, 0xd6, 0x64, 0xf1, 0xd9, 0xdc, 0x64, 0xb5, 0xb4, 0x40, 0x9f, 0x55, 0x15, 0xcd,
+    0x9d, 0x75, 0x9b, 0xd7, 0xf1, 0x7a, 0x69, 0xd6, 0x8b, 0x0c, 0x64, 0x8f, 0xc6, 0x9a, 0x85,
+    0x88, 0x95, 0x78, 0xb3, 0x56, 0x5b, 0x1d, 0x30, 0x92, 0xaf, 0x0c, 0x7f, 0x80, 0x22, 0xab,
+    0x49, 0xa2, 0xe9, 0xae, 0x3e, 0x42, 0x57, 0xe8, 0xf5, 0x9a, 0x75, 0x04, 0x3c, 0xee, 0x6f,
+    0xc6, 0xac, 0x5a, 0xea, 0x4a, 0x8f, 0x83, 0xc8, 0x3d, 0xf3, 0x57, 0x63, 0x2f, 0x69, 0x16,
+    0xf5, 0x43, 0x9f, 0x4a, 0x78, 0x3e, 0x6b, 0x5b, 0xd7, 0x52, 0x3b, 0x13, 0x51, 0x0b, 0xfd,
+    0x5e, 0xd0, 0xe1, 0xd4, 0x4a, 0xa3, 0xbd, 0x6b, 0xad, 0xfd, 0xbb, 0x0c, 0x32, 0x83, 0xf5,
+    0x15, 0x21, 0xb8, 0xb4, 0x7f, 0xbc, 0x98, 0xfc, 0x28, 0xf5, 0x2b, 0x95, 0x7d, 0x96, 0x65,
+    0xc5, 0xe2, 0x54, 0x18, 0x17, 0x36, 0xef, 0x19, 0xf5, 0x1c, 0x8a, 0xd0, 0x8f, 0x59, 0xd3,
+    0xe4, 0x4d, 0xc2, 0xea, 0x31, 0xfe, 0xf1, 0xc5, 0x0d, 0x05, 0x94, 0xbd, 0x02, 0xfe, 0x3c,
+    0x56, 0x7d, 0xcf, 0x87, 0xec, 0x6e, 0x32, 0x40, 0x0a, 0x7d, 0x54, 0xd4, 0xb4, 0x8a, 0x5c,
+    0xcb, 0xcc, 0x96, 0x7f, 0x13, 0xe9, 0xd0, 0xe4, 0x23, 0xb4, 0xad, 0xe8, 0x82, 0xaa, 0x8f,
+    0x12, 0x5d, 0xdc, 0xb6, 0xdb, 0x4b, 0x0c, 0xe7, 0xa1, 0x73, 0x58, 0x37, 0x5a, 0x4c, 0xd6,
+    0x93, 0x31, 0xb7, 0x75, 0x70, 0xa7, 0xa1, 0xeb, 0x55, 0x53, 0x57, 0xb8, 0xb6, 0x97, 0x24,
+    0x94, 0x61, 0xdc, 0x0a, 0x9b, 0xa5, 0xf1, 0x68, 0x2e, 0x67, 0x2f, 0x84, 0xec, 0x52, 0xdb,
+    0xc4, 0x97, 0xb8, 0x3e, 0x6c, 0x16, 0xea, 0x7d, 0x07, 0x35, 0x3a, 0xf8, 0x63, 0x51, 0x97,
+    0xfe, 0x3e, 0x35, 0x89, 0x3e, 0x8a, 0x31, 0x5c, 0xc4, 0x3e, 0x26, 0xd4, 0x09, 0x01, 0x6e,
+    0xf2, 0x0f, 0x63, 0x5a, 0xd0, 0x6b, 0x73, 0x48, 0xa0, 0x49, 0x70, 0xdb, 0xbb, 0xe5, 0xaa,
+    0x96, 0xbb, 0x31, 0xb9, 0x45, 0x7c, 0x48, 0xd5, 0xff, 0x00, 0x84, 0x32, 0xdd, 0xbf, 0xd6,
+    0xea, 0x17, 0x2f, 0xff, 0x00, 0x03, 0xa7, 0x8f, 0x05, 0xe9, 0x4a, 0x3e, 0x6f, 0x35, 0x8f,
+    0xa9, 0x7a, 0xad, 0x16, 0xa4, 0x40, 0xe5, 0x81, 0xf7, 0xdf, 0x52, 0x8d, 0x51, 0x7b, 0xba,
+    0xff, 0x00, 0xdf, 0x74, 0x72, 0x31, 0xa9, 0xd3, 0x26, 0x1e, 0x11, 0xd1, 0x87, 0x58, 0x49,
+    0xfa, 0xb9, 0xa4, 0x6f, 0x08, 0x68, 0xce, 0x31, 0xe4, 0x11, 0xfe, 0xeb, 0x1a, 0x74, 0x7a,
+    0x8a, 0xb6, 0x31, 0x83, 0x9f, 0xf6, 0xaa, 0x61, 0x7b, 0x8e, 0xc9, 0xf9, 0x9a, 0x5c, 0xac,
+    0xd1, 0x38, 0x33, 0x3d, 0xfc, 0x17, 0x64, 0x87, 0x75, 0xb5, 0xc5, 0xd4, 0x27, 0xd1, 0x5e,
+    0xa2, 0x3a, 0x06, 0xab, 0x07, 0xfc, 0x7b, 0x6a, 0x53, 0x11, 0xe9, 0x26, 0x1b, 0xf9, 0xd6,
+    0xb1, 0xd4, 0x40, 0x1d, 0x47, 0xe4, 0x69, 0x87, 0x53, 0x6c, 0xf0, 0x01, 0xfc, 0x28, 0x51,
+    0x62, 0x6a, 0x06, 0x14, 0xf7, 0x3a, 0xfe, 0x9f, 0x20, 0x13, 0x5b, 0xc5, 0x70, 0x87, 0xf8,
+    0x95, 0x70, 0x7f, 0x43, 0x52, 0x47, 0xe2, 0x30, 0xa3, 0xfd, 0x2a, 0xc2, 0xe2, 0x3f, 0x52,
+    0xa3, 0x70, 0xfe, 0x95, 0xab, 0x2e, 0xa3, 0xf2, 0x82, 0xf1, 0x16, 0x1e, 0xd5, 0x9f, 0x25,
+    0xfa, 0x33, 0xff, 0x00, 0xa8, 0x5c, 0x7b, 0xd5, 0xa8, 0xb3, 0x39, 0x49, 0x47, 0x66, 0x4f,
+    0x6f, 0xae, 0x69, 0xf7, 0x47, 0x6c, 0x77, 0x51, 0x86, 0x3f, 0xc2, 0xff, 0x00, 0x29, 0xfd,
+    0x6a, 0xe8, 0x20, 0x8c, 0x83, 0x9a, 0xc7, 0x93, 0xfb, 0x3a, 0xe7, 0xfd, 0x7d, 0x94, 0x6c,
+    0x7d, 0x48, 0xe6, 0xa1, 0x5b, 0x38, 0xe2, 0x6d, 0xd6, 0x17, 0x92, 0xdb, 0xff, 0x00, 0xb0,
+    0xdf, 0x3a, 0xd1, 0x66, 0x0a, 0xa2, 0x36, 0xe6, 0xc1, 0x89, 0x87, 0xb5, 0x67, 0xc2, 0x70,
+    0xf8, 0xaa, 0xe7, 0x55, 0x92, 0xd8, 0xf9, 0x77, 0xca, 0x00, 0xed, 0x2c, 0x7c, 0xa9, 0xfc,
+    0x3b, 0x52, 0xa4, 0xaa, 0xd8, 0x74, 0x60, 0xcb, 0xd8, 0x83, 0xc1, 0xaa, 0x44, 0x49, 0xdd,
+    0xdc, 0xd1, 0x2d, 0x91, 0x55, 0x5c, 0x8d, 0xc7, 0x9e, 0xb5, 0x32, 0xb8, 0x64, 0x07, 0xb5,
+    0x54, 0x96, 0x4e, 0x70, 0x0f, 0x4a, 0x68, 0x73, 0x7a, 0x0f, 0xdd, 0x8a, 0xb1, 0x13, 0x06,
+    0x5e, 0x6b, 0x3c, 0xc9, 0x4f, 0x82, 0x62, 0x24, 0x0a, 0x7a, 0x1a, 0x76, 0x22, 0x32, 0xd4,
+    0xd0, 0x07, 0x68, 0xe0, 0xd3, 0x4b, 0x60, 0xfd, 0x68, 0xa6, 0x31, 0xc7, 0x5a, 0x93, 0x47,
+    0xb0, 0xb2, 0x1c, 0x29, 0xac, 0xc7, 0xe1, 0x88, 0xad, 0x1d, 0xd9, 0x5e, 0x6a, 0x85, 0xc2,
+    0xed, 0x7c, 0xf6, 0x34, 0xcc, 0xaa, 0x77, 0x23, 0xcd, 0x4c, 0x92, 0x64, 0x60, 0xf5, 0xaa,
+    0xf9, 0xa5, 0x1c, 0xf7, 0xa0, 0xc9, 0x32, 0xc1, 0x34, 0x84, 0xd4, 0x7b, 0x88, 0x34, 0x16,
+    0xe2, 0x91, 0x42, 0x96, 0xa6, 0x16, 0x14, 0xc7, 0x90, 0x2f, 0x53, 0x55, 0xa4, 0x9b, 0x3c,
+    0x52, 0x25, 0xb2, 0x67, 0x98, 0x67, 0x02, 0x99, 0x1b, 0x73, 0xd6, 0xaa, 0x99, 0x29, 0xc9,
+    0x27, 0x34, 0x85, 0x66, 0x6b, 0xdb, 0xb7, 0x22, 0xbd, 0x3b, 0xc2, 0xaa, 0x16, 0xca, 0x11,
+    0xd3, 0xe4, 0x2e, 0x7f, 0x1a, 0xf2, 0x98, 0x24, 0xce, 0x0d, 0x7a, 0x9f, 0x85, 0xa5, 0x5f,
+    0x29, 0x41, 0x3c, 0x08, 0x40, 0xfe, 0x55, 0xcf, 0x5f, 0xe1, 0x3b, 0xb0, 0x4f, 0xde, 0x36,
+    0xb5, 0x3b, 0x81, 0x05, 0xa9, 0x39, 0xeb, 0xfc, 0x85, 0x79, 0x55, 0xf4, 0xbb, 0xa5, 0x77,
+    0x27, 0x2c, 0x4e, 0x49, 0xae, 0xdf, 0xc5, 0x77, 0xc1, 0x63, 0x31, 0xa9, 0xe9, 0x1f, 0xf3,
+    0xaf, 0x3b, 0xb9, 0x97, 0x39, 0xa8, 0xa1, 0x1b, 0x44, 0xd3, 0x17, 0x3d, 0x6c, 0x53, 0x9d,
+    0xb2, 0xc6, 0xaa, 0x13, 0xcd, 0x49, 0x34, 0x80, 0x67, 0x3d, 0x6a, 0x9b, 0x38, 0x27, 0xad,
+    0x74, 0x1e, 0x6d, 0xae, 0xc9, 0x59, 0xc0, 0x38, 0xea, 0x69, 0x8c, 0x49, 0xa6, 0x07, 0x0a,
+    0x38, 0x19, 0xa4, 0x32, 0x9a, 0x43, 0xe5, 0x15, 0xf0, 0x8a, 0x58, 0xf4, 0x1d, 0x6b, 0x23,
+    0xec, 0xf2, 0x6a, 0x73, 0x92, 0xe4, 0xac, 0x2a, 0x7a, 0x0a, 0xbf, 0x74, 0xfb, 0xe0, 0x2a,
+    0x3a, 0x9a, 0xb1, 0xa7, 0x46, 0xb1, 0xc1, 0xcf, 0x5c, 0xe6, 0xb3, 0x92, 0xe6, 0x76, 0x66,
+    0xb1, 0xf7, 0x63, 0x7e, 0xa2, 0x5a, 0xe9, 0xd6, 0xf6, 0xc3, 0x88, 0x85, 0x6a, 0xc2, 0x51,
+    0x50, 0x6d, 0x4c, 0x7e, 0x15, 0x1c, 0x69, 0xbc, 0xe4, 0x8f, 0x96, 0xa4, 0x91, 0xd5, 0x46,
+    0x05, 0x3d, 0xb6, 0x04, 0x9e, 0xec, 0x1e, 0x7d, 0xa0, 0x92, 0x0e, 0x2a, 0x9c, 0xd7, 0x90,
+    0xe3, 0xe6, 0xe7, 0xf0, 0xa8, 0x6e, 0xa7, 0x67, 0x05, 0x47, 0x4a, 0xcf, 0x60, 0x3b, 0x8a,
+    0x96, 0xc7, 0xcc, 0x4d, 0x3c, 0x36, 0x37, 0x20, 0xe6, 0x34, 0x27, 0xe9, 0x83, 0x58, 0xf7,
+    0x5a, 0x4a, 0xa6, 0x5a, 0x16, 0x38, 0xfe, 0xe9, 0xab, 0xac, 0x40, 0xa8, 0xcb, 0x1c, 0x70,
+    0x4d, 0x65, 0x24, 0x9e, 0xe5, 0xc6, 0x4c, 0xc7, 0x11, 0x94, 0x3c, 0x64, 0x1a, 0x95, 0x1d,
+    0x81, 0xab, 0x32, 0x47, 0x92, 0x4d, 0x44, 0x57, 0x9a, 0xcd, 0x46, 0xdb, 0x17, 0xcd, 0x71,
+    0x49, 0xdf, 0xd7, 0xad, 0x46, 0xc8, 0xc3, 0xbd, 0x3c, 0x75, 0xa9, 0x17, 0x9e, 0x0d, 0x51,
+    0x37, 0xb1, 0x5b, 0x69, 0x34, 0xa1, 0x33, 0x53, 0x94, 0xc5, 0x18, 0x18, 0xa5, 0x60, 0xe6,
+    0x20, 0x31, 0xe1, 0xb2, 0x7a, 0x52, 0x34, 0x20, 0x8c, 0x8e, 0xb5, 0x6b, 0x86, 0x5c, 0x1a,
+    0x88, 0x9d, 0xa7, 0x06, 0x8b, 0x05, 0xd9, 0x54, 0xa9, 0x53, 0x4b, 0xc1, 0x15, 0x2c, 0x9d,
+    0x2a, 0xb9, 0x38, 0x35, 0x2f, 0x42, 0xd6, 0xa0, 0xc3, 0x15, 0x2e, 0xee, 0x14, 0xfb, 0x54,
+    0x2c, 0xd9, 0x5a, 0x70, 0x39, 0x41, 0x49, 0x3d, 0x41, 0xa1, 0x8f, 0xf7, 0xcd, 0x30, 0xd3,
+    0xe4, 0xfb, 0xf5, 0x0b, 0x36, 0x2a, 0x24, 0xca, 0x43, 0x81, 0x14, 0x13, 0x51, 0x16, 0xa0,
+    0x36, 0x6a, 0x6e, 0x04, 0x9b, 0xa9, 0xa5, 0xb2, 0x29, 0xb9, 0xa2, 0x8b, 0x80, 0xdd, 0xd4,
+    0xe5, 0x6c, 0x8a, 0x63, 0x0e, 0x69, 0x14, 0xe0, 0xd4, 0xdf, 0x51, 0x92, 0x13, 0x48, 0xac,
+    0x7a, 0xd2, 0x91, 0xde, 0x99, 0xd1, 0xa9, 0xec, 0x02, 0x1e, 0xb5, 0x3d, 0x91, 0xc5, 0xda,
+    0x54, 0x24, 0x64, 0x53, 0xed, 0x4e, 0xdb, 0x94, 0xfa, 0xe2, 0x92, 0xd1, 0x89, 0xec, 0x59,
+    0xd4, 0x17, 0xe6, 0xcd, 0x52, 0x4f, 0xbe, 0x2b, 0x46, 0xfd, 0x72, 0x01, 0xf6, 0xac, 0xe8,
+    0xff, 0x00, 0xd6, 0x0a, 0xa9, 0xfc, 0x40, 0xb6, 0x1d, 0x30, 0xe4, 0x52, 0x05, 0xc9, 0x07,
+    0xd6, 0x9d, 0x37, 0x6a, 0x92, 0x24, 0xdd, 0x10, 0x34, 0xad, 0x79, 0x00, 0x04, 0xf4, 0xeb,
+    0x53, 0x24, 0x79, 0x19, 0x34, 0xa8, 0x06, 0x29, 0xcc, 0x48, 0x1c, 0x56, 0xca, 0x36, 0x25,
+    0xb1, 0x09, 0x0a, 0x30, 0x29, 0x94, 0x13, 0x4c, 0x66, 0xc5, 0x0d, 0x82, 0x43, 0xb3, 0x4d,
+    0x67, 0x02, 0xa3, 0x69, 0x2a, 0x22, 0xd5, 0x0e, 0x7d, 0x8a, 0xb1, 0x23, 0x49, 0xe9, 0x51,
+    0x16, 0xcd, 0x26, 0x73, 0x4e, 0x54, 0x24, 0xf3, 0xd2, 0xb3, 0xbb, 0x63, 0x04, 0x5d, 0xc7,
+    0x27, 0xa5, 0x4d, 0x40, 0x18, 0xa2, 0xa9, 0x2b, 0x08, 0x4a, 0x0f, 0x03, 0x34, 0xb4, 0x53,
+    0x02, 0x28, 0xe5, 0x2b, 0xc1, 0xe4, 0x54, 0xea, 0xea, 0xdd, 0x0d, 0x53, 0xa3, 0xa7, 0x4a,
+    0x85, 0x2b, 0x0e, 0xc5, 0xfc, 0xd2, 0x83, 0x54, 0xd6, 0x76, 0x5f, 0x7a, 0x93, 0xed, 0x3c,
+    0x70, 0xbc, 0xd5, 0xa9, 0xa1, 0x58, 0x9c, 0x11, 0x92, 0x33, 0x4e, 0xcd, 0x67, 0x96, 0x24,
+    0xe7, 0xbd, 0x38, 0x4a, 0xeb, 0xd1, 0x8d, 0x2e, 0x70, 0xb1, 0xa0, 0x0d, 0x2e, 0x6a, 0x88,
+    0xb9, 0x71, 0xd4, 0x03, 0x52, 0xa5, 0xc8, 0x27, 0x91, 0x8a, 0xb5, 0x34, 0x16, 0x2d, 0x52,
+    0xd4, 0x06, 0x74, 0x1f, 0xc4, 0x29, 0xeb, 0x22, 0x91, 0x9c, 0xd5, 0x29, 0x21, 0x04, 0xb1,
+    0x09, 0x57, 0xdf, 0xb1, 0xaa, 0x4a, 0xed, 0x0c, 0x9c, 0x1c, 0x11, 0xd4, 0x55, 0xfd, 0xeb,
+    0xfd, 0xe1, 0xf9, 0xd4, 0x33, 0xc2, 0xb2, 0x65, 0x94, 0x8c, 0xd4, 0xcd, 0x75, 0x40, 0x8b,
+    0x96, 0xf7, 0x8d, 0xb4, 0x30, 0x39, 0x1d, 0xc1, 0xab, 0xc9, 0x74, 0x8e, 0x3a, 0xe0, 0xfa,
+    0x1a, 0xe6, 0x32, 0xc8, 0x71, 0x92, 0x0d, 0x58, 0x86, 0xe4, 0xa8, 0xc3, 0xb1, 0xfa, 0xd5,
+    0x42, 0xbb, 0x5a, 0x31, 0x38, 0xdc, 0xe8, 0xc4, 0xa3, 0x1d, 0x69, 0x8c, 0xd9, 0x6c, 0x83,
+    0x59, 0x29, 0xa8, 0x04, 0xfe, 0x2c, 0x8a, 0x9d, 0x35, 0x18, 0x1f, 0x82, 0xdb, 0x4f, 0xbd,
+    0x6c, 0xaa, 0xc5, 0xf5, 0x17, 0x2d, 0x8b, 0xa7, 0x77, 0x6c, 0x55, 0x79, 0x99, 0xc1, 0x01,
+    0x80, 0x03, 0xda, 0xa3, 0xfb, 0x58, 0xdc, 0x76, 0xc8, 0xac, 0x29, 0x1e, 0x43, 0x21, 0xc9,
+    0x23, 0xf0, 0xa4, 0xe4, 0x9a, 0xd0, 0x65, 0xa8, 0x8a, 0x3a, 0x8f, 0x5f, 0x4a, 0x90, 0xc0,
+    0xa4, 0x55, 0x00, 0x6a, 0x74, 0xba, 0x75, 0xe0, 0xe1, 0x85, 0x35, 0x25, 0xd4, 0x4d, 0x0f,
+    0x6b, 0x5c, 0x72, 0x0d, 0x30, 0xc7, 0x22, 0x72, 0x33, 0xf8, 0x52, 0x49, 0xa8, 0xc5, 0x19,
+    0xc3, 0x86, 0x07, 0xaf, 0x02, 0x92, 0x3d, 0x46, 0x29, 0x17, 0xa1, 0xa2, 0xf0, 0xbd, 0x93,
+    0x0d, 0x49, 0xe3, 0xbd, 0x9e, 0x12, 0x06, 0x49, 0x1e, 0xf5, 0x76, 0x3d, 0x54, 0x11, 0x87,
+    0x5f, 0xca, 0xb2, 0x3c, 0xc0, 0xe7, 0x34, 0x70, 0x39, 0xcd, 0x0a, 0x6d, 0x12, 0xe9, 0xc5,
+    0xee, 0x8d, 0xf8, 0xef, 0xed, 0xe4, 0xfe, 0x2c, 0x1f, 0x7a, 0x9b, 0x2a, 0xc3, 0x2a, 0xc3,
+    0xeb, 0x5c, 0xc8, 0x73, 0xdb, 0xf4, 0xa9, 0x61, 0xbc, 0x96, 0x13, 0xd4, 0xe2, 0xad, 0x55,
+    0x5d, 0x4c, 0xdd, 0x15, 0xd0, 0xda, 0x9b, 0xcd, 0x51, 0x90, 0xfb, 0x7e, 0x9d, 0x2a, 0x8c,
+    0xd7, 0xc6, 0x2f, 0xf5, 0x8f, 0xb7, 0xde, 0xa6, 0x8b, 0x51, 0x42, 0x3e, 0x6e, 0x29, 0x26,
+    0x36, 0x97, 0x51, 0xb0, 0x25, 0x7d, 0x0e, 0x2a, 0xdb, 0xba, 0xd1, 0x8e, 0x2a, 0xdb, 0xa2,
+    0x9f, 0xdb, 0xd5, 0xc8, 0x0b, 0x31, 0x39, 0xf4, 0x26, 0x9c, 0xd3, 0x64, 0xf2, 0xf9, 0x35,
+    0x9d, 0x25, 0xb0, 0xb3, 0x90, 0xb8, 0x05, 0x94, 0xf4, 0x3e, 0x95, 0x08, 0x91, 0x9e, 0x40,
+    0xa1, 0xb1, 0x9e, 0xe4, 0xd7, 0x3b, 0xab, 0x25, 0xa4, 0x8d, 0xac, 0xba, 0x1b, 0x09, 0x22,
+    0x0c, 0x92, 0x79, 0xa9, 0x04, 0xea, 0x3a, 0x11, 0x54, 0x21, 0xb0, 0xb8, 0x9d, 0xc2, 0xa4,
+    0xd1, 0xff, 0x00, 0xdf, 0x55, 0x60, 0xe8, 0x37, 0xff, 0x00, 0xde, 0x43, 0xf4, 0x6a, 0xd1,
+    0x4e, 0x76, 0xd1, 0x12, 0xdc, 0x56, 0xec, 0x27, 0xbd, 0xc7, 0x00, 0x64, 0xd4, 0x42, 0xf0,
+    0x9e, 0xdf, 0xad, 0x49, 0xfd, 0x83, 0x7a, 0x7a, 0xed, 0xff, 0x00, 0xbe, 0xa9, 0x3f, 0xb0,
+    0xae, 0x87, 0x71, 0xf9, 0xd4, 0xb7, 0x55, 0xbd, 0x87, 0xcd, 0x1e, 0xe3, 0xa3, 0xbb, 0x6c,
+    0x80, 0x2b, 0x42, 0x19, 0x9b, 0xab, 0x3f, 0x3f, 0x5a, 0xcf, 0x4d, 0x12, 0xe0, 0xf5, 0x91,
+    0x57, 0x1e, 0xa6, 0xa5, 0x1a, 0x25, 0xc9, 0xff, 0x00, 0x96, 0xe9, 0xf9, 0x9a, 0xd2, 0x12,
+    0xa8, 0xb7, 0x44, 0xc9, 0xc1, 0xf5, 0x34, 0x44, 0xe3, 0xfb, 0xd9, 0xfc, 0x69, 0xc2, 0x40,
+    0xc4, 0x00, 0x79, 0xac, 0xff, 0x00, 0xec, 0x29, 0xff, 0x00, 0xe7, 0xf2, 0x11, 0xf5, 0x63,
+    0x51, 0xbe, 0x93, 0x24, 0x67, 0x26, 0xfa, 0x01, 0xff, 0x00, 0x03, 0xad, 0x3d, 0xa4, 0xff,
+    0x00, 0x94, 0x8e, 0x58, 0xf7, 0x36, 0x9c, 0xc6, 0x90, 0x61, 0xbe, 0xf9, 0xeb, 0xcf, 0x4a,
+    0xa6, 0x56, 0x01, 0xc9, 0x61, 0xf9, 0xd6, 0x25, 0xcc, 0x26, 0x20, 0x4f, 0xda, 0xd1, 0xcf,
+    0xa2, 0xb6, 0x6a, 0xa6, 0xe6, 0xee, 0x4d, 0x67, 0x2c, 0x4d, 0x9d, 0x9a, 0x2e, 0x34, 0xed,
+    0xd4, 0xdb, 0x69, 0x17, 0x3c, 0x1e, 0x29, 0x3c, 0xc1, 0xeb, 0x54, 0x21, 0x2d, 0xb0, 0x02,
+    0x49, 0x35, 0x72, 0x28, 0x4b, 0x90, 0x5c, 0xe1, 0x7f, 0x9d, 0x11, 0x9b, 0x96, 0xc5, 0xda,
+    0xc4, 0xd0, 0x2b, 0xdc, 0xcc, 0x11, 0x41, 0xe6, 0xb6, 0xad, 0xf4, 0xe5, 0x88, 0x86, 0x38,
+    0xdd, 0xea, 0x79, 0xac, 0xf8, 0xa4, 0x48, 0x40, 0xd9, 0xf2, 0x9f, 0x5e, 0xf4, 0xf7, 0xd4,
+    0x8a, 0x8e, 0x5c, 0x93, 0xe8, 0x0d, 0x74, 0x45, 0x28, 0xad, 0x4c, 0x67, 0xcd, 0x2d, 0x11,
+    0xbd, 0x1f, 0x95, 0x08, 0xe4, 0x64, 0xfa, 0x9a, 0x1e, 0xfa, 0x35, 0xe4, 0xb8, 0xae, 0x59,
+    0xef, 0xdd, 0xbf, 0x8b, 0x15, 0x0b, 0x5c, 0x13, 0xd4, 0x93, 0xf5, 0x34, 0x9d, 0x58, 0x82,
+    0xa6, 0xce, 0x8e, 0x5d, 0x5d, 0x07, 0xdd, 0x39, 0xaa, 0x13, 0x6a, 0x2d, 0x21, 0xe7, 0x27,
+    0xeb, 0x59, 0x26, 0x6a, 0x43, 0x35, 0x43, 0xac, 0x52, 0xa4, 0x8b, 0xcd, 0x75, 0x23, 0x77,
+    0xc7, 0xd2, 0xa7, 0x86, 0x0f, 0x30, 0x6e, 0x91, 0x89, 0xf6, 0xcd, 0x64, 0x79, 0xe4, 0x1c,
+    0xe6, 0xad, 0x45, 0x77, 0x9e, 0x41, 0x23, 0xd6, 0x88, 0xd5, 0x4d, 0xea, 0x37, 0x1d, 0x34,
+    0x35, 0xa2, 0x8a, 0x25, 0x6c, 0xe0, 0x54, 0xc4, 0x46, 0x78, 0xc5, 0x65, 0x0b, 0xdc, 0x1e,
+    0x45, 0x3f, 0xed, 0xeb, 0x5a, 0xfb, 0x48, 0x99, 0x3a, 0x72, 0x6c, 0xbe, 0x51, 0x29, 0x8c,
+    0xaa, 0x2a, 0x9f, 0xdb, 0x41, 0xe8, 0x45, 0x21, 0xb9, 0xdd, 0xfc, 0x43, 0xf3, 0xa3, 0x9d,
+    0x02, 0xa7, 0x22, 0xc9, 0x41, 0xd9, 0x8d, 0x30, 0x87, 0x1d, 0x1c, 0x1a, 0x87, 0xce, 0xf7,
+    0xa4, 0x33, 0x0e, 0xa4, 0xd2, 0xe6, 0x45, 0xa8, 0xb2, 0x46, 0x92, 0x44, 0xeb, 0xd2, 0x81,
+    0x72, 0xc0, 0xd4, 0x26, 0x75, 0x23, 0xef, 0x0a, 0x4f, 0x35, 0x07, 0x75, 0xa9, 0x72, 0xf3,
+    0x2f, 0x94, 0xd1, 0x4b, 0xa7, 0x1d, 0x18, 0xfe, 0x75, 0x65, 0x35, 0x09, 0x17, 0xf8, 0x8f,
+    0xe7, 0x58, 0xbf, 0x6a, 0x51, 0xfc, 0x55, 0x04, 0x9a, 0x82, 0xee, 0xc0, 0x73, 0x91, 0x43,
+    0xab, 0x15, 0xd4, 0x8f, 0x65, 0x73, 0xa7, 0x1a, 0x9b, 0xf7, 0x1f, 0xad, 0x2f, 0xf6, 0x93,
+    0x1e, 0x9c, 0x7e, 0x26, 0xb9, 0xc5, 0xbf, 0x6c, 0x67, 0x93, 0x4e, 0x1a, 0x89, 0xf4, 0xa3,
+    0xdb, 0x44, 0x5e, 0xc9, 0x9b, 0x4d, 0x74, 0xc5, 0x89, 0x1f, 0xad, 0x67, 0xcd, 0x6c, 0x24,
+    0x24, 0x90, 0x0e, 0x79, 0xe6, 0xaa, 0x9b, 0xfc, 0xf4, 0x6c, 0x7e, 0x14, 0xb1, 0xde, 0x92,
+    0x7e, 0x63, 0xf8, 0xd0, 0xea, 0x41, 0xe8, 0xc7, 0x1a, 0x6e, 0x3b, 0x0e, 0x6d, 0x11, 0x8a,
+    0x79, 0x91, 0xbe, 0xd2, 0x7b, 0x55, 0x53, 0x35, 0xdd, 0x94, 0x9b, 0x5f, 0x3c, 0x74, 0xcd,
+    0x6a, 0x43, 0x79, 0xb7, 0xa1, 0xe3, 0xf4, 0xa9, 0xd9, 0x20, 0xba, 0x43, 0xd0, 0x93, 0xd8,
+    0xd2, 0x74, 0x96, 0xf0, 0xd1, 0x87, 0x3c, 0x97, 0xc5, 0xb1, 0x4a, 0xdf, 0x5c, 0x46, 0x18,
+    0x90, 0x60, 0xfa, 0x8a, 0xd0, 0xb7, 0xba, 0x4b, 0x86, 0x01, 0x0e, 0x47, 0x7a, 0xcb, 0xb8,
+    0xd1, 0x43, 0xe4, 0xc7, 0x95, 0x3d, 0xb1, 0xc8, 0xac, 0xd4, 0x7b, 0xcd, 0x32, 0x63, 0xd4,
+    0x0e, 0x87, 0xd0, 0xd4, 0x7b, 0x5a, 0x94, 0xdf, 0xbe, 0xb4, 0x17, 0xb3, 0x84, 0x97, 0xba,
+    0x77, 0xb6, 0xff, 0x00, 0x27, 0x39, 0x03, 0xd2, 0xad, 0x79, 0xeb, 0xed, 0x5c, 0x8d, 0xaf,
+    0x89, 0x09, 0x50, 0xb2, 0xc6, 0x09, 0xf5, 0x06, 0xae, 0xff, 0x00, 0x6c, 0xee, 0x19, 0x58,
+    0xf8, 0xf5, 0xcd, 0x6f, 0x1a, 0x91, 0x96, 0xcc, 0x12, 0x94, 0x74, 0xb1, 0xd0, 0xf9, 0xeb,
+    0xeb, 0x41, 0x9d, 0x7d, 0xeb, 0x9f, 0x5d, 0x55, 0x9c, 0xe3, 0x6e, 0x3f, 0x1a, 0x57, 0xd4,
+    0x00, 0x19, 0x63, 0x8f, 0xa9, 0xab, 0xba, 0x13, 0x94, 0xbb, 0x1b, 0x6f, 0x70, 0x08, 0xc7,
+    0x4a, 0xae, 0xd2, 0x0c, 0xfa, 0xd6, 0x0c, 0x9a, 0xcc, 0x09, 0xc6, 0xe2, 0x4f, 0xb5, 0x43,
+    0xfd, 0xb8, 0x8c, 0xd8, 0x5d, 0xe7, 0xf0, 0xa9, 0x75, 0x60, 0xba, 0x8b, 0x96, 0x6f, 0xa1,
+    0xd0, 0xee, 0x07, 0xb5, 0x26, 0xe0, 0x39, 0xe9, 0x5c, 0xf3, 0xea, 0xae, 0x07, 0xdd, 0x97,
+    0x1f, 0x4a, 0x85, 0xb5, 0x69, 0x3b, 0x2c, 0xb4, 0x9d, 0x68, 0x2e, 0xa1, 0xec, 0xa4, 0x74,
+    0x92, 0x48, 0x92, 0xa9, 0x56, 0xc1, 0x1e, 0x86, 0xb2, 0xe4, 0x8a, 0x5b, 0x47, 0x69, 0x2c,
+    0x5f, 0x6f, 0x7d, 0x87, 0xa1, 0xac, 0xef, 0xed, 0x77, 0x07, 0x95, 0x6f, 0xc4, 0x54, 0x91,
+    0xeb, 0x08, 0xc7, 0x12, 0x0c, 0x7b, 0x8a, 0x97, 0x56, 0x9c, 0xba, 0x8d, 0x53, 0x9a, 0x35,
+    0xac, 0xfc, 0x4b, 0x0a, 0x91, 0x0d, 0xf2, 0x35, 0xbc, 0x9e, 0xa7, 0x95, 0x35, 0x62, 0x7d,
+    0x52, 0xc9, 0x7e, 0x66, 0xb9, 0x88, 0x03, 0xd3, 0xe6, 0xcd, 0x62, 0xca, 0xd6, 0x97, 0xaa,
+    0x03, 0x15, 0x6f, 0x4c, 0xf5, 0xac, 0x9b, 0xbd, 0x37, 0xca, 0x3b, 0xa3, 0xe5, 0x7d, 0x2a,
+    0x65, 0x52, 0xa4, 0x55, 0xd6, 0xa8, 0xb5, 0x15, 0x2d, 0x1e, 0x87, 0x55, 0xfd, 0xb5, 0xa7,
+    0xe7, 0x1f, 0x6a, 0x42, 0x7d, 0xb3, 0x47, 0xf6, 0xc5, 0x8e, 0x7f, 0xd7, 0x8f, 0xfb, 0xe4,
+    0xff, 0x00, 0x85, 0x50, 0xf0, 0xfc, 0x3a, 0x3e, 0x71, 0x73, 0x16, 0x64, 0xed, 0xbb, 0x35,
+    0xd4, 0xa6, 0x9f, 0xa3, 0xba, 0xe5, 0x6d, 0xe1, 0xc7, 0xd2, 0xae, 0x32, 0x9c, 0x95, 0xf4,
+    0x0f, 0x66, 0xae, 0x51, 0x87, 0xc4, 0x1a, 0x79, 0x40, 0x1e, 0xe4, 0x02, 0x3d, 0x41, 0xff,
+    0x00, 0x0a, 0x7b, 0x6b, 0x7a, 0x63, 0x8c, 0x0b, 0xc8, 0xbf, 0x3c, 0x55, 0xc3, 0xa4, 0xe9,
+    0x47, 0xfe, 0x58, 0x45, 0xf9, 0xd4, 0x32, 0x68, 0x5a, 0x63, 0x0e, 0x11, 0x07, 0xe3, 0x55,
+    0x79, 0x15, 0xca, 0xed, 0x62, 0x18, 0xf5, 0x3b, 0x37, 0xfb, 0xb7, 0x51, 0x67, 0xd9, 0xc5,
+    0x3a, 0x49, 0xa3, 0x91, 0x0e, 0xd7, 0x56, 0xf7, 0x07, 0x35, 0x52, 0x5d, 0x0b, 0x4d, 0x07,
+    0xe6, 0x8c, 0x01, 0xeb, 0xba, 0xa2, 0xff, 0x00, 0x84, 0x5a, 0xde, 0xe1, 0x19, 0xad, 0xc3,
+    0x80, 0x3b, 0xab, 0x50, 0xdc, 0xd7, 0x63, 0x36, 0x96, 0xc4, 0xbb, 0xc7, 0xad, 0x3d, 0x24,
+    0x04, 0x62, 0xb0, 0xa6, 0xd2, 0x27, 0xb6, 0x62, 0x21, 0xbd, 0x95, 0x58, 0x76, 0x63, 0x55,
+    0x7e, 0xd1, 0xab, 0x5b, 0x36, 0x09, 0x12, 0xa8, 0xef, 0xc5, 0x43, 0xaa, 0xd7, 0xc5, 0x12,
+    0x15, 0x3b, 0xec, 0xce, 0xa0, 0xb8, 0x1c, 0x93, 0x50, 0x49, 0x74, 0xab, 0xc2, 0x9e, 0x6b,
+    0x9b, 0x93, 0x52, 0x9d, 0xf9, 0x74, 0x74, 0xfc, 0x09, 0xa8, 0xfe, 0xd0, 0xd2, 0xff, 0x00,
+    0xcb, 0x52, 0x7f, 0x1a, 0x87, 0x5e, 0x3d, 0x0a, 0xf6, 0x2f, 0xa9, 0xb9, 0x25, 0xd2, 0x03,
+    0xcb, 0x8f, 0xc4, 0xd4, 0x0d, 0x7b, 0x10, 0xfe, 0x31, 0xf8, 0x56, 0x43, 0x1c, 0x75, 0x23,
+    0xf3, 0xa6, 0x82, 0x0f, 0xdd, 0xc9, 0xfa, 0x0a, 0x87, 0x5d, 0x94, 0xa9, 0xa3, 0x57, 0xed,
+    0xb1, 0x67, 0xef, 0x9f, 0xca, 0x9f, 0x1d, 0xd4, 0x44, 0x8c, 0x48, 0x3f, 0x1a, 0xcc, 0x5b,
+    0x79, 0xdf, 0xee, 0xc2, 0xe7, 0xf0, 0xab, 0x09, 0xa5, 0x5e, 0xbe, 0x31, 0x09, 0xa1, 0x54,
+    0x9f, 0x60, 0x71, 0x89, 0xb9, 0x6d, 0x26, 0x58, 0x63, 0xa5, 0x7a, 0x0e, 0x81, 0x7d, 0xe5,
+    0xc2, 0x79, 0xfe, 0x01, 0x5e, 0x65, 0x6d, 0xa4, 0xea, 0x68, 0x38, 0x25, 0x41, 0xed, 0x5a,
+    0x31, 0x41, 0xad, 0x46, 0x9b, 0x52, 0xe9, 0x94, 0x0f, 0x43, 0x56, 0xfd, 0xe5, 0xa8, 0xe9,
+    0x7e, 0xed, 0xdd, 0x1d, 0x77, 0x88, 0xaf, 0x8b, 0xb4, 0x87, 0x3c, 0x0c, 0x0a, 0xe4, 0xe7,
+    0xb8, 0x04, 0x1c, 0x75, 0xa8, 0x6e, 0x2d, 0x35, 0x59, 0x54, 0x89, 0x6e, 0x19, 0xc1, 0xf5,
+    0xe6, 0xb3, 0xa4, 0xd2, 0x2f, 0x0f, 0xf1, 0x67, 0xf1, 0x34, 0x7c, 0x2a, 0xc8, 0x55, 0x3d,
+    0xf7, 0x76, 0x4b, 0x23, 0xee, 0x3d, 0x6a, 0x22, 0xc3, 0x3d, 0x6a, 0x1f, 0xec, 0xdb, 0xf8,
+    0xf3, 0x8d, 0xa7, 0xeb, 0x9a, 0x89, 0xec, 0xaf, 0xf1, 0xf7, 0x94, 0x7d, 0x05, 0x4b, 0x93,
+    0xec, 0x4a, 0x8a, 0x5d, 0x4b, 0x79, 0xa6, 0xb3, 0xaa, 0x29, 0x66, 0x38, 0x15, 0x44, 0x58,
+    0xea, 0x2c, 0xd8, 0x33, 0xed, 0x1e, 0xb8, 0xa7, 0x36, 0x95, 0x33, 0x0f, 0x9e, 0xe9, 0xdb,
+    0xda, 0x97, 0x3c, 0xba, 0x21, 0xda, 0x3d, 0x58, 0xb2, 0xdd, 0xa1, 0xe9, 0x80, 0x3d, 0xea,
+    0xdd, 0xbd, 0xf4, 0x21, 0x01, 0x66, 0x01, 0x7b, 0xfb, 0x55, 0x03, 0xa3, 0x8e, 0x87, 0x9f,
+    0xa9, 0x34, 0x9f, 0xd9, 0x28, 0xa0, 0x8c, 0xf0, 0x7b, 0x64, 0xd4, 0x5e, 0x7d, 0x86, 0xf9,
+    0x1a, 0xdc, 0xdf, 0xfe, 0xd8, 0xd3, 0xc2, 0x85, 0x17, 0x28, 0x3f, 0x1a, 0x53, 0x71, 0x04,
+    0x83, 0xe4, 0x95, 0x4f, 0xd0, 0xd7, 0x30, 0xfa, 0x52, 0x76, 0x38, 0xfa, 0x1a, 0x81, 0xac,
+    0x65, 0x8f, 0x98, 0xa4, 0xfc, 0x33, 0x4b, 0x9e, 0x6b, 0x74, 0x57, 0x2c, 0x5e, 0xcc, 0xe8,
+    0xa6, 0x20, 0x02, 0x54, 0xe6, 0xa8, 0x49, 0x36, 0x73, 0x81, 0x83, 0x58, 0xdf, 0x6b, 0xba,
+    0xb7, 0x6d, 0xa5, 0x88, 0xf6, 0x34, 0xa3, 0x50, 0x72, 0xd9, 0x75, 0x07, 0x3e, 0x95, 0x1e,
+    0xd6, 0x3d, 0x45, 0xec, 0x99, 0x79, 0xe6, 0x39, 0xa8, 0xcc, 0xad, 0x51, 0x7d, 0xaa, 0x37,
+    0x1e, 0x9f, 0x5a, 0x4f, 0x30, 0x76, 0xe9, 0x47, 0x32, 0x2b, 0x94, 0x98, 0x49, 0x9e, 0xb4,
+    0x8c, 0x33, 0xd2, 0xa1, 0xf3, 0x28, 0x13, 0xe3, 0xe9, 0x4a, 0xe8, 0x5c, 0xac, 0x0b, 0x10,
+    0x79, 0xa5, 0x0f, 0x91, 0xd6, 0x91, 0xdd, 0x5c, 0x67, 0x8a, 0xab, 0xe7, 0x6d, 0x38, 0xa9,
+    0x72, 0x48, 0xa4, 0xae, 0x5e, 0x0d, 0xb8, 0x54, 0x6c, 0xdb, 0x4d, 0x57, 0x13, 0x10, 0x72,
+    0x29, 0x5e, 0x4d, 0xcb, 0x9a, 0x39, 0xd0, 0x72, 0xea, 0x4c, 0x25, 0xc1, 0xa4, 0x95, 0xb7,
+    0x2e, 0x45, 0x56, 0xdc, 0x69, 0x43, 0x91, 0xf4, 0xa5, 0xce, 0x3e, 0x51, 0x7c, 0xdc, 0xf0,
+    0x7a, 0xd3, 0x1e, 0x9b, 0x22, 0xf7, 0x14, 0x23, 0x16, 0x5e, 0x6a, 0x2e, 0xf6, 0x65, 0x58,
+    0x68, 0x35, 0x2a, 0x9c, 0xad, 0x46, 0x46, 0x0d, 0x39, 0x3b, 0xd1, 0x1d, 0xc0, 0x24, 0xeb,
+    0x50, 0xb0, 0xcd, 0x4b, 0x27, 0x6a, 0x88, 0x9a, 0x52, 0xdc, 0x08, 0xcd, 0x20, 0x38, 0xa7,
+    0xb0, 0xef, 0x4c, 0xac, 0xc6, 0x3a, 0x94, 0x73, 0x4d, 0x06, 0x9e, 0x0f, 0x39, 0xaa, 0x40,
+    0x35, 0xc6, 0x0d, 0x32, 0xa4, 0x90, 0x82, 0x2a, 0x3a, 0x97, 0xb8, 0x12, 0x8e, 0x45, 0x31,
+    0x85, 0x2a, 0x66, 0x9c, 0x45, 0x56, 0xe8, 0x06, 0x2f, 0x22, 0x88, 0xfe, 0x59, 0xd0, 0xfa,
+    0x30, 0xa7, 0x28, 0xe6, 0x98, 0x46, 0x1f, 0xf1, 0xa4, 0x06, 0xad, 0xd8, 0xf9, 0x14, 0xd6,
+    0x4a, 0x70, 0xe2, 0xb5, 0xee, 0xff, 0x00, 0xd4, 0xad, 0x64, 0x01, 0xfb, 0xc0, 0x3d, 0xea,
+    0xea, 0x6e, 0x89, 0x8e, 0xc3, 0xe6, 0xe8, 0x0d, 0x4f, 0x6f, 0xfe, 0xaa, 0xa1, 0x9b, 0xee,
+    0x8f, 0xad, 0x3e, 0x13, 0x88, 0xe8, 0x8f, 0xc4, 0x37, 0xb1, 0x28, 0x6c, 0x1a, 0x73, 0x38,
+    0xda, 0x6a, 0x07, 0x7c, 0x1e, 0x29, 0xa1, 0xf2, 0x2a, 0xb9, 0x85, 0x61, 0x5a, 0x4f, 0x4a,
+    0x88, 0xb5, 0x23, 0xf0, 0xd4, 0xca, 0xc9, 0xc8, 0xa1, 0x49, 0xa4, 0xa2, 0x9c, 0xa8, 0xcc,
+    0x78, 0x19, 0xa5, 0xb8, 0x0e, 0x8d, 0x33, 0xc9, 0xa9, 0x7a, 0x52, 0x2d, 0xbc, 0x87, 0xab,
+    0x62, 0xa4, 0x16, 0xab, 0xfc, 0x44, 0x9a, 0xd1, 0x45, 0xf6, 0x15, 0xd1, 0x19, 0x65, 0x1d,
+    0xc5, 0x27, 0x98, 0xbd, 0xb2, 0x7f, 0x0a, 0xb2, 0x21, 0x8d, 0x7a, 0x28, 0xa7, 0x60, 0x7a,
+    0x0a, 0xae, 0x56, 0x2e, 0x62, 0xa6, 0xf3, 0xd9, 0x1b, 0xf2, 0xa3, 0x73, 0x7f, 0x71, 0xaa,
+    0xe7, 0x1e, 0x94, 0xd2, 0x48, 0xe8, 0x05, 0x1c, 0x9e, 0x61, 0x72, 0xb0, 0x8d, 0x7d, 0x05,
+    0x2f, 0x94, 0x87, 0xb0, 0xa7, 0x80, 0x29, 0xc0, 0x0f, 0x5a, 0x5c, 0xa8, 0x64, 0x5e, 0x4a,
+    0x7a, 0x52, 0xfd, 0x9d, 0x7d, 0x0d, 0x4c, 0xb8, 0x1d, 0xe9, 0xe0, 0x8f, 0x5a, 0xa5, 0x04,
+    0x2b, 0x95, 0x8d, 0xb2, 0xfa, 0x1a, 0x6f, 0xd9, 0x87, 0xa9, 0xab, 0xc3, 0xeb, 0x4e, 0xfc,
+    0x28, 0xf6, 0x68, 0x2e, 0x67, 0x1b, 0x6f, 0xf6, 0xbf, 0x4a, 0x69, 0xb7, 0x6e, 0xc4, 0x56,
+    0xa7, 0x1e, 0x94, 0xbb, 0x54, 0xf6, 0x14, 0x7b, 0x24, 0x17, 0x32, 0x4c, 0x0e, 0x3b, 0x03,
+    0x4d, 0x29, 0x22, 0xff, 0x00, 0x09, 0x15, 0xb1, 0xe5, 0xc6, 0x7a, 0xa8, 0xa3, 0xc8, 0x8c,
+    0xfa, 0x8a, 0x3d, 0x8f, 0x60, 0xe6, 0x31, 0xc4, 0x84, 0x75, 0xa7, 0xf9, 0xa3, 0xde, 0xb4,
+    0xda, 0xce, 0x36, 0xef, 0xf9, 0x8a, 0x89, 0xb4, 0xc0, 0x7e, 0xe9, 0x02, 0x93, 0xa5, 0x35,
+    0xb0, 0x5d, 0x19, 0x84, 0xe4, 0xe6, 0x92, 0xae, 0xbe, 0x9b, 0x2a, 0xfd, 0xdc, 0x1a, 0x81,
+    0xad, 0x66, 0x4e, 0xb1, 0x9a, 0xc9, 0xc2, 0x4b, 0x74, 0x3b, 0xa2, 0x1a, 0x31, 0x4a, 0x51,
+    0x87, 0x55, 0x22, 0x8f, 0xc6, 0xa4, 0x61, 0x8a, 0x72, 0x96, 0x5e, 0x8c, 0x47, 0xd2, 0x9b,
+    0xf8, 0xd2, 0xd3, 0x02, 0x78, 0xe6, 0x97, 0x70, 0x1b, 0xf2, 0x3d, 0xea, 0xc1, 0x99, 0xb1,
+    0xc1, 0x19, 0xaa, 0x4a, 0xfb, 0x5b, 0x35, 0x61, 0x67, 0x8c, 0xf5, 0x50, 0x0f, 0xbd, 0x69,
+    0x19, 0x79, 0x89, 0x91, 0xc8, 0x8f, 0x23, 0x6e, 0x27, 0x26, 0x99, 0xe5, 0xba, 0x9c, 0x81,
+    0x56, 0xbc, 0xe8, 0xc7, 0xf7, 0x69, 0xa6, 0x64, 0x3d, 0xd7, 0xf2, 0xa1, 0xa4, 0x04, 0x22,
+    0x69, 0x17, 0x8c, 0x9f, 0xc6, 0x9d, 0xf6, 0xa7, 0x3d, 0x69, 0xae, 0x15, 0xce, 0x77, 0x8a,
+    0x4d, 0x83, 0xfb, 0xc2, 0xa6, 0xec, 0x07, 0x8b, 0xa7, 0x14, 0xbf, 0x6a, 0x73, 0xeb, 0x4e,
+    0x86, 0x0f, 0x31, 0xb6, 0x86, 0x51, 0xee, 0x6a, 0xe4, 0x7a, 0x53, 0xc9, 0xd2, 0x58, 0xcf,
+    0xd0, 0xd5, 0x25, 0x27, 0xb0, 0x9b, 0x48, 0xcf, 0xfb, 0x44, 0x98, 0xc0, 0x24, 0x53, 0x63,
+    0x95, 0xe3, 0x6c, 0xab, 0x15, 0x3e, 0xd5, 0xb4, 0x9a, 0x18, 0x3f, 0x7a, 0x5f, 0xc8, 0x54,
+    0xbf, 0xd8, 0x90, 0xe3, 0x1b, 0x9f, 0x3f, 0x85, 0x57, 0xb3, 0x99, 0x3e, 0xd2, 0x26, 0x4f,
+    0xdb, 0xe4, 0x29, 0xb5, 0xc0, 0x60, 0x7d, 0x45, 0x57, 0x2c, 0xa4, 0xf0, 0xb8, 0xad, 0xef,
+    0xec, 0x38, 0x7f, 0xe7, 0xa1, 0x1f, 0x85, 0x1f, 0xd8, 0x70, 0x7f, 0xcf, 0x5a, 0x6e, 0x9d,
+    0x47, 0xb8, 0x7b, 0x48, 0x98, 0x4b, 0x29, 0x52, 0x08, 0x24, 0x11, 0x52, 0x8b, 0xc9, 0xfb,
+    0x4a, 0xd5, 0xb4, 0x34, 0x5b, 0x55, 0xeb, 0x38, 0x14, 0x1d, 0x26, 0xcc, 0x7f, 0xcb, 0xc8,
+    0xfd, 0x28, 0xf6, 0x53, 0x0f, 0x69, 0x13, 0x1c, 0x5e, 0x5c, 0xf6, 0x95, 0xff, 0x00, 0x3a,
+    0x77, 0xdb, 0x2f, 0x3f, 0xe7, 0xb3, 0xfe, 0x75, 0xa8, 0xda, 0x75, 0xa2, 0x0c, 0x8b, 0x90,
+    0x7f, 0x2a, 0x69, 0xd3, 0xe0, 0x62, 0x36, 0xdc, 0x28, 0xcf, 0xb0, 0xa7, 0xec, 0xe7, 0xdc,
+    0x39, 0x91, 0x9b, 0xf6, 0xbb, 0xcf, 0xf9, 0xec, 0xff, 0x00, 0x9d, 0x1f, 0x6f, 0xbc, 0x1c,
+    0x19, 0xe4, 0xfc, 0xeb, 0x4f, 0xfb, 0x20, 0x1e, 0x93, 0xaf, 0xe9, 0x4c, 0x6d, 0x15, 0xcf,
+    0xdd, 0x9a, 0x33, 0xf5, 0x34, 0x7b, 0x3a, 0x81, 0xcd, 0x13, 0x38, 0xdd, 0xdc, 0xf5, 0x32,
+    0x37, 0xe7, 0x4d, 0x6b, 0x99, 0x1f, 0xef, 0x1c, 0xfd, 0x6b, 0x40, 0xe8, 0xce, 0x07, 0x33,
+    0x45, 0xf9, 0xd3, 0x46, 0x9a, 0xab, 0xf7, 0xa6, 0x4c, 0xd1, 0xec, 0xea, 0x0f, 0x9a, 0x25,
+    0x15, 0x96, 0xa4, 0xf3, 0x94, 0xd2, 0xc9, 0x02, 0x82, 0x42, 0x3a, 0x1f, 0x7c, 0xe2, 0x9a,
+    0x2d, 0x0b, 0x0c, 0xf9, 0x91, 0xe7, 0xd3, 0x75, 0x4d, 0xa4, 0x3b, 0xa2, 0xed, 0xbc, 0xb1,
+    0x85, 0xe4, 0x8c, 0xfb, 0xd4, 0xed, 0x74, 0x8b, 0xde, 0xb3, 0x0d, 0xac, 0xa3, 0xa3, 0x21,
+    0xfa, 0x38, 0xa6, 0x98, 0x65, 0x1d, 0x87, 0xfd, 0xf4, 0x2b, 0x55, 0x52, 0x51, 0x56, 0xb0,
+    0x68, 0x5e, 0x7b, 0xb6, 0x7e, 0x01, 0xc0, 0xa8, 0xfc, 0xdc, 0xd5, 0x4c, 0x32, 0x9f, 0x98,
+    0x75, 0xf4, 0x34, 0xf0, 0xdb, 0x7a, 0x66, 0xa1, 0xd4, 0x6f, 0x71, 0x97, 0x00, 0x63, 0xd7,
+    0x03, 0xeb, 0x52, 0xa0, 0x40, 0x39, 0xe4, 0xd6, 0x7f, 0x9c, 0x47, 0xf1, 0x1f, 0xce, 0x8f,
+    0xb4, 0xb0, 0xe9, 0x9a, 0xa5, 0x51, 0x21, 0x1a, 0x27, 0x61, 0x1d, 0x2a, 0xbb, 0xe0, 0x74,
+    0x35, 0x54, 0xdc, 0xbe, 0x29, 0x85, 0xd9, 0xba, 0x9a, 0x52, 0xa8, 0x98, 0xec, 0x58, 0x32,
+    0x52, 0xac, 0xe5, 0x4e, 0x41, 0xaa, 0xb9, 0x34, 0xe0, 0xae, 0xdd, 0x15, 0x8f, 0xd0, 0x54,
+    0x73, 0x30, 0x2d, 0x7d, 0xad, 0xbd, 0xa9, 0x7e, 0xd7, 0xea, 0x3f, 0x5a, 0x81, 0x6d, 0xe7,
+    0x6e, 0x91, 0x3f, 0xfd, 0xf3, 0x52, 0x2d, 0x8d, 0xc9, 0xff, 0x00, 0x96, 0x44, 0x7d, 0x6a,
+    0x93, 0x9b, 0x0d, 0x07, 0xfd, 0xac, 0x7a, 0x1a, 0x3e, 0xd4, 0x3f, 0xba, 0x68, 0x1a, 0x6d,
+    0xd9, 0xff, 0x00, 0x96, 0x7f, 0xad, 0x2f, 0xf6, 0x65, 0xd7, 0xf7, 0x07, 0xe7, 0x4f, 0xf7,
+    0x9d, 0x85, 0x74, 0x1f, 0x6a, 0x5f, 0x43, 0x4e, 0x17, 0x29, 0xef, 0x49, 0xfd, 0x99, 0x73,
+    0xfd, 0xd1, 0xf9, 0xd1, 0xfd, 0x9b, 0x73, 0xfd, 0xc1, 0xf9, 0xd1, 0xfb, 0xce, 0xc1, 0x74,
+    0x3b, 0xed, 0x11, 0x9e, 0xf5, 0x0c, 0x93, 0xb3, 0x37, 0xca, 0x48, 0x14, 0xe3, 0x61, 0x70,
+    0x3f, 0x86, 0x93, 0xec, 0x73, 0x0e, 0xa0, 0x52, 0x7c, 0xef, 0xa0, 0xf4, 0x23, 0xf3, 0x5f,
+    0xfb, 0xc6, 0x9b, 0x9c, 0x1c, 0xe6, 0xa4, 0x36, 0xd2, 0xfa, 0x7e, 0xb4, 0xd3, 0x04, 0x83,
+    0xf8, 0x4d, 0x67, 0x69, 0x0c, 0x95, 0x67, 0x7f, 0xef, 0x53, 0xbe, 0xd0, 0xde, 0xdf, 0x95,
+    0x57, 0x2a, 0xcb, 0xd4, 0x11, 0x52, 0x22, 0xe4, 0x65, 0xaa, 0x94, 0x98, 0x89, 0x3e, 0xd0,
+    0xde, 0x82, 0x91, 0x67, 0x60, 0xd9, 0x03, 0x23, 0xd2, 0x81, 0xe5, 0x0e, 0xec, 0x69, 0xea,
+    0xf1, 0x0e, 0xb5, 0x57, 0x7d, 0xc0, 0xb3, 0x0c, 0x8c, 0xdf, 0x73, 0x20, 0xfa, 0x56, 0x8c,
+    0x01, 0xc1, 0x05, 0xb8, 0xfa, 0x56, 0x62, 0xdc, 0x22, 0xf2, 0x8b, 0x53, 0x8d, 0x49, 0x80,
+    0xff, 0x00, 0x56, 0x09, 0xf7, 0x35, 0xd1, 0x4e, 0xa4, 0x63, 0xbb, 0x22, 0x49, 0xb3, 0x65,
+    0x26, 0x55, 0x1d, 0x5a, 0x99, 0x20, 0x8a, 0xe1, 0x19, 0x58, 0x70, 0x6b, 0x1c, 0xea, 0x73,
+    0x11, 0xc2, 0xa0, 0xa8, 0x9a, 0xee, 0xe1, 0x8e, 0x77, 0xe3, 0xe8, 0x2b, 0x47, 0x89, 0x81,
+    0x9a, 0xa5, 0xd4, 0x6d, 0xf5, 0x93, 0x5b, 0x3e, 0xe4, 0x39, 0x5f, 0x6a, 0x8a, 0xde, 0xf0,
+    0xc4, 0x70, 0xd9, 0x22, 0x94, 0x96, 0x73, 0x97, 0x25, 0x8f, 0xb9, 0xa6, 0x34, 0x4a, 0x7a,
+    0x29, 0x15, 0xc6, 0xe5, 0x69, 0x5e, 0x1a, 0x1b, 0x2d, 0xb5, 0x26, 0x93, 0x50, 0x6c, 0xfe,
+    0xef, 0x8f, 0x7a, 0xb7, 0x63, 0x6e, 0x97, 0x0e, 0xaf, 0x73, 0x31, 0x20, 0x8c, 0xe3, 0x38,
+    0x15, 0x9c, 0x22, 0x03, 0xb5, 0x49, 0x1b, 0xc9, 0x19, 0xf9, 0x4f, 0xe9, 0x55, 0x19, 0xb6,
+    0xef, 0x20, 0x7e, 0x46, 0xef, 0xd9, 0xec, 0x23, 0x71, 0xb6, 0x1d, 0xde, 0xbc, 0x13, 0xfc,
+    0xea, 0xe2, 0xcd, 0x6d, 0x10, 0x01, 0x63, 0x55, 0x1f, 0x40, 0x2b, 0x9e, 0x5b, 0xeb, 0x95,
+    0x1f, 0xc2, 0x7e, 0xb4, 0x8f, 0x7d, 0x74, 0xea, 0x57, 0x6a, 0xf3, 0xde, 0xba, 0x63, 0x5e,
+    0x0b, 0x64, 0x66, 0xe0, 0xd9, 0xd2, 0x0b, 0xa8, 0x49, 0xc1, 0x55, 0x23, 0xea, 0x29, 0xde,
+    0x75, 0xbf, 0xfc, 0xf3, 0x5a, 0xe4, 0x9a, 0x5b, 0xaf, 0x50, 0x3f, 0x1a, 0x84, 0xdc, 0xdc,
+    0x03, 0x83, 0x21, 0xa1, 0xe2, 0xd2, 0xe8, 0x2f, 0x65, 0xe6, 0x76, 0x2d, 0x25, 0xb1, 0xea,
+    0x83, 0xf3, 0xaa, 0x17, 0x3f, 0x60, 0xcf, 0x11, 0x28, 0x61, 0xed, 0x9a, 0xe7, 0x44, 0xd7,
+    0x2f, 0xc0, 0x77, 0x3f, 0x4a, 0x96, 0x3b, 0x0b, 0xd9, 0xcf, 0x11, 0xbf, 0xd4, 0xd4, 0xbc,
+    0x4b, 0x96, 0xd1, 0xb8, 0xd5, 0x3b, 0x6e, 0xc2, 0xf5, 0x42, 0x49, 0xbe, 0x33, 0xb4, 0x13,
+    0xc0, 0x14, 0xd4, 0xbf, 0x95, 0x53, 0x6b, 0x7c, 0xc2, 0xaf, 0x47, 0xe1, 0xdb, 0xb7, 0xc1,
+    0x62, 0xa2, 0xad, 0xc7, 0xe1, 0xac, 0x7f, 0xad, 0x94, 0x7e, 0x75, 0x9a, 0xa5, 0x55, 0xbb,
+    0xa5, 0x62, 0xf9, 0xa2, 0x60, 0xad, 0xcb, 0xac, 0x85, 0xc7, 0x04, 0x9c, 0xf1, 0x56, 0x97,
+    0x59, 0xbb, 0x5e, 0x16, 0x46, 0x1f, 0x8d, 0x6f, 0x26, 0x89, 0x63, 0x19, 0xcb, 0x38, 0xfc,
+    0xaa, 0xc2, 0x69, 0xb6, 0x0b, 0xef, 0x57, 0x1a, 0x15, 0x17, 0xda, 0xb0, 0x9c, 0xe2, 0x60,
+    0x2e, 0xb3, 0xa8, 0x9f, 0xf9, 0x6f, 0x27, 0xe7, 0x52, 0x7f, 0x6b, 0xea, 0x5f, 0xf3, 0xd9,
+    0xeb, 0xa3, 0x5b, 0x2b, 0x3e, 0xc9, 0x52, 0x7d, 0x8e, 0xdb, 0xfb, 0x82, 0xb4, 0xf6, 0x55,
+    0x3f, 0x9c, 0x57, 0x5d, 0x8e, 0x4e, 0x5d, 0x5b, 0x50, 0x6e, 0xae, 0xc7, 0xf0, 0xab, 0xfa,
+    0x67, 0x8b, 0x2f, 0x2c, 0x54, 0xa3, 0xa0, 0x70, 0x7d, 0xab, 0x5a, 0x4b, 0x2b, 0x62, 0x7e,
+    0xe0, 0xaa, 0xef, 0xa6, 0x5b, 0x37, 0xf0, 0xd2, 0x74, 0x6a, 0x7f, 0x30, 0xb9, 0xa3, 0xd8,
+    0xc7, 0xba, 0xf1, 0x04, 0xf3, 0xce, 0xd2, 0x79, 0x43, 0x04, 0xd3, 0xa3, 0xd4, 0xb7, 0xa0,
+    0xdd, 0x19, 0x1f, 0x8d, 0x4f, 0x77, 0xa4, 0xdb, 0xc6, 0x9b, 0x83, 0x95, 0x3d, 0xbd, 0xeb,
+    0x34, 0xdb, 0x20, 0xff, 0x00, 0x96, 0x98, 0xa8, 0xfd, 0xec, 0x1e, 0xac, 0xa4, 0xa2, 0xf6,
+    0x2e, 0x3d, 0xdc, 0x7b, 0x49, 0xda, 0x6a, 0x08, 0xe3, 0x37, 0xb2, 0x15, 0x45, 0x55, 0xc7,
+    0x7c, 0x54, 0x5e, 0x50, 0x03, 0x1e, 0x68, 0x34, 0xf8, 0x8c, 0xb0, 0x9d, 0xd1, 0xba, 0xd2,
+    0x72, 0x72, 0x7e, 0xf6, 0xc3, 0xb5, 0x96, 0x86, 0xcd, 0x97, 0x87, 0x21, 0x27, 0x74, 0xee,
+    0x58, 0x75, 0xc5, 0x6e, 0xc1, 0xa5, 0x59, 0x42, 0xa3, 0x6c, 0x42, 0xb9, 0x2f, 0xed, 0x5b,
+    0xd4, 0x00, 0x10, 0x08, 0xf6, 0x38, 0xa7, 0xff, 0x00, 0x6d, 0xce, 0xa3, 0x0c, 0x92, 0x63,
+    0xd8, 0xd6, 0xb1, 0x9d, 0x38, 0xed, 0xa1, 0x16, 0x97, 0x5d, 0x4e, 0xd1, 0x56, 0x08, 0xfe,
+    0xea, 0x28, 0xfc, 0x29, 0xde, 0x72, 0x0e, 0xe2, 0xb8, 0xe8, 0x35, 0xf8, 0xd5, 0x86, 0xf0,
+    0xfe, 0xf9, 0xad, 0x04, 0xf1, 0x05, 0xa3, 0x60, 0x6e, 0xfd, 0x2a, 0xbd, 0xa4, 0x5f, 0x51,
+    0xa6, 0xd7, 0x43, 0x7f, 0xed, 0x2a, 0x3b, 0x9a, 0x63, 0x5e, 0x01, 0xd9, 0x8d, 0x65, 0xc7,
+    0xaa, 0xdb, 0xcc, 0xdb, 0x55, 0xb9, 0xf7, 0x15, 0x3f, 0x9e, 0x8f, 0xde, 0x9d, 0xd3, 0x13,
+    0x91, 0x2c, 0x9a, 0x89, 0x1f, 0x75, 0x0f, 0xe3, 0x55, 0x64, 0xd5, 0x24, 0x1f, 0xc0, 0x2a,
+    0x42, 0xca, 0x6a, 0x26, 0x8a, 0x36, 0xce, 0x47, 0xeb, 0x48, 0x97, 0xcd, 0xdc, 0xae, 0xfa,
+    0x9c, 0x8d, 0xfc, 0x2a, 0x2a, 0x23, 0x7c, 0xff, 0x00, 0xdd, 0x5a, 0xb0, 0xd6, 0xd1, 0xe2,
+    0xa9, 0xc8, 0x61, 0x52, 0x46, 0x29, 0x36, 0x43, 0x4f, 0xa8, 0xf5, 0x96, 0x49, 0x8e, 0x42,
+    0x0c, 0x7b, 0x53, 0x8a, 0xb8, 0x19, 0x20, 0x0a, 0xa2, 0xda, 0x81, 0x87, 0x21, 0x10, 0xe2,
+    0xab, 0xc9, 0x7f, 0x34, 0xaa, 0x43, 0x10, 0x01, 0xf4, 0xa8, 0x72, 0x43, 0x50, 0x6c, 0xb3,
+    0x25, 0xe8, 0x46, 0x20, 0x81, 0xc7, 0x7c, 0xd4, 0x0f, 0x7e, 0x0f, 0xdd, 0x5c, 0xd4, 0x30,
+    0xc9, 0x6c, 0x83, 0x32, 0x0c, 0xb7, 0xd3, 0x35, 0xa1, 0x14, 0xb0, 0x18, 0xc3, 0x26, 0xd0,
+    0x2a, 0x79, 0x9b, 0x2b, 0x95, 0x2e, 0x86, 0x69, 0x6b, 0x89, 0x0e, 0x55, 0x1f, 0x06, 0x93,
+    0xc8, 0xb9, 0x3d, 0x46, 0x3e, 0xb5, 0xa6, 0xd7, 0x08, 0x3f, 0x89, 0x71, 0x55, 0xe4, 0xbc,
+    0x88, 0x0f, 0xf5, 0x8b, 0xf9, 0xd4, 0xbf, 0x36, 0x3e, 0x67, 0xd1, 0x19, 0xf2, 0xd8, 0xbb,
+    0x72, 0xe4, 0x55, 0x57, 0xb3, 0xe3, 0x83, 0x57, 0xa6, 0xbe, 0x87, 0x18, 0x0c, 0x49, 0xfa,
+    0x55, 0x37, 0xbb, 0x1f, 0xc2, 0xbf, 0x9d, 0x67, 0x2e, 0x42, 0xe2, 0xe4, 0x57, 0x6b, 0x77,
+    0x1e, 0x86, 0xa2, 0x2a, 0xca, 0x70, 0x41, 0x15, 0x3b, 0x4e, 0xe7, 0xd0, 0x54, 0x65, 0x8b,
+    0x75, 0x35, 0x8b, 0x4b, 0xa1, 0x63, 0x01, 0x22, 0x8d, 0xe7, 0x34, 0x63, 0xd2, 0x8d, 0xa7,
+    0xd0, 0xd4, 0xea, 0x31, 0xe9, 0x20, 0x1d, 0xf8, 0xa8, 0xe4, 0x20, 0xbe, 0x45, 0x26, 0x28,
+    0xa1, 0xb7, 0x6b, 0x00, 0x2b, 0x63, 0x83, 0xd2, 0xa4, 0xa8, 0xa8, 0x04, 0x8a, 0x13, 0x02,
+    0x4e, 0x94, 0xd2, 0xd8, 0xfa, 0x52, 0x16, 0x26, 0x9a, 0xc7, 0x34, 0x5c, 0x07, 0x99, 0x7e,
+    0x5c, 0x62, 0x98, 0x8d, 0xb4, 0xd2, 0x52, 0x52, 0xbb, 0x02, 0x66, 0x3c, 0x66, 0x84, 0x3d,
+    0x6a, 0x3d, 0xff, 0x00, 0x2e, 0x28, 0x0d, 0x8a, 0xab, 0x88, 0x7b, 0x9e, 0x2a, 0x1a, 0x71,
+    0x6c, 0xd3, 0x69, 0x36, 0x31, 0x48, 0xc8, 0xa6, 0x1a, 0x70, 0x26, 0x8d, 0xa6, 0x96, 0xe0,
+    0x32, 0xa4, 0x03, 0x22, 0x80, 0x94, 0xe1, 0x91, 0x4d, 0x20, 0x18, 0x56, 0x93, 0x6d, 0x49,
+    0xb4, 0x93, 0x4e, 0x11, 0xd3, 0xb0, 0x86, 0xa8, 0xa5, 0x2b, 0x4f, 0x03, 0x14, 0x87, 0x9a,
+    0xab, 0x00, 0x81, 0x6a, 0x17, 0x1f, 0x39, 0xfa, 0xd4, 0xf9, 0xc5, 0x57, 0x73, 0xfb, 0xc3,
+    0x53, 0x2d, 0x81, 0x1a, 0x97, 0x67, 0x11, 0xa0, 0xf7, 0xac, 0xb5, 0xff, 0x00, 0x5f, 0xf8,
+    0xd5, 0xdd, 0x44, 0x90, 0x23, 0xc1, 0xf5, 0xaa, 0x31, 0xff, 0x00, 0xac, 0x14, 0x4d, 0xeb,
+    0x61, 0x47, 0x61, 0xf3, 0xf6, 0xa6, 0xc6, 0xd8, 0x18, 0xa7, 0x4f, 0xd5, 0x6a, 0x30, 0xa4,
+    0xd2, 0x7b, 0x94, 0x0e, 0x72, 0xd4, 0x81, 0x88, 0x3c, 0x53, 0xc4, 0x63, 0xbd, 0x38, 0x28,
+    0x1d, 0x05, 0x2b, 0x30, 0x23, 0xda, 0xce, 0x7a, 0x54, 0xa2, 0x00, 0x3a, 0x92, 0x69, 0x45,
+    0x19, 0x3d, 0xcd, 0x52, 0x4b, 0xa8, 0x87, 0x04, 0x45, 0xec, 0x29, 0xc1, 0xd5, 0x7a, 0x54,
+    0x46, 0x92, 0xab, 0x9a, 0xdb, 0x01, 0x37, 0x9f, 0xed, 0x49, 0xe7, 0x9f, 0x41, 0x50, 0xd1,
+    0x9a, 0x5c, 0xec, 0x56, 0x44, 0xde, 0x73, 0x52, 0x79, 0xc6, 0xa2, 0xe6, 0xa4, 0x8c, 0x29,
+    0xeb, 0xd6, 0x9a, 0x93, 0x63, 0xb0, 0xf5, 0x7d, 0xd4, 0xfc, 0x1a, 0x40, 0x00, 0xa7, 0x55,
+    0xa1, 0x15, 0xc3, 0x0f, 0x5a, 0x5c, 0x8f, 0x5a, 0xae, 0x1f, 0x03, 0xa5, 0x38, 0x4a, 0x3d,
+    0x0d, 0x65, 0xcc, 0x3b, 0x13, 0xe4, 0x52, 0xe4, 0x7a, 0xd4, 0x1e, 0x68, 0xf4, 0x34, 0xe0,
+    0xf9, 0xfe, 0x13, 0xf9, 0x53, 0x52, 0x02, 0x70, 0xde, 0x86, 0x9c, 0x24, 0x61, 0xde, 0xab,
+    0xef, 0xff, 0x00, 0x65, 0xbf, 0x2a, 0x3c, 0xc0, 0x3b, 0x1f, 0xca, 0x9a, 0x90, 0x16, 0xc4,
+    0xa7, 0xda, 0x9c, 0x26, 0x1d, 0xc5, 0x53, 0x12, 0xaf, 0xf7, 0xa9, 0xc2, 0x40, 0x7a, 0x30,
+    0xaa, 0x53, 0x15, 0x8b, 0xa2, 0x44, 0x3d, 0xe9, 0xdb, 0xd7, 0xb3, 0x0a, 0xa3, 0xbc, 0x8a,
+    0x5d, 0xe6, 0xab, 0xda, 0x05, 0x8b, 0xe1, 0xfd, 0x0d, 0x38, 0x39, 0xac, 0xf0, 0xfe, 0xd4,
+    0xe1, 0x31, 0x1d, 0xcd, 0x35, 0x50, 0x56, 0x34, 0x04, 0x9e, 0xd4, 0xed, 0xe3, 0x1c, 0xd6,
+    0x7f, 0x9c, 0x5b, 0xab, 0x53, 0xbc, 0xe6, 0xc6, 0x37, 0x55, 0x2a, 0x81, 0x62, 0xe6, 0xc8,
+    0xa4, 0xfe, 0x15, 0x3f, 0x4a, 0x63, 0x58, 0xc0, 0xfd, 0xb1, 0x55, 0x03, 0x73, 0x52, 0x2d,
+    0xc3, 0xaf, 0x72, 0x45, 0x1c, 0xd1, 0x7b, 0xa0, 0xb0, 0x92, 0x69, 0x43, 0xf8, 0x4d, 0x54,
+    0x93, 0x4f, 0x96, 0x3e, 0x40, 0xc8, 0xad, 0x01, 0x78, 0xc0, 0xfd, 0xd1, 0x8a, 0x95, 0x6e,
+    0xd1, 0xb8, 0x6e, 0x3e, 0xb5, 0x2e, 0x9d, 0x36, 0x17, 0x66, 0x13, 0x46, 0xcb, 0xd5, 0x48,
+    0xa6, 0xd7, 0x40, 0x63, 0x86, 0x5e, 0x78, 0x3e, 0xe2, 0xab, 0x4b, 0xa7, 0x29, 0xe5, 0x71,
+    0x59, 0xca, 0x83, 0xe8, 0x3e, 0x63, 0x22, 0x8a, 0xb5, 0x2d, 0x94, 0x91, 0xf6, 0x35, 0x59,
+    0x94, 0xa9, 0xe4, 0x56, 0x2e, 0x2d, 0x6e, 0x50, 0x94, 0x51, 0x4b, 0x9f, 0x6a, 0x40, 0x3d,
+    0x58, 0x0e, 0xb9, 0xab, 0x10, 0xdd, 0x2c, 0x4d, 0xbb, 0x04, 0x9f, 0xad, 0x55, 0x5e, 0x4d,
+    0x48, 0x23, 0xcf, 0xfc, 0xb4, 0x15, 0x49, 0xbe, 0x82, 0x65, 0xc3, 0xa9, 0xe3, 0xa2, 0x7e,
+    0xb4, 0xdf, 0xed, 0x36, 0xec, 0xbf, 0xad, 0x40, 0x20, 0x1d, 0xe4, 0x1f, 0x9d, 0x3b, 0xec,
+    0xc8, 0x7f, 0xe5, 0xa0, 0xab, 0xe6, 0x99, 0x36, 0x89, 0x3a, 0xea, 0x39, 0x1f, 0x32, 0x31,
+    0xff, 0x00, 0x81, 0x52, 0x1b, 0xc0, 0xdd, 0x22, 0x3f, 0x99, 0xa6, 0x08, 0x13, 0x1f, 0xeb,
+    0x45, 0x3c, 0x5b, 0xa6, 0x3f, 0xd6, 0xf3, 0x55, 0xef, 0x86, 0x83, 0x5a, 0x74, 0xef, 0x07,
+    0xea, 0x69, 0x86, 0x64, 0x3f, 0xf2, 0xc7, 0x15, 0x37, 0xd9, 0x81, 0xfe, 0x3a, 0x43, 0x6c,
+    0x07, 0xf1, 0xd2, 0xb4, 0x82, 0xe8, 0xaa, 0x5f, 0x27, 0x85, 0x22, 0x80, 0xc7, 0xd1, 0xa9,
+    0xed, 0x6a, 0x41, 0xe1, 0xc5, 0x30, 0xc4, 0xc3, 0xf8, 0xc7, 0xe7, 0x51, 0xa9, 0x5a, 0x0e,
+    0xf3, 0x71, 0xd4, 0x1f, 0xce, 0x9a, 0xd2, 0x92, 0x7e, 0x52, 0x47, 0xe3, 0x51, 0x9e, 0x0f,
+    0x27, 0x34, 0xb4, 0xb9, 0x98, 0x58, 0x94, 0x39, 0x6e, 0xae, 0xdf, 0x9d, 0x49, 0xe5, 0x12,
+    0x01, 0x2c, 0xc0, 0x7b, 0xd5, 0x70, 0xc4, 0x74, 0xa9, 0x7e, 0xd5, 0x29, 0x8f, 0x66, 0x46,
+    0x3e, 0x94, 0xd3, 0x5d, 0x40, 0x78, 0x81, 0x4f, 0x59, 0x45, 0x06, 0x28, 0xc7, 0xfc, 0xb6,
+    0x5a, 0x85, 0x52, 0x59, 0x0e, 0x15, 0x59, 0xbe, 0x82, 0xac, 0xc7, 0xa6, 0xdc, 0x39, 0xe4,
+    0x05, 0x1e, 0xe6, 0xa9, 0x26, 0xf6, 0x40, 0xf4, 0xea, 0x57, 0x6c, 0x03, 0xc3, 0x67, 0xe9,
+    0x48, 0x18, 0xfa, 0x9a, 0xd4, 0x8f, 0x49, 0x8d, 0x46, 0x65, 0x90, 0x9f, 0xa7, 0x15, 0x61,
+    0x2d, 0x2d, 0x23, 0xe8, 0x81, 0xbf, 0x5a, 0xd1, 0x61, 0xe6, 0xf7, 0xd0, 0x9e, 0x74, 0x62,
+    0x28, 0x66, 0x3f, 0x2a, 0x93, 0xf4, 0xa9, 0xd2, 0xd6, 0xe6, 0x4e, 0x91, 0x37, 0xe3, 0x5b,
+    0x6a, 0x51, 0x47, 0xc9, 0x18, 0xa7, 0xef, 0x6f, 0x61, 0x5a, 0xac, 0x32, 0xea, 0xc4, 0xe6,
+    0x64, 0xa6, 0x93, 0x70, 0xdd, 0x76, 0xaf, 0xe3, 0x56, 0x53, 0x46, 0xfe, 0xfc, 0xbf, 0x90,
+    0xab, 0xbe, 0x61, 0x1d, 0x5f, 0x14, 0xc3, 0x32, 0x0e, 0xaf, 0x9a, 0xb5, 0x46, 0x9a, 0x27,
+    0x9a, 0x4c, 0x62, 0xe9, 0x36, 0xcb, 0xf7, 0x9d, 0x8f, 0xd4, 0xd4, 0xcb, 0x63, 0x66, 0x9f,
+    0xf2, 0xcc, 0x1f, 0xaf, 0x35, 0x19, 0xb9, 0x8c, 0x1a, 0x69, 0xbd, 0x41, 0xdf, 0xf5, 0xaa,
+    0xb5, 0x35, 0xd1, 0x0a, 0xd3, 0x65, 0xc5, 0x8a, 0x05, 0xfb, 0xb1, 0x28, 0xfc, 0x05, 0x48,
+    0x19, 0x07, 0x61, 0x59, 0xc2, 0xf5, 0x59, 0xb0, 0x31, 0x4f, 0xf3, 0xfe, 0xb5, 0x6a, 0x71,
+    0xe8, 0x2e, 0x47, 0xd4, 0xbf, 0xe6, 0x28, 0xec, 0x3f, 0x2a, 0x3c, 0xd1, 0xe9, 0xfa, 0x55,
+    0x40, 0xe0, 0x8e, 0x58, 0xd3, 0x81, 0x07, 0xa1, 0xfd, 0x69, 0xf3, 0x0b, 0x90, 0xb5, 0xe6,
+    0xfd, 0x68, 0x33, 0xa8, 0xeb, 0xfc, 0xea, 0xb7, 0xe2, 0x28, 0xc0, 0xfe, 0xf0, 0xa3, 0x99,
+    0x87, 0x2a, 0x2c, 0x7d, 0xa5, 0x3d, 0xbf, 0x3a, 0x4f, 0xb5, 0x2f, 0x6a, 0xae, 0x78, 0x1f,
+    0x7a, 0xa2, 0x6d, 0xc4, 0xf0, 0xf8, 0xfc, 0x29, 0x39, 0xd8, 0xa5, 0x04, 0x5a, 0x6b, 0x82,
+    0x47, 0x0a, 0x2a, 0x12, 0xce, 0xc7, 0xaa, 0xd4, 0x38, 0x7c, 0x7f, 0xac, 0xfd, 0x28, 0x5d,
+    0xe4, 0xe3, 0x76, 0x6a, 0x5c, 0xee, 0x5a, 0x49, 0x6c, 0x49, 0xe5, 0xb1, 0xee, 0x29, 0x7c,
+    0xaf, 0x5c, 0x1a, 0x55, 0x8d, 0xf1, 0xf7, 0xa9, 0xde, 0x5b, 0x77, 0x6a, 0x2c, 0x17, 0x10,
+    0x5a, 0xc4, 0xe3, 0x9a, 0x63, 0x69, 0xd1, 0x9f, 0xba, 0xe4, 0x54, 0x82, 0x36, 0x1d, 0x1a,
+    0x9c, 0x03, 0x8e, 0xe2, 0x8e, 0x48, 0xbd, 0xd1, 0x37, 0x7d, 0x19, 0x4d, 0xf4, 0xb6, 0x27,
+    0xe5, 0x71, 0x50, 0x49, 0xa7, 0xcf, 0x1e, 0x08, 0x1b, 0xbe, 0x95, 0xab, 0x96, 0x14, 0x09,
+    0x08, 0x3d, 0x2a, 0x1d, 0x18, 0x31, 0xf3, 0x48, 0xca, 0x1e, 0x6a, 0x8c, 0x34, 0x07, 0xeb,
+    0x83, 0x4e, 0x17, 0x0e, 0xa7, 0xee, 0x01, 0xf5, 0x5a, 0xd5, 0x13, 0x2f, 0x75, 0xa0, 0x98,
+    0x9b, 0xa8, 0xfc, 0xc5, 0x2f, 0x63, 0xd9, 0x8b, 0x9b, 0xba, 0x33, 0x45, 0xdf, 0x1c, 0xac,
+    0x7f, 0xf7, 0xc8, 0xa7, 0x0b, 0xc3, 0xd8, 0x20, 0xff, 0x00, 0x80, 0xd5, 0xd6, 0xb5, 0x82,
+    0x4e, 0xcb, 0xf8, 0x54, 0x2f, 0xa6, 0xa9, 0xfb, 0xa4, 0x8a, 0x4e, 0x9d, 0x45, 0xb3, 0x1f,
+    0x34, 0x59, 0x0f, 0xda, 0x5c, 0xf7, 0x41, 0xf8, 0x0a, 0x5f, 0xb4, 0x4a, 0x3a, 0x49, 0x17,
+    0xe4, 0x2a, 0x29, 0x2c, 0x25, 0x5e, 0x84, 0x9f, 0xa5, 0x56, 0x78, 0xa4, 0x8f, 0xa8, 0x35,
+    0x9b, 0x73, 0x5b, 0x94, 0x92, 0x65, 0xa3, 0x79, 0x39, 0xe8, 0xc0, 0xfd, 0x14, 0x53, 0x1e,
+    0xe2, 0x5e, 0x8c, 0xdf, 0xa0, 0xaa, 0x9b, 0x9b, 0xdf, 0xf0, 0xa9, 0xe2, 0x58, 0xc8, 0xcc,
+    0x8c, 0x7e, 0x95, 0x29, 0xc9, 0xf5, 0x1d, 0x90, 0xbe, 0x6b, 0x31, 0xc0, 0xe4, 0xfb, 0x2d,
+    0x4f, 0x1d, 0xa5, 0xcc, 0xdf, 0x75, 0x0d, 0x69, 0x69, 0xd0, 0x42, 0x57, 0xcc, 0xc2, 0x91,
+    0xdb, 0x15, 0xa7, 0xe6, 0x24, 0x63, 0x03, 0x02, 0xba, 0x21, 0x41, 0x3d, 0x64, 0xc9, 0x72,
+    0xec, 0x63, 0x45, 0xa1, 0xcd, 0x21, 0x05, 0xd8, 0x01, 0x57, 0xe0, 0xd1, 0x2d, 0x62, 0xe6,
+    0x42, 0x1c, 0xfb, 0xd4, 0x92, 0x6a, 0x10, 0xa7, 0xde, 0x95, 0x47, 0xe3, 0x55, 0x5f, 0x5a,
+    0xb5, 0x4e, 0x8c, 0x5b, 0xe8, 0x2b, 0x45, 0x1a, 0x50, 0x15, 0xdb, 0x35, 0x12, 0x1b, 0x68,
+    0x87, 0xc9, 0x18, 0xfc, 0xa9, 0xc6, 0x6c, 0x0c, 0x22, 0x56, 0x0b, 0xf8, 0x81, 0x07, 0xdd,
+    0x89, 0x8f, 0xd4, 0xe2, 0xa2, 0x3a, 0xfc, 0x8d, 0xc2, 0xc2, 0x33, 0xf5, 0xcd, 0x3f, 0x6f,
+    0x05, 0xd4, 0x5c, 0xac, 0xdd, 0x79, 0xe4, 0x03, 0x24, 0xe0, 0x54, 0x0d, 0x3f, 0xab, 0x1f,
+    0xce, 0xb1, 0xcd, 0xfd, 0xf4, 0xfc, 0x6d, 0x08, 0x3e, 0x94, 0xa4, 0x48, 0xdf, 0x7e, 0x4c,
+    0xfe, 0x34, 0x7b, 0x5b, 0xec, 0x84, 0xe1, 0xdd, 0x96, 0xa7, 0x9d, 0x43, 0x82, 0x18, 0x12,
+    0x28, 0x3a, 0x84, 0x87, 0xee, 0xe0, 0x7e, 0x15, 0x4c, 0x84, 0x4e, 0xa4, 0x51, 0xe6, 0xaf,
+    0x6c, 0x54, 0xba, 0x8c, 0xa5, 0x14, 0x5d, 0x5b, 0xfb, 0x8f, 0xef, 0x7e, 0x95, 0x20, 0xba,
+    0xb9, 0x71, 0xf7, 0xc8, 0xfc, 0x6b, 0x3b, 0xce, 0x03, 0xff, 0x00, 0xd5, 0x47, 0xda, 0x48,
+    0xe9, 0x47, 0xb4, 0xee, 0xc2, 0xc6, 0xaa, 0xcf, 0x26, 0x3e, 0x77, 0x39, 0xf6, 0x34, 0xf1,
+    0x73, 0x8e, 0xac, 0x7f, 0x3a, 0xc7, 0xfb, 0x53, 0x7a, 0xd2, 0x7d, 0xad, 0xbf, 0xbc, 0x29,
+    0xfb, 0x64, 0x4f, 0x21, 0xb0, 0xf2, 0x47, 0x2e, 0x37, 0x64, 0xfd, 0x6a, 0xbb, 0xd9, 0x41,
+    0x2b, 0x64, 0x36, 0x3e, 0x95, 0x9e, 0x6f, 0x88, 0xfe, 0x35, 0xa4, 0xfe, 0xd1, 0x70, 0x7e,
+    0x52, 0xa6, 0x93, 0xab, 0x07, 0xb8, 0xd4, 0x1a, 0xd8, 0xba, 0xda, 0x5c, 0x67, 0xa3, 0xd3,
+    0x1f, 0x4a, 0xc0, 0xf9, 0x64, 0xaa, 0xe3, 0x54, 0x90, 0x75, 0x51, 0x4f, 0x1a, 0xaf, 0xaa,
+    0xd4, 0xf3, 0x53, 0x61, 0x69, 0x88, 0xd6, 0x32, 0xa0, 0xf9, 0x5c, 0xd5, 0x59, 0x04, 0xd1,
+    0x7d, 0xf5, 0x38, 0xf5, 0xc5, 0x5e, 0x1a, 0xa4, 0x7d, 0xd4, 0x8a, 0x77, 0xdb, 0xe0, 0x71,
+    0x86, 0xe7, 0xea, 0x2a, 0x5a, 0x83, 0xd9, 0x8d, 0x39, 0x2d, 0xd1, 0x94, 0x5c, 0x3f, 0xde,
+    0x50, 0x6a, 0x26, 0x41, 0xd5, 0x78, 0xad, 0x46, 0xfb, 0x2c, 0x99, 0xf9, 0x40, 0xfa, 0x55,
+    0x67, 0x89, 0x33, 0x85, 0xe9, 0x59, 0xca, 0x0c, 0xb5, 0x2b, 0x94, 0xd5, 0xa5, 0x43, 0x95,
+    0x62, 0x3e, 0x86, 0xaf, 0x41, 0xab, 0xdc, 0x44, 0x81, 0x5b, 0xe6, 0xc7, 0x73, 0x50, 0x98,
+    0x31, 0xd2, 0x90, 0x45, 0x8a, 0x95, 0xcd, 0x1d, 0x81, 0xa4, 0xcb, 0xeb, 0xad, 0x4b, 0xe8,
+    0xbf, 0x8d, 0x29, 0xd6, 0x2e, 0x1b, 0xa6, 0xd1, 0xf4, 0x15, 0x9c, 0xd1, 0x29, 0xf6, 0xfa,
+    0x54, 0x2d, 0x1b, 0x29, 0xe0, 0xd1, 0xed, 0x26, 0x2e, 0x54, 0x69, 0x9d, 0x52, 0xe8, 0xf5,
+    0x70, 0x7f, 0x0a, 0xae, 0xd7, 0x12, 0x33, 0x12, 0x58, 0xf3, 0x54, 0x09, 0x61, 0xd4, 0x9a,
+    0x4d, 0xcd, 0xea, 0x6a, 0x5d, 0x46, 0x3e, 0x54, 0x5b, 0x6b, 0x8c, 0xf0, 0x5f, 0x34, 0xcf,
+    0x39, 0x3f, 0xbd, 0x55, 0xf1, 0x40, 0x5c, 0xd4, 0xf3, 0x31, 0xd8, 0xb0, 0x67, 0x4c, 0x71,
+    0xcd, 0x44, 0x66, 0x6e, 0xc3, 0x14, 0xab, 0x0b, 0x1e, 0xd5, 0x2a, 0xc0, 0x3f, 0x88, 0xd3,
+    0xb4, 0x98, 0x68, 0x41, 0xb9, 0x9b, 0xae, 0x69, 0x42, 0x3b, 0x74, 0x53, 0x56, 0xc2, 0x2a,
+    0xf4, 0x02, 0x80, 0xc1, 0x4f, 0x35, 0x5c, 0x9d, 0xc2, 0xe5, 0x7f, 0xb3, 0x3f, 0x7c, 0x0a,
+    0x72, 0xc0, 0xa3, 0xef, 0x1c, 0xd5, 0x86, 0x99, 0x71, 0x50, 0x34, 0x99, 0x3c, 0x53, 0xb4,
+    0x50, 0x93, 0x6c, 0x5f, 0x2d, 0x3f, 0xba, 0x29, 0x36, 0x2f, 0xf7, 0x45, 0x34, 0xb9, 0xf5,
+    0xa6, 0x96, 0xf7, 0xa5, 0x74, 0x04, 0x98, 0x03, 0xa0, 0x14, 0x87, 0x15, 0x19, 0x70, 0x3b,
+    0xd3, 0x4c, 0x82, 0x87, 0x24, 0x3b, 0x0e, 0x20, 0x1e, 0xc2, 0x9b, 0xb0, 0x7a, 0x0a, 0x6f,
+    0x9b, 0xed, 0x49, 0xe6, 0x31, 0xe8, 0xb5, 0x17, 0x40, 0x3b, 0x60, 0xf4, 0xa6, 0x94, 0x5e,
+    0xe0, 0x53, 0x80, 0x90, 0xf6, 0x02, 0x8f, 0x2b, 0x3d, 0x5b, 0xf2, 0xa2, 0xd7, 0x02, 0x16,
+    0x0a, 0x29, 0x98, 0x27, 0xa0, 0xab, 0x62, 0x34, 0x1d, 0xa9, 0x78, 0x14, 0x72, 0x05, 0xca,
+    0xa2, 0x27, 0x3d, 0xa9, 0x7c, 0x86, 0x3d, 0x48, 0xab, 0x05, 0x85, 0x26, 0x73, 0x47, 0x2a,
+    0x0b, 0x91, 0x79, 0x03, 0xd4, 0xd0, 0x21, 0x5f, 0x7a, 0x97, 0x34, 0x66, 0x9f, 0x2a, 0x01,
+    0x9e, 0x4a, 0xff, 0x00, 0x76, 0x97, 0xc9, 0x5f, 0x41, 0x4b, 0x93, 0x47, 0x34, 0xec, 0x84,
+    0x21, 0x8d, 0x7d, 0x05, 0x1e, 0x58, 0xf4, 0xa7, 0x01, 0xeb, 0x47, 0x4e, 0x82, 0x9d, 0x90,
+    0x08, 0x22, 0x1e, 0x94, 0xbe, 0x52, 0xfa, 0x51, 0xcf, 0xbd, 0x19, 0xc7, 0x5a, 0x2c, 0x85,
+    0xa8, 0x6c, 0x5f, 0x4a, 0x36, 0x8a, 0x69, 0x6a, 0x69, 0x71, 0x46, 0x81, 0x61, 0xe5, 0x45,
+    0x30, 0xaa, 0xd2, 0x17, 0xa6, 0x16, 0xa9, 0x6d, 0x0c, 0x52, 0x07, 0x6a, 0xac, 0xdf, 0xeb,
+    0x3f, 0x1a, 0x9d, 0x9f, 0x02, 0xab, 0x93, 0xce, 0x6b, 0x39, 0x31, 0xa2, 0xe6, 0xa0, 0xc1,
+    0xbc, 0xbc, 0x7b, 0xd5, 0x48, 0xf8, 0x90, 0x52, 0xbc, 0x86, 0x42, 0x33, 0xd8, 0x62, 0x99,
+    0x9c, 0x1c, 0xd2, 0x6e, 0xee, 0xe0, 0x96, 0x84, 0x93, 0x1e, 0x45, 0x35, 0x55, 0xb1, 0x90,
+    0x0e, 0x29, 0x19, 0xb7, 0x1a, 0x9e, 0x19, 0x51, 0x63, 0xc1, 0x38, 0x34, 0xd5, 0x9b, 0x19,
+    0x17, 0xce, 0x3b, 0x1a, 0x37, 0x30, 0xed, 0x56, 0x84, 0x88, 0x7f, 0x88, 0x7e, 0x74, 0xbf,
+    0x29, 0xec, 0x2a, 0xb9, 0x7c, 0xc5, 0x72, 0xa6, 0xf3, 0xdd, 0x69, 0x7c, 0xc1, 0xe9, 0x53,
+    0x94, 0x5f, 0x4a, 0x8d, 0x90, 0x0a, 0x4e, 0x2d, 0x00, 0xcd, 0xe0, 0xf7, 0xa2, 0x94, 0xc6,
+    0x3d, 0x29, 0xa6, 0x3f, 0x42, 0x69, 0x00, 0xb4, 0x53, 0x70, 0xc2, 0x93, 0xe6, 0x1d, 0x45,
+    0x03, 0x1f, 0x9a, 0x4c, 0xe3, 0xa5, 0x37, 0x75, 0x28, 0xc5, 0x00, 0x3c, 0x4a, 0xd4, 0xef,
+    0x39, 0xbd, 0x05, 0x47, 0x45, 0x3b, 0xb1, 0x0b, 0xb1, 0x71, 0xd2, 0x8d, 0x8b, 0xe9, 0x4e,
+    0xcd, 0x14, 0x59, 0x00, 0xd1, 0x1a, 0xe7, 0x38, 0xa9, 0x29, 0x28, 0xa6, 0x80, 0x5e, 0x29,
+    0xd8, 0x14, 0xdc, 0xd2, 0xe6, 0x98, 0x0b, 0x81, 0xe9, 0x4d, 0x28, 0xbe, 0x82, 0x97, 0x26,
+    0x9a, 0x5f, 0x1d, 0x41, 0xa5, 0xa0, 0x06, 0xc1, 0xdb, 0x8a, 0x31, 0xee, 0x69, 0xbe, 0x62,
+    0x9e, 0xf4, 0xa1, 0xc7, 0xad, 0x2d, 0x00, 0x5e, 0x7d, 0x68, 0xa3, 0x70, 0xf5, 0xa3, 0x22,
+    0x80, 0x16, 0x97, 0x34, 0xdc, 0xd1, 0x9a, 0x60, 0x3b, 0x7e, 0x3a, 0x9a, 0x51, 0x20, 0x3e,
+    0x95, 0x59, 0xce, 0x58, 0xd3, 0x69, 0x73, 0x85, 0x8b, 0xa1, 0xa9, 0x72, 0x6a, 0x98, 0x76,
+    0x1d, 0xe9, 0xeb, 0x3f, 0xad, 0x35, 0x34, 0x16, 0x2c, 0x86, 0x60, 0x72, 0x0d, 0x4a, 0xb7,
+    0x32, 0xaf, 0xf1, 0x67, 0xeb, 0x55, 0xd5, 0xc3, 0x74, 0x39, 0xa7, 0x66, 0xad, 0x49, 0xf4,
+    0x11, 0x71, 0x6f, 0x33, 0xc3, 0xa7, 0xe5, 0x51, 0x4a, 0x90, 0x4d, 0x92, 0x38, 0xcd, 0x57,
+    0xc9, 0xa2, 0x9b, 0x9b, 0x7b, 0x85, 0x88, 0x25, 0x84, 0xa9, 0x3b, 0x79, 0xa8, 0x6a, 0xed,
+    0x44, 0xf1, 0x06, 0xe7, 0xa1, 0xac, 0xa5, 0x0e, 0xc3, 0xb9, 0x5e, 0x97, 0x34, 0xad, 0x1b,
+    0x0e, 0xd9, 0xa6, 0xd6, 0x63, 0x17, 0x75, 0x3b, 0xb7, 0xff, 0x00, 0x5e, 0x99, 0x4b, 0x40,
+    0x13, 0xac, 0x0e, 0xca, 0x0e, 0xec, 0x03, 0x4a, 0x6d, 0xcf, 0xf7, 0xaa, 0x10, 0xec, 0x06,
+    0x03, 0x1c, 0x52, 0x6e, 0x6f, 0x53, 0xf9, 0xd5, 0x5d, 0x0b, 0x51, 0xcd, 0xb9, 0x1b, 0x1b,
+    0x8f, 0xe7, 0x4d, 0xdc, 0xc7, 0xf8, 0x8f, 0xe7, 0x49, 0x4a, 0x01, 0x27, 0x81, 0x9a, 0x43,
+    0x0c, 0xd1, 0x52, 0xa4, 0x0c, 0xdc, 0xb7, 0x15, 0x6a, 0x3b, 0x62, 0x7a, 0x2f, 0xe3, 0x54,
+    0xa0, 0xd8, 0xae, 0x52, 0x11, 0xb1, 0xed, 0xf9, 0xd4, 0xab, 0x6e, 0xcd, 0xde, 0xb4, 0x16,
+    0xd5, 0x57, 0xef, 0x1a, 0x79, 0x68, 0x63, 0x1d, 0x85, 0x6a, 0xa8, 0xf7, 0x17, 0x31, 0x4d,
+    0x2c, 0x73, 0xf7, 0x8d, 0x5b, 0x8a, 0xd2, 0x24, 0xe4, 0xa6, 0x4f, 0xbd, 0x31, 0xaf, 0xa2,
+    0x41, 0xc7, 0x3f, 0x4a, 0x81, 0xb5, 0x07, 0x3f, 0x75, 0x40, 0xfa, 0xd5, 0xaf, 0x67, 0x11,
+    0x6a, 0xcd, 0x45, 0x60, 0xa3, 0x00, 0x00, 0x28, 0x69, 0x40, 0x1f, 0x33, 0x80, 0x3e, 0xb5,
+    0x8a, 0x6e, 0x27, 0x90, 0xfd, 0xe3, 0xf8, 0x50, 0x21, 0x66, 0x39, 0x76, 0xc7, 0xeb, 0x55,
+    0xed, 0x9f, 0x44, 0x2e, 0x43, 0x4d, 0xaf, 0x6d, 0xd7, 0xf8, 0xf7, 0x1f, 0x61, 0x9a, 0x88,
+    0xea, 0x4b, 0xfc, 0x11, 0x93, 0xf5, 0x38, 0xaa, 0xab, 0x04, 0x63, 0xae, 0x4f, 0xd6, 0xa5,
+    0x51, 0x1a, 0xff, 0x00, 0x08, 0xa5, 0xcf, 0x37, 0xe4, 0x3e, 0x54, 0x3f, 0xed, 0xd3, 0xb7,
+    0xdd, 0x40, 0x3f, 0x5a, 0x5d, 0xf7, 0x4f, 0xea, 0x3f, 0x4a, 0x3c, 0xf5, 0x51, 0xc0, 0x02,
+    0x9a, 0x6e, 0xfd, 0x28, 0xbf, 0x79, 0x0e, 0xc3, 0xbc, 0x99, 0x9b, 0xab, 0xe3, 0xf1, 0xa7,
+    0x8b, 0x6f, 0xef, 0x4a, 0x4f, 0xd2, 0xab, 0x9b, 0xa6, 0x3d, 0x0d, 0x30, 0xce, 0xed, 0xfc,
+    0x54, 0xaf, 0x10, 0xd4, 0xbc, 0x2d, 0xa2, 0x1d, 0x49, 0x3f, 0x8d, 0x2f, 0x97, 0x02, 0xf6,
+    0x5f, 0xc4, 0xd6, 0x7e, 0xe6, 0x3d, 0x49, 0xa2, 0x8e, 0x75, 0xd1, 0x05, 0x8d, 0x00, 0xd6,
+    0xeb, 0xfd, 0xcf, 0xca, 0x97, 0xed, 0x11, 0x0e, 0xff, 0x00, 0x90, 0xac, 0xea, 0x70, 0xeb,
+    0x4d, 0x4d, 0x85, 0x8d, 0x01, 0x72, 0x9d, 0x97, 0x3f, 0x5a, 0x51, 0x38, 0xec, 0x00, 0xaa,
+    0x4a, 0x2a, 0x65, 0x5a, 0x7c, 0xec, 0x76, 0x45, 0x83, 0x31, 0x3d, 0xea, 0x36, 0x90, 0x9e,
+    0xe7, 0xf3, 0xa4, 0x0b, 0x41, 0x51, 0x4b, 0x99, 0xb1, 0xd8, 0x66, 0x4e, 0x7e, 0xf1, 0xfc,
+    0xe9, 0x77, 0x9f, 0x53, 0x41, 0x02, 0x9b, 0x9c, 0x50, 0x22, 0x4d, 0xdc, 0x70, 0x4d, 0x38,
+    0x48, 0xc3, 0x90, 0x6a, 0x2c, 0xd2, 0x86, 0xa0, 0x0b, 0x4b, 0x76, 0xea, 0x30, 0x79, 0xa7,
+    0xfd, 0xb7, 0x1d, 0x56, 0xa9, 0xee, 0xa4, 0x26, 0xab, 0x9d, 0xf7, 0x17, 0x2a, 0x2e, 0xfd,
+    0xbd, 0x47, 0xf0, 0x9a, 0x5f, 0xed, 0x04, 0xee, 0xa6, 0xb3, 0xc9, 0x14, 0xc3, 0xc8, 0xa3,
+    0xda, 0x48, 0x5c, 0xa8, 0xd5, 0x17, 0xd0, 0x9e, 0xa4, 0x8f, 0xc2, 0x9e, 0x2e, 0x61, 0x6e,
+    0x8c, 0x2b, 0x14, 0x1c, 0x74, 0xa5, 0xdf, 0x4b, 0xdb, 0x48, 0x39, 0x51, 0xb1, 0xe6, 0xc4,
+    0x4e, 0x37, 0x0c, 0xfd, 0x69, 0xac, 0xcb, 0x9f, 0x95, 0xeb, 0x28, 0x3d, 0x2f, 0x99, 0x4f,
+    0xda, 0xdc, 0x39, 0x4b, 0xed, 0x2b, 0x28, 0xea, 0x0d, 0x22, 0xdd, 0x48, 0xbd, 0x09, 0xfc,
+    0xea, 0x97, 0x99, 0xef, 0x4e, 0x0d, 0x4b, 0x9d, 0x8e, 0xc8, 0xd1, 0x5b, 0xf3, 0xfc, 0x43,
+    0x35, 0x20, 0xba, 0x85, 0xfa, 0x80, 0x2b, 0x2f, 0x75, 0x1b, 0xaa, 0x95, 0x46, 0x2e, 0x44,
+    0x69, 0xb4, 0x56, 0xf2, 0x74, 0xc7, 0xe1, 0x55, 0xe5, 0xb2, 0x52, 0x3e, 0x56, 0xe2, 0xa0,
+    0x85, 0x94, 0x67, 0x71, 0xc5, 0x4a, 0xd2, 0xed, 0x19, 0x57, 0x1f, 0x4c, 0xd3, 0xbc, 0x5a,
+    0xd5, 0x0a, 0xcd, 0x75, 0x21, 0x31, 0x4d, 0x16, 0x42, 0x3b, 0x0f, 0x60, 0x6a, 0x07, 0x32,
+    0x93, 0xf3, 0x33, 0x1f, 0xa9, 0xab, 0x62, 0xe8, 0x1f, 0xbc, 0x29, 0x4b, 0xc5, 0x20, 0xa8,
+    0x71, 0x4f, 0x66, 0x51, 0x9f, 0xf5, 0xa2, 0xac, 0xbc, 0x7c, 0xf1, 0xc8, 0xa8, 0x99, 0x05,
+    0x64, 0xe3, 0x61, 0x91, 0xd4, 0x90, 0xcb, 0xe5, 0x3e, 0xed, 0xb9, 0xa6, 0x10, 0x69, 0x29,
+    0x6d, 0xa8, 0x16, 0x5a, 0xf6, 0x43, 0xf7, 0x40, 0x5a, 0x8c, 0xdc, 0xca, 0x7a, 0xb9, 0xfc,
+    0xea, 0x2a, 0x28, 0x72, 0x93, 0xea, 0x16, 0x1c, 0x5d, 0x89, 0xc9, 0x34, 0x79, 0x8c, 0x3a,
+    0x1a, 0x6d, 0x38, 0x28, 0xef, 0x42, 0xb8, 0x06, 0xf6, 0x3f, 0xc4, 0x69, 0x32, 0x7d, 0x4d,
+    0x3f, 0x00, 0x76, 0xa3, 0x8f, 0x4a, 0x76, 0x02, 0x3a, 0x29, 0xff, 0x00, 0x85, 0x23, 0x0a,
+    0x4d, 0x00, 0xca, 0x50, 0x48, 0xe8, 0x68, 0xa5, 0x00, 0x54, 0xd8, 0x62, 0x86, 0x6a, 0x7a,
+    0x7c, 0xc7, 0x9a, 0x66, 0x05, 0x38, 0x60, 0x53, 0x42, 0x26, 0xda, 0xb4, 0x6d, 0x5f, 0x4a,
+    0x8b, 0x78, 0xf5, 0xa3, 0xcc, 0x1e, 0xb5, 0x7c, 0xc8, 0x09, 0xc6, 0x07, 0x4a, 0x5c, 0xfb,
+    0xd4, 0x1e, 0x60, 0xf5, 0x14, 0x79, 0xa3, 0xd4, 0x51, 0xcc, 0x82, 0xc5, 0x8d, 0xc7, 0xd6,
+    0x9c, 0x1a, 0xab, 0x79, 0x8b, 0xeb, 0x52, 0xa3, 0xae, 0x79, 0xaa, 0x52, 0x11, 0x21, 0xc1,
+    0xed, 0x51, 0xb2, 0x83, 0xd2, 0xa6, 0x69, 0x63, 0x2b, 0x80, 0x39, 0xa8, 0x19, 0x86, 0x3a,
+    0xd0, 0xda, 0x02, 0x26, 0x4f, 0x51, 0x9a, 0x85, 0x90, 0xaf, 0x4e, 0x95, 0x63, 0x77, 0xbd,
+    0x34, 0xe0, 0x8a, 0xcd, 0xa1, 0x91, 0x21, 0x5e, 0xf5, 0x32, 0x15, 0x07, 0x8a, 0x85, 0x93,
+    0xd2, 0x98, 0x46, 0x29, 0x27, 0x60, 0x2e, 0xee, 0xa6, 0x99, 0x00, 0xaa, 0xa1, 0xc8, 0xa3,
+    0x79, 0xf4, 0xa7, 0xce, 0x16, 0x2c, 0x19, 0x7d, 0xa9, 0x85, 0xf3, 0xd6, 0xa1, 0xdc, 0x68,
+    0xc9, 0xf5, 0xa4, 0xe7, 0x70, 0xb1, 0x29, 0x61, 0x4c, 0x2e, 0x29, 0x94, 0xa1, 0x09, 0xe8,
+    0x2a, 0x6e, 0xc6, 0x2e, 0xfa, 0x6e, 0xe3, 0x52, 0x08, 0x87, 0x73, 0x9a, 0x78, 0x0a, 0xbd,
+    0x00, 0xa7, 0x66, 0x22, 0x0d, 0x8e, 0xdd, 0xa9, 0xe2, 0x0f, 0x53, 0x52, 0xd2, 0x55, 0x72,
+    0xa0, 0x1a, 0x23, 0x51, 0xda, 0x9d, 0xc5, 0x14, 0x55, 0x68, 0x01, 0x9a, 0x4e, 0x68, 0xe2,
+    0x97, 0x34, 0x08, 0x69, 0x04, 0xf7, 0xa4, 0xf2, 0xfd, 0x4d, 0x3b, 0x34, 0xb4, 0x59, 0x30,
+    0x19, 0xb7, 0x1d, 0xa8, 0xc1, 0xf4, 0xa7, 0xf1, 0x4b, 0x90, 0x28, 0xb0, 0x0c, 0x08, 0x4d,
+    0x38, 0x47, 0xea, 0x69, 0x77, 0x53, 0x4b, 0xd3, 0xb2, 0x16, 0xa3, 0xb6, 0x28, 0xed, 0x46,
+    0x07, 0xa5, 0x30, 0xc9, 0x4d, 0x32, 0x51, 0x74, 0x16, 0x63, 0xc9, 0x14, 0x9b, 0xaa, 0x13,
+    0x25, 0x34, 0xc8, 0x6a, 0x79, 0x90, 0xec, 0x4c, 0x5e, 0xa3, 0x67, 0xc8, 0xa8, 0x8b, 0x13,
+    0x46, 0x0b, 0x77, 0xc5, 0x4b, 0x95, 0xc7, 0x60, 0x2f, 0x4c, 0x2f, 0x4f, 0xf2, 0x87, 0x72,
+    0x69, 0x7c, 0xa5, 0xa9, 0xb3, 0x02, 0x22, 0xe6, 0x9b, 0x93, 0x56, 0x04, 0x4a, 0x29, 0x76,
+    0x28, 0xed, 0x47, 0x2b, 0x0b, 0x95, 0x4e, 0x71, 0x4d, 0xa9, 0xe4, 0x60, 0x7e, 0x51, 0x50,
+    0x9e, 0xb5, 0x2d, 0x0c, 0x55, 0x19, 0xcd, 0x36, 0x9c, 0x09, 0x00, 0xd3, 0x69, 0x00, 0x94,
+    0x62, 0x94, 0xd2, 0xa9, 0xe2, 0x80, 0x1b, 0x8a, 0x70, 0x0c, 0x3a, 0x52, 0xf1, 0xeb, 0x4b,
+    0x9a, 0x69, 0x00, 0x79, 0x8e, 0x3b, 0xd1, 0xe7, 0x37, 0x71, 0x41, 0x39, 0xed, 0x4c, 0x2a,
+    0x3d, 0x68, 0xd4, 0x09, 0x04, 0xa3, 0xd2, 0x94, 0x3a, 0x9e, 0xf5, 0x0e, 0x3d, 0xe8, 0xc5,
+    0x17, 0x60, 0x4d, 0xc5, 0x06, 0xa1, 0xe4, 0x77, 0xa5, 0xdc, 0xc2, 0x8b, 0x80, 0xf2, 0x38,
+    0xa6, 0xe0, 0x7a, 0x52, 0x6f, 0x34, 0xbb, 0xc7, 0xa5, 0x17, 0x40, 0x1c, 0xf6, 0x34, 0xd3,
+    0x9e, 0xf9, 0xa7, 0x6e, 0x14, 0x9b, 0xbd, 0xe8, 0xd0, 0x00, 0x48, 0x45, 0x38, 0x4a, 0x3b,
+    0x8a, 0x8a, 0x8a, 0x57, 0x60, 0x4d, 0xe6, 0x2d, 0x2f, 0x98, 0xbe, 0xb5, 0x05, 0x14, 0x73,
+    0x30, 0x2c, 0x86, 0x07, 0xa1, 0xa5, 0xcd, 0x55, 0xa5, 0xc9, 0x1d, 0xe9, 0xf3, 0x01, 0x6b,
+    0x34, 0xd3, 0x50, 0x6f, 0x6f, 0x5a, 0x0b, 0xb1, 0xef, 0x4f, 0x98, 0x43, 0x98, 0x0c, 0x54,
+    0x74, 0x67, 0x34, 0x54, 0xb6, 0x31, 0x77, 0x1a, 0x5d, 0xd4, 0xda, 0x29, 0x5c, 0x07, 0x89,
+    0x31, 0xeb, 0x41, 0x72, 0x7b, 0xd3, 0x28, 0xa7, 0x70, 0x1d, 0x45, 0x36, 0x8a, 0x40, 0x29,
+    0xa2, 0x92, 0x8a, 0x00, 0x50, 0x48, 0xe9, 0x52, 0xac, 0xcc, 0x3a, 0xf3, 0x51, 0x51, 0x4d,
+    0x36, 0x80, 0xb2, 0xb3, 0x29, 0xf6, 0xa7, 0x06, 0x07, 0xbd, 0x54, 0xa2, 0xab, 0x9d, 0x8a,
+    0xc5, 0xce, 0xb4, 0x55, 0x55, 0x76, 0x5e, 0x86, 0xa5, 0x59, 0xc7, 0xf1, 0x0c, 0x53, 0x52,
+    0x41, 0x62, 0x5c, 0x54, 0x4c, 0x80, 0xf5, 0x18, 0x35, 0x28, 0x60, 0x7a, 0x1a, 0x4e, 0xb4,
+    0xda, 0xb8, 0x15, 0x99, 0x0a, 0xfd, 0x29, 0x2a, 0xc1, 0x1f, 0x95, 0x44, 0xe9, 0xb7, 0x91,
+    0xd2, 0xa1, 0xa1, 0x8c, 0xa9, 0x23, 0x85, 0xa4, 0xe4, 0x70, 0x3d, 0x4d, 0x47, 0x52, 0xab,
+    0x3b, 0x2e, 0x33, 0x81, 0xed, 0x42, 0x4b, 0xa8, 0x12, 0xf9, 0x71, 0x47, 0xd7, 0xe6, 0x3e,
+    0xf4, 0xbb, 0x87, 0x61, 0xc5, 0x30, 0x00, 0xb4, 0xc6, 0x90, 0x76, 0xe6, 0xac, 0x45, 0xa5,
+    0x9c, 0x28, 0xfb, 0xb9, 0x3e, 0xf4, 0x35, 0xe3, 0x91, 0xd8, 0x55, 0x32, 0xc4, 0xf7, 0xa4,
+    0xa7, 0xce, 0xc2, 0xc4, 0xcd, 0x70, 0xed, 0xfc, 0x46, 0xa2, 0x2c, 0x4d, 0x36, 0x96, 0xb3,
+    0x72, 0x6c, 0x62, 0xd2, 0x8a, 0x4a, 0x05, 0x52, 0x11, 0x38, 0x94, 0x0c, 0x0c, 0x71, 0x4e,
+    0x33, 0x8e, 0xc2, 0xab, 0xd0, 0x2a, 0xae, 0x04, 0xa6, 0x63, 0xd8, 0x52, 0x19, 0x18, 0xf7,
+    0xa6, 0x52, 0x8a, 0x9b, 0xb0, 0x17, 0x24, 0xf7, 0xa5, 0xa4, 0xa5, 0xaa, 0x40, 0x02, 0x9e,
+    0x29, 0xa0, 0x53, 0x85, 0x52, 0x01, 0xd4, 0xa2, 0x90, 0x52, 0xe2, 0x98, 0x0e, 0x14, 0xe1,
+    0x4d, 0x14, 0xe1, 0x4c, 0x09, 0x16, 0xa6, 0x5a, 0x81, 0x6a, 0x65, 0x34, 0x0c, 0x92, 0x9a,
+    0x69, 0x69, 0xa6, 0x8b, 0x80, 0xd3, 0x4d, 0x34, 0x1a, 0x69, 0xa2, 0xe2, 0x17, 0x3e, 0xf4,
+    0x66, 0x9b, 0x8a, 0x5a, 0x2e, 0x01, 0x9a, 0x5a, 0x4a, 0x28, 0xb8, 0x0b, 0x48, 0x69, 0x68,
+    0xa4, 0x03, 0x71, 0x49, 0x8a, 0x93, 0x14, 0x62, 0x80, 0x19, 0x8a, 0x5c, 0x53, 0xb1, 0x46,
+    0x28, 0x01, 0xb8, 0xa7, 0x0c, 0x51, 0x8a, 0x4c, 0x50, 0x31, 0x68, 0xcd, 0x25, 0x14, 0xee,
+    0x02, 0xd1, 0x49, 0x4d, 0xa2, 0xe2, 0x1d, 0x9a, 0x33, 0x49, 0x9a, 0x28, 0x01, 0xdb, 0xc8,
+    0xe8, 0x4d, 0x21, 0x6c, 0x9e, 0x69, 0x29, 0x0d, 0x20, 0x17, 0x34, 0x99, 0x1d, 0xc5, 0x25,
+    0x14, 0xae, 0x03, 0xb0, 0xa7, 0xbe, 0x28, 0x11, 0x93, 0xd0, 0x8a, 0x6d, 0x2d, 0x2d, 0x00,
+    0x42, 0xa4, 0x75, 0x14, 0x66, 0x9d, 0xb8, 0xe3, 0x19, 0xa6, 0x53, 0x01, 0x73, 0x4b, 0x9a,
+    0x6d, 0x2d, 0x30, 0x17, 0x9a, 0x43, 0x9a, 0x70, 0x14, 0xa4, 0x50, 0x04, 0x74, 0x52, 0x91,
+    0x49, 0x52, 0xd0, 0x05, 0x14, 0x51, 0x8a, 0x56, 0x18, 0x62, 0x94, 0x0a, 0x4c, 0x52, 0xd1,
+    0x61, 0x0b, 0x8a, 0x30, 0x3d, 0x28, 0xa2, 0x80, 0x0d, 0xa2, 0xa5, 0x44, 0xa8, 0xea, 0x64,
+    0x34, 0xec, 0x03, 0xfc, 0xbe, 0x3a, 0xd4, 0x6f, 0x19, 0x15, 0x38, 0xce, 0x29, 0x18, 0x71,
+    0x45, 0x90, 0xca, 0x87, 0x23, 0xb5, 0x37, 0x26, 0xa5, 0x71, 0x51, 0xd2, 0x62, 0x13, 0x75,
+    0x07, 0x9a, 0x31, 0x45, 0x21, 0x8c, 0x23, 0x14, 0x94, 0xec, 0x52, 0x85, 0xa4, 0x03, 0x00,
+    0x26, 0x9d, 0xb3, 0xd6, 0x9d, 0x45, 0x16, 0x00, 0x55, 0x19, 0xa7, 0xd3, 0x28, 0xe6, 0xa9,
+    0x31, 0x0e, 0xcd, 0x26, 0xea, 0x4c, 0x51, 0x45, 0xc0, 0x5c, 0x9a, 0x33, 0x49, 0xf8, 0xd1,
+    0x45, 0xc0, 0x5d, 0xd4, 0x64, 0xd3, 0x73, 0x46, 0x68, 0xb8, 0x0e, 0xa2, 0x9b, 0x9a, 0x4c,
+    0xd1, 0x70, 0x1f, 0x9a, 0x37, 0x0a, 0x8c, 0xb5, 0x37, 0x75, 0x1c, 0xc0, 0x4a, 0x5a, 0x90,
+    0xb5, 0x45, 0xb8, 0x9a, 0x0d, 0x1c, 0xc0, 0x3c, 0xbd, 0x34, 0xbd, 0x36, 0x90, 0x9c, 0x52,
+    0xb8, 0x0a, 0x58, 0xd3, 0x72, 0x68, 0xcd, 0x26, 0x4d, 0x20, 0x13, 0x9f, 0x5a, 0x75, 0x34,
+    0xd2, 0x50, 0x03, 0xb3, 0x46, 0xec, 0x53, 0x68, 0xa5, 0x70, 0x1f, 0xe6, 0x7b, 0x52, 0x79,
+    0x86, 0x99, 0x4b, 0x4e, 0xe0, 0x3b, 0xcc, 0x34, 0x85, 0xb2, 0x3a, 0xd3, 0x68, 0xc5, 0x2b,
+    0x80, 0xcc, 0x1a, 0x69, 0xa9, 0x18, 0x8c, 0x62, 0xa3, 0xa9, 0x63, 0x0e, 0xd4, 0x94, 0xec,
+    0x0d, 0xb9, 0xcf, 0xe1, 0x4d, 0xa0, 0x02, 0x92, 0x96, 0x81, 0x40, 0x09, 0x4a, 0x29, 0x68,
+    0xa0, 0x02, 0x8a, 0x28, 0xa7, 0x70, 0x12, 0x8a, 0x28, 0xa5, 0x70, 0x0a, 0x28, 0x3c, 0x52,
+    0x66, 0x8b, 0x80, 0x11, 0x46, 0x28, 0xcd, 0x19, 0xa3, 0x40, 0x12, 0x8a, 0x52, 0x46, 0x29,
+    0x29, 0x00, 0x94, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14,
+    0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00,
+    0x14, 0x51, 0x45, 0x00, 0x14, 0x51, 0x45, 0x00, 0x2d, 0x14, 0x51, 0x40, 0x05, 0x14, 0x51,
+    0x40, 0x05, 0x14, 0x51, 0x40, 0x0e, 0x57, 0x2b, 0xd2, 0xa4, 0x59, 0x01, 0xeb, 0xc1, 0xa2,
+    0x8a, 0x69, 0x80, 0xe3, 0x22, 0xe7, 0x04, 0xd2, 0xf0, 0x47, 0xb5, 0x14, 0x55, 0x5c, 0x44,
+    0x04, 0x72, 0x71, 0xd2, 0x9f, 0xbf, 0x03, 0xa5, 0x14, 0x50, 0x31, 0xa5, 0x89, 0xeb, 0x49,
+    0x45, 0x14, 0xc4, 0x2d, 0x06, 0x8a, 0x29, 0x30, 0x12, 0x96, 0x8a, 0x2a, 0x06, 0x02, 0x96,
+    0x8a, 0x2a, 0xe2, 0x02, 0xd1, 0x45, 0x14, 0xd8, 0x83, 0x34, 0xa2, 0x8a, 0x2a, 0x53, 0x18,
+    0xe1, 0x4a, 0x28, 0xa2, 0xb4, 0x42, 0x1e, 0x29, 0x45, 0x14, 0x55, 0xa0, 0x1c, 0x05, 0x3b,
+    0x14, 0x51, 0x4c, 0x05, 0x14, 0xa2, 0x8a, 0x29, 0x01, 0x22, 0x8a, 0x95, 0x68, 0xa2, 0x81,
+    0x8f, 0xa6, 0x9a, 0x28, 0xa4, 0x32, 0x33, 0x4d, 0xa2, 0x8a, 0x04, 0x14, 0x01, 0x45, 0x14,
+    0x00, 0xb8, 0xa5, 0x02, 0x8a, 0x29, 0x88, 0x31, 0x46, 0x28, 0xa2, 0x80, 0x16, 0x97, 0x14,
+    0x51, 0x40, 0x09, 0x8a, 0x31, 0x45, 0x14, 0x00, 0x62, 0x8c, 0x51, 0x45, 0x00, 0x25, 0x25,
+    0x14, 0x50, 0x30, 0xa4, 0x22, 0x8a, 0x28, 0x10, 0xda, 0x28, 0xa2, 0x80, 0x0a, 0x4a, 0x28,
+    0xa4, 0xc0, 0x29, 0x28, 0xa2, 0xa1, 0x8c, 0x5c, 0xd1, 0x9a, 0x28, 0xa4, 0x02, 0xe6, 0x8a,
+    0x28, 0xaa, 0x4c, 0x41, 0x8a, 0x28, 0xa2, 0xac, 0x07, 0x03, 0x4b, 0x45, 0x14, 0x00, 0xd3,
+    0x4d, 0xa2, 0x8a, 0x4c, 0x02, 0x97, 0x34, 0x51, 0x49, 0x00, 0x66, 0x93, 0x34, 0x51, 0x43,
+    0x00, 0xcd, 0x1b, 0x8d, 0x14, 0x54, 0x0c, 0x32, 0x6a, 0x68, 0x9a, 0x8a, 0x2a, 0x90, 0x8b,
+    0x4a, 0x78, 0xa5, 0x61, 0x45, 0x14, 0xae, 0x32, 0xbc, 0x80, 0xd5, 0x63, 0xc1, 0xa2, 0x8a,
+    0x00, 0x6e, 0x4d, 0x2e, 0x4d, 0x14, 0x52, 0x01, 0xc3, 0x9a, 0x5c, 0x51, 0x45, 0x31, 0x06,
+    0x29, 0x71, 0x45, 0x14, 0xc0, 0x4a, 0x28, 0xa2, 0x80, 0x02, 0x69, 0x28, 0xa2, 0x90, 0x05,
+    0x25, 0x14, 0x50, 0x30, 0xa6, 0x92, 0x28, 0xa2, 0x80, 0x13, 0x34, 0xdc, 0x9a, 0x28, 0xa4,
+    0x01, 0x49, 0x45, 0x14, 0x00, 0x13, 0x49, 0x9a, 0x28, 0xa0, 0x04, 0xa2, 0x8a, 0x28, 0x01,
+    0x29, 0x28, 0xa2, 0x80, 0x0a, 0x4c, 0x8a, 0x28, 0xa4, 0xc4, 0x05, 0x85, 0x26, 0xea, 0x28,
+    0xa5, 0x71, 0x89, 0xbb, 0xda, 0x90, 0xb1, 0xa2, 0x8a, 0x57, 0x01, 0x37, 0x1f, 0x5a, 0x42,
+    0x49, 0xef, 0x45, 0x14, 0x00, 0xec, 0xf1, 0x4d, 0x3d, 0x68, 0xa2, 0x9b, 0x01, 0xb4, 0x51,
+    0x45, 0x48, 0x05, 0x2d, 0x14, 0x50, 0x01, 0x45, 0x14, 0x53, 0x00, 0xa3, 0x34, 0x51, 0x48,
+    0x04, 0x26, 0x93, 0x34, 0x51, 0x40, 0x08, 0x4e, 0x68, 0xa2, 0x8a, 0x00, 0x28, 0xa2, 0x8a,
+    0x00, 0x28, 0xa2, 0x8a, 0x00, 0xff, 0xd9
+};
+size_t small_img_len = 73687;
+
+
diff --git a/src/note-c/test/hitl/card.binary/lib/notecard_binary/small_img.h b/src/note-c/test/hitl/card.binary/lib/notecard_binary/small_img.h
new file mode 100644
index 0000000..628a0ab
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/lib/notecard_binary/small_img.h
@@ -0,0 +1,10 @@
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+extern const uint8_t small_img_map[];
+extern size_t small_img_len;
+
+
diff --git a/src/note-c/test/hitl/card.binary/platformio.ini b/src/note-c/test/hitl/card.binary/platformio.ini
new file mode 100644
index 0000000..00ef65f
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/platformio.ini
@@ -0,0 +1,30 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env]
+platform = ststm32
+board = bw_swan_r5
+framework = arduino
+build_flags =
+	-std=c++14
+	-Wall
+	-Werror # ensure unused functions in the test script generate an error
+	-D PIO_FRAMEWORK_ARDUINO_ENABLE_CDC
+	-D UNITY_INCLUDE_PRINT_FORMATTED
+	'-D DEFAULT_NOTEHUB_PROXY_ROUTE_ALIAS="cobstest"'
+	'-D DEFAULT_PRODUCT_UID=""' # don't set the product UID
+lib_deps = blues/Blues Wireless Notecard@^1.5.1
+debug_tool = stlink
+test_framework = unity
+test_port = /dev/swan
+
+[env:debug]
+build_type = debug
+debug_test = *
diff --git a/src/note-c/test/hitl/card.binary/src/main.cpp b/src/note-c/test/hitl/card.binary/src/main.cpp
new file mode 100644
index 0000000..fabf04a
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/src/main.cpp
@@ -0,0 +1,19 @@
+
+#include "NotecardBinary.h"
+
+void setup()
+{
+
+}
+
+void showHelp()
+{
+
+}
+
+void loop()
+{
+
+}
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/LOCAL_TESTING.md b/src/note-c/test/hitl/card.binary/test/LOCAL_TESTING.md
new file mode 100644
index 0000000..7f7049f
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/LOCAL_TESTING.md
@@ -0,0 +1,50 @@
+The easiest way to run the end to end tests locally is to use the workflow file. However, if you need to get in even closer, then manual setup is the way to go.
+
+The md5 server and localtunnel are long running servers so you'll need a few shell terminals open.
+
+1. launch the md5 server
+
+```bash
+   cd test/hitl/scripts
+   python3 -m md5srv.py --token <any-string> --save --dir test_files
+```
+
+2. Install localtunnel if you don't already have it `npm install -g localtunnel`
+
+3. Launch localtunnel using your own subdomain (e.g. bobscobsjobs), so it doesn't keep changing. Localtunnel can crash when the server port goes away, so may need to be relauched.
+
+```bash
+   npx localtunnel -p 8080 -s <mysubdomain>
+```
+
+4. Create a proxy route in Notehub with a suitable name and a unique alias, such as "cobstest". The url should be the same as the output from localtunnel. Add an additional header `X-Access-Token` with the value of your token that was passed to the md5srv above.
+
+5. Edit `test/hitl/card.binary/platformio.ini` and add these lines:
+```
+  build_flags =
+     ...
+	'-D NOTEHUB_PROXY_ROUTE_ALIAS="cobstest"'
+	'-D PRODUCT_UID="<your product UID>"'
+```
+
+6. Edit `test/hitl/card.binary/test/test_card_binary.cpp` in VSCode. To run just selected tests you can comment out any macros in the `testsuite_card_binary()` function or add a filter. Commenting out functions doesn't work because they are then unused, causing a compiler error. Use `if (false)` instead.
+
+7. Select the `env:debug` environment in the status bar at the bottom. Compile and upload the code using `>PlatformIO upload`, or press F5 to start a debugging session.
+
+> Note that there is a bug in PlatformIO that uploads the code even if the build fails. I typically keep the test hardware switched off on the switched USB hub until the build is successful.
+
+On pressing F5, a successful build looks like
+
+```
+Processing debug (platform: ststm32; board: bw_swan_r5; framework: arduino)
+---------------------------------------------------------------------------------------------
+Building...
+ *  Terminal will be reused by tasks, press any key to close it.
+```
+
+8. Run the tests with
+```bash
+pio test -e debug --without-building --without-uploading --json-output-path test.json --junit-output-path test.xml
+```
+
+To see the notecard debug output, add `-vv` after `pio test`.
\ No newline at end of file
diff --git a/src/note-c/test/hitl/card.binary/test/README.md b/src/note-c/test/hitl/card.binary/test/README.md
new file mode 100644
index 0000000..410a16d
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/README.md
@@ -0,0 +1,55 @@
+
+## `card.binary`` Tests
+
+The tests in this project aim to exhaustively test the `card.binary` feature on Notecard.
+
+The tests have a number of variations:
+* The Notecard communications interface used to send and validate the binary data
+  * I2C
+  * Serial (LPUART)
+  * AUX serial
+    * baudrates from 9600 up to 115200
+* The size of the chunks of data sent over the interface when doing `card.binary.put`.
+* The total size of the image sent, and the contents of the image. Variations include:
+  * A repeated value
+  * A repeated buffer (an image can repeat another image)
+  * A random image from a given seed
+* The maximum filled size of the `card.binary` buffer. The maximum size is typically used, although smoke tests and other fast-running tests use a smaller value.
+* The size of the chunks used to verify the buffer via `card.binary.get`.
+* The onward handler of each filled `card.binary` buffer:
+  * web.post chunked: sends the data for each filled buffer to the endpoint. The server computes the combined md5 and length for all chunks received which is validated against the original image md5 and length.
+  * web.post unchunked: uses Notehub to combine the separate web.post fragments into a single payload sent to the endpoint. Again, the md5 and length are validated.
+  * note.add
+
+## Outline of the binary test
+
+A particular test may use a small image, and only partially fill the card.binary buffer, or it may fill it several times when the image is larger than the maximum fill size of the buffer set in the test. After the buffer is filled, the binary content is sent to Notehub, either via `web.post` or `note.add`.
+
+In outline, the tests operate like this:
+
+```
+    while there's more data in the image to send:
+        while the card.binary buffer is not full:
+            send a chunk of data over the selected Notecard interface
+        validate the card.binary buffer:
+            while there's more data to retrieve:
+                retrieve a chunk the buffer in chunks of a given size
+                compare the contents and md5 of the chunk with the corresponding portion of the image
+        dispatch the card.binary buffer:
+            when web.post chunked:
+                send the card.binary buffer via the web.post endpoint immediately
+                verify the length and MD5 received
+            when web.post unchunked:
+                send the card.binary buffer via the web.post as a fragment to be assembled by Notehub. Validate HTTP status is 100 for all but the last fragment.
+    the transfer is complete:
+        web.post chunked: validate the total length and MD5 received by the md5 server and the number of chunks sent
+        web.post unchunked: validate the final web.post returns 200, the total length and MD5 received by the md5 server and the number of chunks sent
+```
+
+The tests perform validation at each step, from each chunk sent all the way to verifying successful
+transmission of the complete image.
+
+
+## Local Test Setup
+
+It's of course possible to run the tests locally, such as for debugging or trying out new types of test. See [LOCAL_TESTING.md](./LOCAL_TESTING.md) for more information on this.
\ No newline at end of file
diff --git a/src/note-c/test/hitl/card.binary/test/test_binary_generators.cpp b/src/note-c/test/hitl/card.binary/test/test_binary_generators.cpp
new file mode 100644
index 0000000..d1cf036
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_binary_generators.cpp
@@ -0,0 +1,91 @@
+
+#include "NotecardBinary.h"
+#include <Arduino.h>
+#include "test_binary_generators.h"
+
+#include "test_unity_util.h"
+
+bool testsuite_binary_generators_filter(const char* name)
+{
+    return true;
+}
+
+void testsuite_binary_generators_setUp()
+{
+}
+
+void testsuite_binary_generators_tearDown()
+{
+}
+
+typedef std::function<void(BinaryGenerator& image, uint8_t* buf, size_t bufSize, size_t chunkSize, size_t total_read)> content_check_fn;
+
+void check_binary(BinaryGenerator& image, size_t total_size, size_t bufSize, content_check_fn contentCheck)
+{
+    TEST_ASSERT_EQUAL(total_size, image.length());
+    TEST_ASSERT_EQUAL(0, image.offset());
+
+    uint8_t buf[bufSize];
+    size_t total_read = 0;
+    while (image.remaining()) {
+        TEST_ASSERT_FALSE(image.isEOF());
+        TEST_ASSERT_EQUAL(total_read, image.offset());
+        TEST_ASSERT_EQUAL(total_size-total_read, image.remaining());
+        size_t chunk = image.read(buf, bufSize);
+        total_read += chunk;
+        contentCheck(image, buf, bufSize, chunk, total_read);
+    }
+    TEST_ASSERT_TRUE(image.isEOF());
+}
+
+content_check_fn check_content_fixed_value(uint8_t value)
+{
+    return [=](BinaryGenerator& image, uint8_t* buf, size_t bufSize, size_t chunkSize, size_t totalRead) {
+        for (size_t i=0; i<chunkSize; i++) {
+            if (buf[i]!=value) {
+                TEST_PRINTF("incorrect value at offset %d: %d != %d", totalRead, value, buf[i]);
+                TEST_FAIL_MESSAGE("BinaryGenerator validation failed.");
+            }
+        }
+    };
+}
+
+TEST(test_fixed_value_generator)
+{
+    uint8_t pattern[128];
+    memset(pattern, 0x7, sizeof(pattern));
+    BufferBinaryGenerator chunk(pattern, sizeof(pattern));
+    size_t binary_size = 20*1024;
+    RepeatedBinaryGenerator image(chunk, binary_size);
+
+    check_binary(image, binary_size, 95, check_content_fixed_value(0x7));
+}
+
+TEST(test_random_generator)
+{
+    uint32_t seed = 1234;
+    RandomBinaryGenerator image(LARGE_SIZE, seed);
+    uint8_t buf[20];
+    image.read(buf, sizeof(buf));
+
+    uint8_t buf2[20];
+    image.reset();
+    image.read(buf2, sizeof(buf2));
+
+    TEST_ASSERT_TRUE(!memcmp(buf, buf2, sizeof(buf)));
+    uint8_t v1 = buf[0];
+    uint8_t v2 = buf[1];
+    uint8_t v3 = buf[2];
+    TEST_ASSERT_EQUAL(136, v1);
+    TEST_ASSERT_EQUAL(40, v2);
+    TEST_ASSERT_EQUAL(142, v3);
+}
+
+void testsuite_binary_generators()
+{
+    TEST_SUITE(binary_generators);
+    RUN_TEST(test_fixed_value_generator);
+    RUN_TEST(test_random_generator);
+}
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/test_binary_generators.h b/src/note-c/test/hitl/card.binary/test/test_binary_generators.h
new file mode 100644
index 0000000..9c4f592
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_binary_generators.h
@@ -0,0 +1,62 @@
+
+#pragma once
+#include "NotecardBinary.h"
+
+/**
+ * @brief Unity and PlatformIO support generation of multiple distinct binaries.
+ * However, I didn't feel it necessary to produce another binary for these tests.
+ */
+void testsuite_binary_generators();
+
+
+struct BuildAllSameValue {
+    uint8_t buf[128];
+    BufferBinaryGenerator chunk;
+    RepeatedBinaryGenerator image;
+
+    BuildAllSameValue(size_t length, uint8_t value)
+        : chunk(buf, sizeof(buf)), image(chunk, length)
+    {
+        memset(buf, value, sizeof(buf));
+    }
+
+    BinaryGenerator& operator ()()
+    {
+        return image;
+    }
+};
+
+struct AllZeros : BuildAllSameValue {
+    AllZeros(size_t length) : BuildAllSameValue(length, 0) {}
+};
+
+struct AllSevens : BuildAllSameValue {
+    AllSevens(size_t length) : BuildAllSameValue(length, 7) {}
+};
+
+struct BuildFromBinaryImage {
+    BufferBinaryGenerator image;
+
+    BuildFromBinaryImage(size_t length, const BinaryImage& binary)
+        : image(binary.data, binary.length) {}
+
+    BinaryGenerator& operator ()()
+    {
+        return image;
+    }
+};
+
+struct SmallBinaryImage : BuildFromBinaryImage {
+    SmallBinaryImage(size_t size) : BuildFromBinaryImage(size, small_binary) {}
+};
+
+struct BuildRandom {
+    RandomBinaryGenerator image;
+    BuildRandom(size_t size, int seed) : image(size, seed) {}
+    BinaryGenerator& operator ()()
+    {
+        return image;
+    }
+};
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/test_card_binary.cpp b/src/note-c/test/hitl/card.binary/test/test_card_binary.cpp
new file mode 100644
index 0000000..7d97fc6
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_card_binary.cpp
@@ -0,0 +1,477 @@
+
+#include "NotecardBinary.h"
+#include "NotecardComms.h"
+#include "test_binary_generators.h"
+#include "test_unity_util.h"
+#include "utils.h"  // for XSTR
+#ifndef TEST_CARD_BINARY_EXHAUSTIVELY
+#define TEST_CARD_BINARY_EXHAUSTIVELY 0
+#endif
+
+
+NotecardBinary cardBinary;
+
+#if !defined(NOTEHUB_PROXY_ROUTE_ALIAS) && defined(DEFAULT_NOTEHUB_PROXY_ROUTE_ALIAS)
+#define NOTEHUB_PROXY_ROUTE_ALIAS DEFAULT_NOTEHUB_PROXY_ROUTE_ALIAS
+#endif
+
+#ifndef NOTEHUB_PROXY_ROUTE_ALIAS
+#error "NOTEHUB_PROXY_ROUTE_ALIAS not defined"
+#endif
+
+// The filter is useful for running a subset of tests, especially when they are defined
+// as regular functions rather than macros.
+// #define TEST_CARD_BINARY_FILTER strstr(name, "serial")
+
+#ifndef TEST_CARD_BINARY_FILTER
+#define TEST_CARD_BINARY_FILTER true
+#endif
+
+bool testsuite_card_binary_filter(const char* name)
+{
+    return TEST_CARD_BINARY_FILTER;
+}
+
+void testsuite_card_binary_setUp(void)
+{
+    cardBinary.notecardDebugStreamInitialize();
+}
+
+void testsuite_card_binary_tearDown(void)
+{
+}
+
+void assert_initialize_notecard(NotecardInterface iface)
+{
+    TEST_ASSERT_TRUE_MESSAGE(initialize_notecard_interface(iface), "Unable to initialize Notecard I/O.");
+}
+
+// todo - don't guess at the buffer size use the Note
+uint8_t transfer_buffer[NotecardBinary::MAX_CHUNK_SIZE + 128];
+size_t max_binary_length;
+
+void AssertNoteBinaryReset()
+{
+    const char* err = NoteBinaryStoreReset();
+    if (err) {
+        dbgSerial.print("Error calling NoteBinaryReset: ");
+        dbgSerial.println(err);
+        TEST_FAIL_MESSAGE("NoteBinaryReset failed.");
+    }
+}
+
+struct BinaryTestArgs {
+    /**
+     * @brief The upper limit on how much binary data to send to the notecard. Default value is
+     *   maximum buffer size returned from `card.binary`.
+     */
+    size_t _maxCardBinary;
+
+    /**
+     * @brief The chunk sizes to use for retrieving the binary via card.binary.get.
+     * Default is to use maxCardBinary.
+     */
+    const int* _validateChunkSizes;
+    size_t _validateChunkSizesCount;
+
+    enum Handler {
+        NONE,
+        WEB_POST_CHUNKED,   // multiple calls to web.post, each resulting a request to the web.post endpoint
+        WEB_POST_UNCHUNKED, // multiple calls to web.post, combined by Notehub resulting in one call to the web.post endpoint.
+        NOTE_ADD
+    } _handler;
+
+
+    BinaryTestArgs()
+    {
+        _maxCardBinary = 0;
+        _validateChunkSizes = nullptr;
+        _validateChunkSizesCount = 0;
+        _handler = NONE;
+    }
+
+    BinaryTestArgs& handler(Handler handler)
+    {
+        _handler = handler;
+        return *this;
+    }
+
+    BinaryTestArgs& maxCardBinary(size_t max)
+    {
+        _maxCardBinary = max;
+        return *this;
+    }
+
+    template<const size_t N> BinaryTestArgs& validateChunkSizes(const int (&sizes)[N])
+    {
+        _validateChunkSizesCount = N;
+        _validateChunkSizes = sizes;
+        return *this;
+    }
+
+};
+
+/**
+ * @brief Primary function that runs a single binary transfer over a given Notecard interface.
+ *
+ * @param generator The binary data to transfer
+ * @param iface The Notecard interface to use for the communication with Notecard
+ * @param chunkSize The amount of binary data transferred in each chunk (card.binary.put request)
+ */
+void binaryTransferTest(const char* name, BinaryGenerator& generator, NotecardInterface iface, size_t chunkSize, const BinaryTestArgs& testArgs)
+{
+    assert_initialize_notecard(iface);
+    // ensure notecard is in the correct mode for binary file transfer.
+    // Todo this is only required when using web.* to retrieve/upload the uploaded binary.
+    TEST_ASSERT_TRUE_MESSAGE(cardBinary.notecardConnectionMode(), "Unable to set Notecard connection mode");
+
+    AssertNoteBinaryReset();
+
+    size_t maxCardBinary = testArgs._maxCardBinary;
+    if (!maxCardBinary) {
+        if (!max_binary_length) {
+            TEST_FAIL_MESSAGE("max_binary_length not set. Be sure the get_max_length test has been run first.");
+            return;
+        } else {
+            maxCardBinary = max_binary_length;
+        }
+    }
+
+    if (!chunkSize) {
+        chunkSize = cardBinary.maxChunkSize(iface);
+    }
+
+    NotecardBinary::BinaryTransfer tx = {
+        .imageName = name,
+        .image = generator,
+        .chunkSize = chunkSize,
+        .buffer = transfer_buffer,
+        .bufferLength = sizeof(transfer_buffer),
+        .maxBinarySize = maxCardBinary,
+        .validate = true,
+        .transfer_cb = NotecardBinary::accept_transfer_callback
+    };
+
+    // allocate all the handlers on the stack, easier memory management. They're not large.
+
+    WebPostHandler webPostHandler(NOTEHUB_PROXY_ROUTE_ALIAS, tx.imageName, MIME_APPLICATION_OCTETSTREAM, false, false);
+    WebPostHandler webPostChunkedHandler(NOTEHUB_PROXY_ROUTE_ALIAS, tx.imageName, MIME_APPLICATION_OCTETSTREAM, true, false);
+    WebPostHandler webPutHandler(NOTEHUB_PROXY_ROUTE_ALIAS, tx.imageName, MIME_APPLICATION_OCTETSTREAM, false, true);
+    WebPostHandler webPutChunkedHandler(NOTEHUB_PROXY_ROUTE_ALIAS, tx.imageName, MIME_APPLICATION_OCTETSTREAM, true, true);
+    NoteAddHandler noteAddHandler(NOTEHUB_PROXY_ROUTE_ALIAS, tx.imageName);
+
+    // NoteAddHandler noteAddHandler;
+    switch (testArgs._handler) {
+    case BinaryTestArgs::NONE:
+        tx.transfer_cb = NotecardBinary::accept_transfer_callback;
+        break;
+    case BinaryTestArgs::WEB_POST_CHUNKED:
+        tx.transfer_cb = webPostChunkedHandler.transfer_callback();
+        break;
+    case BinaryTestArgs::WEB_POST_UNCHUNKED:
+        tx.transfer_cb = webPostHandler.transfer_callback();
+        break;
+    case BinaryTestArgs::NOTE_ADD:
+        tx.transfer_cb = noteAddHandler.transfer_callback();
+        break;
+    default:
+        TEST_FAIL_MESSAGE("Unknown transfer handler");
+        return;
+    }
+
+    TEST_ASSERT_TRUE_MESSAGE(cardBinary.transferBinary(tx), "binary transfer failed");
+
+    AssertNoteBinaryReset();
+}
+
+
+
+const BinaryTestArgs webpost = BinaryTestArgs().handler(BinaryTestArgs::WEB_POST_UNCHUNKED);
+const BinaryTestArgs webpost_chunked = BinaryTestArgs().handler(BinaryTestArgs::WEB_POST_CHUNKED);
+const BinaryTestArgs note_add = BinaryTestArgs().handler(BinaryTestArgs::NOTE_ADD);
+const BinaryTestArgs validate;
+
+// negative sizes validate based on the size of the card.binary minus the absolute value. So 0 means
+// validate using a buffer exactly large enough to hold the entire transferred binary.
+const int validate_chunk_sizes[9] = { 255, 256, 1234, 4095, 4096, -3, -2, -1 /* binary size -1 */, 0 /* binary size */};
+const BinaryTestArgs validate_in_chunks = BinaryTestArgs().validateChunkSizes(validate_chunk_sizes);
+
+
+
+// This Variadic macro allows parameters to be passed to the constructor of `image`.
+// The macro declares a lambda function with the desired test name, and no capture,
+// so it's equivalent to a function pointer.
+// imagename: the name of the image, used in the test name. Note this should be a token, not a string.
+// image: An image builder that is constructed with the size, and the optional variadic arguments.
+// It's expected to provide `BinaryGenerator& operator()` to retrieve the built image.
+// iface: a NotecardInterface enum value, such as NOTECARD_IF_SErIAL.
+// ifacename: A friendly name for the notecard interface, appears in the test name.
+// size: the size of the image to create/transfer.
+// sizename: a name for the size, appears in the test name.
+// testArgs: additional test arguments
+
+// This global avoids any capture on the lambda so it remains a regular C functions.
+const BinaryTestArgs* currentTestArgs;
+
+#define RUN_SIZE(imagename, image, iface, ifacename, size, sizename, testArgs, ...) { \
+  currentTestArgs = &testArgs; \
+  UnityTestFunction test_ ## imagename ## _ ## ifacename ## _ ## sizename ## testArgs = []() { \
+    image builder = image(size __VA_OPT__(,) __VA_ARGS__); \
+    binaryTransferTest(XSTR(imagename), builder(), iface, 0, *currentTestArgs); \
+  }; \
+  RUN_FILTER(test_ ## imagename ## _ ## ifacename ## _ ## sizename ## testArgs ); \
+  currentTestArgs = nullptr; \
+}
+
+// Tests binary transfer over a range of sizes.
+#define RUN_ALL_SIZES(imagename, image, iface, ifacename, testArgs, ...) \
+  RUN_SIZE(imagename, image, iface, ifacename, TINY_SIZE, TINY_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_SIZE(imagename, image, iface, ifacename, SMALL_SIZE, SMALL_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_SIZE(imagename, image, iface, ifacename, MEDIUM_SIZE, MEDIUM_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_SIZE(imagename, image, iface, ifacename, LARGE_SIZE, LARGE_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_SIZE(imagename, image, iface, ifacename, XLARGE_SIZE, XLARGE_SIZE_NAME, testArgs, __VA_ARGS__); \
+// todo - add sizes greater than one buffer size
+
+// Tests binary transfer over a range of sizes (using RUN_ALL_SIZES) and over all Notecard Interfaces.
+#define RUN_ALL_SIZES_ALL_IFACES(imagename, image, testArgs, ...) \
+  RUN_ALL_SIZES(imagename, image, NOTECARD_IF_AUX_SERIAL, auxserial, testArgs, __VA_ARGS__); \
+  RUN_ALL_SIZES(imagename, image, NOTECARD_IF_I2C, i2c, testArgs, __VA_ARGS__); \
+  RUN_ALL_SIZES(imagename, image, NOTECARD_IF_SERIAL, serial, testArgs, __VA_ARGS__);
+
+// Tests binary transfer over AUX serial, using the given baud rate and chunk size.
+#define RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, chunkSize, testArgs, ...) \
+  UnityTestFunction test_ ## imagename ## _ ## aux_serial ## _ ## baudrate ## _ ## sizename ## chunk ## chunkSize ## _ ## testArgs = []() { \
+    image builder = image(size __VA_OPT__(,) __VA_ARGS__); \
+    set_aux_serial_baudrate(baudrate); \
+    binaryTransferTest(builder(), NOTECARD_IF_AUX_SERIAL, chunkSize, testArgs); \
+  }; \
+  RUN_FILTER(test_ ## imagename ## _ ## aux_serial ## _ ## baudrate ## _ ## sizename ## chunk ## chunkSize ## _ ## testArgs);
+
+#define RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, baudrate, testArgs, ...) \
+  UnityTestFunction test_ ## imagename ## _ ## aux_serial ## _ ## baudrate ## _ ## sizename = []() { \
+    image builder = image(size __VA_OPT__(,) __VA_ARGS__); \
+    set_aux_serial_baudrate(baudrate); \
+    binaryTransferTest(builder(), NOTECARD_IF_AUX_SERIAL); \
+  }; \
+  RUN_FILTER(test_ ## imagename ## _ ## aux_serial ## _ ## baudrate ## _ ## sizename);
+
+#define RUN_AUX_SERIAL_ALL_CHUNK_SIZES(imagename, image, size, sizename, baudrate, testArgs, ...) \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 256); \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 512); \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 1024); \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 2048); \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 4096);
+
+#define RUN_AUX_SERIAL_SELECT_CHUNK_SIZES(imagename, image, size, sizename, baudrate, ...) \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 256); \
+    RUN_AUX_SERIAL_BAUDRATE_CHUNK(imagename, image, size, sizename, baudrate, testArgs, 4096);
+
+
+// Tests binary transfer over AUX serial using a variety of baudrates
+#define RUN_AUX_SERIAL_ALL_BAUDRATES(imagename, image, size, sizename, testArgs, ...) \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 9600, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 14400, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 19200, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 38400, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 57600, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 115200, testArgs, __VA_ARGS__);
+
+#define RUN_AUX_SERIAL_SELECT_BAUDRATES(imagename, image, size, sizename, testArgs, ...) \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 9600, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_BAUDRATE(imagename, image, size, sizename, 115200, testArgs, __VA_ARGS__);
+
+
+#ifndef TEST_AUX_SERIAL_EXHAUSTIVELY
+#define TEST_AUX_SERIAL_EXHAUSTIVELY TEST_CARD_BINARY_EXHAUSTIVELY
+#endif
+
+#if TEST_AUX_SERIAL_EXHAUSTIVELY
+#define RUN_AUX_SERIAL_BAUDRATES RUN_AUX_SERIAL_SELECT_BAUDRATES
+#else
+#define RUN_AUX_SERIAL_BAUDRATES RUN_AUX_SERIAL_ALL_BAUDRATES
+#endif
+
+
+/**
+ * @brief Macro that expands to a matrix of tests.
+ */
+#define RUN_AUX_SERIAL_ALL_SIZES_ALL_BAUDRATES(imagename, image, testArgs, ...) \
+  RUN_AUX_SERIAL_ALL_BAUDRATES(imagename, image, TINY_SIZE, TINY_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_ALL_BAUDRATES(imagename, image, SMALL_SIZE, SMALL_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_ALL_BAUDRATES(imagename, image, MEDIUM_SIZE, MEDIUM_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_ALL_BAUDRATES(imagename, image, LARGE_SIZE, LARGE_SIZE_NAME, testArgs, __VA_ARGS__); \
+  RUN_AUX_SERIAL_ALL_BAUDRATES(imagename, image, MAX_SIZE, MAX_SIZE_NAME, testArgs, __VA_ARGS__);
+
+static const size_t R5_MAX_BINARY_LENGTH = 130554;
+static const size_t U5_MAX_BINARY_LENGTH = 261110;
+
+size_t get_expected_max_binary_length()
+{
+    size_t ret = 0;
+    J* rsp = NoteRequestResponseWithRetry(NoteNewRequest("card.version"), 10);
+    if (rsp == nullptr) {
+        dbgSerial.println("No response to card.version.");
+    } else {
+        char *target = JGetString(JGetObject(rsp, "body"), "target");
+        if (target == nullptr) {
+            dbgSerial.println("Failed to get target from card.version body.");
+        } else {
+            if (strcmp(target, "r5") == 0) {
+                ret = R5_MAX_BINARY_LENGTH;
+            } else if (strcmp(target, "u5") == 0) {
+                ret = U5_MAX_BINARY_LENGTH;
+            } else {
+                dbgSerial.print("Unrecognized target: ");
+                dbgSerial.println(target);
+            }
+        }
+    }
+
+    JDelete(rsp);
+
+    return ret;
+}
+
+/**
+ * @brief Retrieves the maximum card.binary length.
+ */
+void test_get_max_binary_length()
+{
+    size_t expected_max_binary_length = 0;
+    assert_initialize_notecard(NOTECARD_IF_I2C);
+
+    AssertNoteBinaryReset();
+
+    expected_max_binary_length = get_expected_max_binary_length();
+    if (expected_max_binary_length == 0) {
+        TEST_FAIL_MESSAGE("Failed to determine max binary length.");
+    }
+
+    J* rsp = NoteRequestResponseWithRetry(NoteNewRequest("card.binary"), 10);
+    J* max_item = nullptr;
+    if (rsp==nullptr || !JIsNullString(rsp, "err") || !JIsNumber(max_item=JGetObjectItem(rsp, "max"))) {
+        TEST_FAIL_MESSAGE("Couldn't retrieve the maximum binary length.");
+    } else {
+        int length = JNumberValue(max_item);
+        if (length<1024) {
+            TEST_FAIL_MESSAGE("card.binary max is too small.");
+        }
+        max_binary_length = length;
+        TEST_ASSERT_EQUAL(expected_max_binary_length, max_binary_length);
+    }
+    JDelete(rsp);
+}
+
+/**
+ * @brief Tests the maximum binary transfer size over a given Notecard interface.
+ * Requires `test_get_max_binary_length()` to have been called first.
+ * @param nif The notecard interface to use for the test.
+ */
+void base_test_max_length(NotecardInterface nif, const BinaryTestArgs& testArgs)
+{
+    if (max_binary_length==0) {
+        TEST_FAIL_MESSAGE("could not get max binary length");
+    }
+    uint8_t buf[257];  // 256+1 so that the pattern "steps upwards"
+    for (uint16_t i=0; i<sizeof(buf); i++) {
+        buf[i] = uint8_t(i);
+    }
+    buf[64] = 0;            // throw in some "special" values.
+    buf[128] = '\n';
+    buf[132] = '\r';
+    buf[256] = 0x7;
+    BufferBinaryGenerator pattern(buf, sizeof(buf));
+    RepeatedBinaryGenerator image(pattern, max_binary_length);
+    binaryTransferTest("maxlength", image, nif, 0, testArgs);
+}
+
+TEST(test_max_length_serial)
+{
+    base_test_max_length(NOTECARD_IF_SERIAL, validate);
+}
+
+TEST(test_max_length_i2c)
+{
+    base_test_max_length(NOTECARD_IF_I2C, validate);
+}
+
+TEST(test_max_length_aux_serial)
+{
+    set_aux_serial_baudrate();
+    base_test_max_length(NOTECARD_IF_AUX_SERIAL, validate);
+}
+
+#define RUN_AUX_SERIAL_ALL_SIZES(imagename, image, baudrate, ...) \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 1*1024, 1k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 2*1024, 2k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 4*1024, 4k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 8*1024, 8k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 16*1024, 16k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 40*1024, 40k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 80*1024, 80k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 120*1024, 120k, baudrate, __VA_ARGS__); \
+    RUN_AUX_SERIAL_BAUDRATE(imagename, image, 160*1024, 160k, baudrate, __VA_ARGS__);
+
+// These tests are intended to be fast-executing, and test the essential functionality.
+#define RUN_SMOKE_TESTS(interface, interfacename) \
+    { /* validate the received data using a variety of chunk sizes. */ \
+        RUN_SIZE(Random_2345, BuildRandom, interface, interfacename, 50*1026, 50k, validate_in_chunks, 2345); \
+    } \
+    {  /* maximum card.binary size is 1k, transferring 5k total, with chunked web.post on each binary buffer */ \
+        BinaryTestArgs max10k_webpost = BinaryTestArgs().maxCardBinary(1*1023).handler(BinaryTestArgs::WEB_POST_UNCHUNKED); \
+        RUN_SIZE(Random_1234, BuildRandom, interface, interfacename, 5*1026, 5k, max10k_webpost, 1234); \
+    } \
+    { /* maximum card.binary size is 1k, transferring 5k total, with chunked web.post on each binary buffer */ \
+        BinaryTestArgs max10k_webpost_chunked = BinaryTestArgs().maxCardBinary(1*1023).handler(BinaryTestArgs::WEB_POST_CHUNKED); \
+        RUN_SIZE(Random_1234, BuildRandom, interface, interfacename, 5*1026, 5k, max10k_webpost_chunked, 1234); \
+    }
+
+void waitForNotecardConnected()
+{
+    // TODO: waitForNotecardConnected takes timeout in milliseconds, so 5*60 seems wrong?
+    TEST_ASSERT_TRUE_MESSAGE(NotecardBinary::waitForNotecardConnected(NOT_CONNECTED_TIMEOUT), "Notecard not connected");
+}
+
+/**
+ * @brief Runs the card.binary test suite.
+ *
+ */
+void testsuite_card_binary()
+{
+    TEST_SUITE(card_binary);
+
+    // initialize max_binary_length for the max_length tests
+    RUN_FILTER(test_get_max_binary_length);
+
+    RUN_FILTER(waitForNotecardConnected);
+
+    // TODO: This test doesn't work with a note.add because it'll try to do a web.get to validate and find nothing there.
+    // {
+    //     BinaryTestArgs max1k_note_add = BinaryTestArgs().maxCardBinary(1*1023).handler(BinaryTestArgs::NOTE_ADD);
+    //     RUN_SIZE(Random_1234, BuildRandom, NOTECARD_IF_I2C, i2c, 5*1026, 5k, max1k_note_add, 1234);
+    // }
+
+    RUN_SMOKE_TESTS(NOTECARD_IF_I2C, i2c);
+    set_aux_serial_baudrate();
+    RUN_SMOKE_TESTS(NOTECARD_IF_AUX_SERIAL, auxserial);
+    RUN_SMOKE_TESTS(NOTECARD_IF_SERIAL, serial);
+
+//    RUN_AUX_SERIAL_ALL_BAUDRATES(all_sevens, AllSevens, TINY_SIZE, TINY_SIZE_NAME);
+//    RUN_AUX_SERIAL_ALL_BAUDRATES(all_sevens, AllSevens, 4*1024, 4k);
+
+    //RUN_SIZE(all_ones, BuildAllSameValue, NOTECARD_IF_SERIAL, serial, 6*1024, 6k, 1);
+
+#if 0
+    RUN_ALL_SIZES_ALL_IFACES(all_sevens, AllSevens);
+
+    RUN_ALL_SIZES_ALL_IFACES(random_1234, BuildRandom, 1234);
+    RUN_ALL_SIZES_ALL_IFACES(all_zeros, AllZeros);
+    RUN_ALL_SIZES_ALL_IFACES(72k_binary, SmallBinaryImage);
+#endif
+
+    RUN_FILTER(test_max_length_i2c);
+    RUN_FILTER(test_max_length_aux_serial);
+    RUN_FILTER(test_max_length_serial);
+}
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/test_card_binary.h b/src/note-c/test/hitl/card.binary/test/test_card_binary.h
new file mode 100644
index 0000000..fb5d95e
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_card_binary.h
@@ -0,0 +1,4 @@
+
+void testsuite_card_binary();
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/test_main.cpp b/src/note-c/test/hitl/card.binary/test/test_main.cpp
new file mode 100644
index 0000000..f003538
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_main.cpp
@@ -0,0 +1,39 @@
+
+#include "test_card_binary.h"
+#include "test_binary_generators.h"
+#include "test_unity_util.h"
+#include <Arduino.h>
+
+
+int runUnityTests(void)
+{
+    UNITY_BEGIN();
+    testsuite_binary_generators();
+    testsuite_card_binary();
+    delay(1000);        // sometimes the device drops the serial connection too quickly
+    return UNITY_END();
+}
+
+/**
+  * For Arduino framework
+  */
+void setup()
+{
+    Serial.begin();
+    while (!Serial);  // wait for connection
+    runUnityTests();
+}
+
+void loop()
+{
+    // ideally would sleep here
+    // or allow the tests to be rerun without reset, but Serial reports a connection when there isn't one.
+    // Tried adding Serial.end() but no help.
+    delay(60*1000);
+}
+
+// #if SERIAL_RX_BUFFER_SIZE!=16384
+//  #error serial buffer is too small
+// #endif
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/test_unity_util.cpp b/src/note-c/test/hitl/card.binary/test/test_unity_util.cpp
new file mode 100644
index 0000000..145ea8c
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_unity_util.cpp
@@ -0,0 +1,37 @@
+
+#include "test_unity_util.h"
+#include <string.h>
+
+test_suite_hook_fn test_suite_setup, test_suite_teardown;
+test_suite_filter_fn test_suite_filter;
+
+void test_suite_hooks(test_suite_hook_fn setup, test_suite_hook_fn teardown, test_suite_filter_fn filter)
+{
+    test_suite_setup = setup;
+    test_suite_teardown = teardown;
+    test_suite_filter = filter;
+}
+
+void setUp()
+{
+    if (test_suite_setup) {
+        test_suite_setup();
+    }
+}
+
+void tearDown()
+{
+    if (test_suite_teardown) {
+        test_suite_teardown();
+    }
+}
+
+bool filterTest(const char* name)
+{
+    if (test_suite_filter) {
+        return test_suite_filter(name);
+    }
+    return true;
+}
+
+
diff --git a/src/note-c/test/hitl/card.binary/test/test_unity_util.h b/src/note-c/test/hitl/card.binary/test/test_unity_util.h
new file mode 100644
index 0000000..d547a06
--- /dev/null
+++ b/src/note-c/test/hitl/card.binary/test/test_unity_util.h
@@ -0,0 +1,34 @@
+
+// This also needs to be added to build_flags in platformio.ini
+#ifndef UNITY_INCLUDE_PRINT_FORMATTED
+#define UNITY_INCLUDE_PRINT_FORMATTED
+#endif
+
+#include "unity.h"
+
+// Use this macro to declare the test functions as static, so the compiler generates a warning/error
+// If we forget to add it to the list of tests.
+#define TEST(x) static void x()
+
+typedef void (*test_suite_hook_fn)(void);
+typedef bool (*test_suite_filter_fn)(const char* name);
+
+void test_suite_hooks(test_suite_hook_fn setup, test_suite_hook_fn teardown, test_suite_filter_fn filter);
+
+// Update the current filename so reports point to the correct source location.
+#define TEST_SUITE(name) \
+    Unity.TestFile = __FILE__; \
+    extern void testsuite_ ## name ## _setUp(void); \
+    extern void testsuite_ ## name ## _tearDown(void); \
+    test_suite_hooks(testsuite_ ## name ## _setUp, \
+        testsuite_ ## name ## _tearDown, \
+        testsuite_ ## name ## _filter);
+
+extern bool filterTest(const char* name);
+
+#define RUN_FILTER(func) \
+    if (filterTest(#func)) { \
+        RUN_TEST(func); \
+    }
+
+
diff --git a/src/note-c/test/hitl/scripts/md5srv.bats b/src/note-c/test/hitl/scripts/md5srv.bats
new file mode 100644
index 0000000..7ff8530
--- /dev/null
+++ b/src/note-c/test/hitl/scripts/md5srv.bats
@@ -0,0 +1,260 @@
+export test_dir=test_files
+export nonexist_dir=doesnotexist
+export token=abc
+export invalid_token=def
+export port=8123
+export address=0.0.0.0
+export md5url=http://$address:$port
+export venv=../../../venv
+export startTimeout=${MD5SRV_TIMEOUT:-3}
+export clean_test_dir=true
+
+bats_require_minimum_version 1.10.0
+
+# NB: on OSX, export BATS_LIB_PATH=/usr/local/lib
+bats_load_library "bats-support"
+bats_load_library "bats-assert"
+
+assert [ -n "$address" ]
+assert [ -n "$port" ]
+assert [ -n "$md5url" ]
+assert [ -n "$token" ]
+
+# don't want these environment variables defined as these interfere with the tests
+assert [ -z "$MD5SRV_PORT" ]
+assert [ -z "$MD5SRV_ADDRESS" ]
+assert [ -z "$MD5SRV_TOKEN" ]
+
+# The -f curl flag is used to distinguish between a communication error and a http server error
+
+function teardown() {
+    stopMD5Server
+}
+
+
+function cleanTestDir() {
+    ! $clean_test_dir || rm -rf $test_dir
+    [ -d $test_dir ] || mkdir $test_dir
+}
+
+function _waitForMD5Server() {
+    # even though a 4xx error is returned, curl will return a success response if it contacts the webserver
+    result=500
+    until [ $result -lt 500 ]; do
+        sleep 0.1
+        result=`curl -s $md5url -o /dev/null -w "%{http_code}"`
+    done
+}
+
+function waitForMD5ServerWithTimeout() {
+    export -f _waitForMD5Server
+    export address=${1:-$address}
+    export port=${2:-$port}
+    export md5url=http://$address:$port
+    timeout $startTimeout bash -c "_waitForMD5Server"
+}
+
+function startMD5Server() {
+    cleanTestDir
+    refute curl -s $md5url     # ensure the server is not already running
+    python3 md5srv.py --dir $test_dir --token $token --save --address $address --port $port 3>&- &
+    export md5_pid=$!
+    waitForMD5ServerWithTimeout
+}
+
+function stopMD5Server() {
+    pid=${1:-$md5_pid}
+    unset md5_pid
+    [ -z "$pid" ] || kill $pid
+}
+
+function assert_json() {
+    assert_equal $(jq -r ".$1"  <<< "$output") $2
+}
+
+@test "Should not fail when the target directory does not exist and --save is not present" {
+    python3 md5srv.py --dir $nonexist_dir --address $address --port $port &
+    md5_pid=$!
+    waitForMD5ServerWithTimeout
+    run curl -s -f -X PUT $md5url/t1 -d abc
+    stopMD5Server
+    assert_success
+    assert_json md5 900150983cd24fb0d6963f7d28e17f72
+    assert_json length 3
+}
+
+@test "Fails when the target directory does not exist and --save is present" {
+    run timeout $startTimeout python3 md5srv.py --dir $nonexist_dir --token $token --save --port $port
+    assert_output --partial "not exist"
+}
+
+@test "Should not save files without an access token" {
+    cleanTestDir
+    run timeout $startTimeout python3 md5srv.py --dir $test_dir --save --port $port
+    assert_output --partial "Token must be provided"
+}
+
+@test "Can be run with default arguments" {
+    # Note that this runs the server on the default address and port, which may not be the same
+    # as the primary address and port used
+    python3 md5srv.py &
+    waitForMD5ServerWithTimeout "0.0.0.0" "8080"
+    run timeout 5 curl -s -f -X PUT http://0.0.0.0:8080/t1 -d abc
+    kill $!
+    assert_success
+}
+
+@test "Can be run with default arguments taking default values from the environment" {
+    # scope setting the environment variables. I thought they would not live beyond the
+    # test but they seem to affect later tests without scoping.
+    function scopeed() {
+        ND5SRV_PORT=8234
+        MD5SRV_TOKEN=1234
+        ND5SRV_ADDRESS=127.0.0.1
+        python3 md5srv.py &
+        pid=$!
+        waitForMD5ServerWithTimeout "$MD5SRV_ADDRESS" "$MD5SRV_PORT"
+        run timeout 5 curl -s -f -X PUT http://0.0.0.0:8080/default-args-env -d abc -H "X-Access-Token: $MD5SRV_TOKEN"
+        kill $pid
+        assert_success
+    }
+    $scoped
+}
+
+
+@test "Should allow web.put without --save no file is created" {
+    cleanTestDir
+    refute curl -s $md5url
+    python3 md5srv.py --dir $test_dir --address $address --port $port 3>&- &
+    md5_pid=$!
+    waitForMD5ServerWithTimeout
+    run curl -s -X PUT $md5url/t1 -d abc
+
+    assert_success
+    assert_json md5 900150983cd24fb0d6963f7d28e17f72
+    assert_json length 3
+    assert [ ! -e $test_dir/payload.bin ]
+}
+
+@test "web.put with no access token should fail with 401 Unauthorized" {
+    startMD5Server
+    # get just the http code
+    http_code=`curl -s -o /dev/null -w "%{http_code}" -X PUT $md5url/noaccess?chunk=0 -d abc`
+    assert_equal "$http_code" "401"
+
+    run curl -s -X PUT $md5url/noaccess?chunk=0 -d abc
+    stopMD5Server
+    assert_success
+    assert_json err Unauthorized
+}
+
+@test "web.put with invalid access token should fail with 403 Forbidden" {
+    startMD5Server
+
+    # get just the http code
+    http_code=`curl -s -o /dev/null -w "%{http_code}"  -X PUT -H "X-Access-Token: $invalid_token" $md5url/invalid?chunk=0 -d abc`
+    assert_equal "$http_code" "403"
+
+    run curl -s -X PUT -H "X-Access-Token: $invalid_token" $md5url/invalid?chunk=0 -d abc
+    stopMD5Server
+    assert_success
+    assert_json err "Forbidden"
+}
+
+@test "non-chunked web.put and web.get with saved data should return the md5 and length" {
+    startMD5Server
+    curl -v -s -f -H "X-Access-Token: $token" -X PUT $md5url/nonchunked -d abc
+    run curl -s -f -H "X-Access-Token: $token" -X GET $md5url/nonchunked
+    stopMD5Server
+    assert_success
+    assert_json md5 900150983cd24fb0d6963f7d28e17f72
+    assert_json length 3
+    assert [ -d $test_dir/nonchunked ]
+    assert [ -f $test_dir/nonchunked/payload.bin ]
+}
+
+@test "chunked web.put and web.get with saved data should return the md5 and length of all chunks" {
+    startMD5Server
+    curl -s -f -H "X-Access-Token: $token" -X PUT $md5url/chunked?chunk=0 -d abc
+    curl -s -f -H "X-Access-Token: $token" -X PUT $md5url/chunked?chunk=1 -d def
+    run curl -s -f -H "X-Access-Token: $token" -X GET $md5url/chunked
+    stopMD5Server
+    assert_success
+    assert_json md5 e80b5017098950fc58aad83c8c14978e
+    assert_json length 6
+    assert [ -d $test_dir/chunked ]
+    assert [ -f $test_dir/chunked/payload00000.bin ]
+    assert [ -f $test_dir/chunked/payload00001.bin ]
+}
+
+@test "non-chunked web.put repeats should fail when the file already exists" {
+    startMD5Server
+    run curl -s -f -H "X-Access-Token: $token" -X PUT $md5url/nonchunked-fail -d abc
+    stopMD5Server   # ensures the server is stopped before assertions exit the test
+    assert_success
+    assert_json md5 900150983cd24fb0d6963f7d28e17f72
+    assert [ -f $test_dir/nonchunked-fail/payload.bin ]
+
+    clean_test_dir=false
+    startMD5Server
+    assert [ -f $test_dir/nonchunked-fail/payload.bin ]
+    run curl -s --fail-with-body -H "X-Access-Token: $token" -X PUT $md5url/nonchunked-fail -d abc
+    stopMD5Server
+    assert_failure
+    assert_output --partial "already exists"
+    assert_json code 409
+}
+
+@test "chunked web.put repeats should fail when the file already exists" {
+    startMD5Server
+    run curl -s -f -H "X-Access-Token: $token" -X PUT $md5url/nonchunked-fail?chunk=0 -d abc
+    stopMD5Server   # ensures the server is stopped before assertions exit the test
+    assert_success
+    assert_json md5 900150983cd24fb0d6963f7d28e17f72
+    assert [ -f $test_dir/nonchunked-fail/payload00000.bin ]
+
+    export clean_test_dir=false
+    startMD5Server
+    assert [ -f $test_dir/nonchunked-fail/payload00000.bin ]
+    run curl -s --fail-with-body -H "X-Access-Token: $token" -X PUT $md5url/nonchunked-fail?chunk=0 -d abc
+    stopMD5Server
+    assert_failure
+    assert_output --partial "already exists"
+    assert_json code 409
+}
+
+@test "Can post a note which is decoded and the payload saved to the server" {
+    assert [ -e "note.json" ]
+    startMD5Server
+    run curl -s -X POST $md5url/addnote?note=1 -d "@note.json" -H "X-Access-Token: $token" -H "Content-Type: application/json"
+    stopMD5Server
+    assert_success
+    assert_json md5 f54095bd47b357cbd57ace4b4da76eaa
+    assert_json length 10230
+    assert [ -e $test_dir/Random_1234/payload.bin ]
+}
+
+@test "Can post a chunk and then retrieve it" {
+    assert [ -z "$MD5SRV_PORT" ]
+    startMD5Server
+    content=abcdef
+    content_length=6
+    timeout 5 curl -s -X POST $md5url/getchunk?chunk=0 -d "$content" -H "X-Access-Token: $token"
+    run timeout 5 curl -s -X GET -D headers.txt $md5url/getchunk?chunk=0 -d "$content" -H "X-Access-Token: $token"
+    stopMD5Server
+
+    assert_success
+    assert_output "${content}"
+    assert [ -e $test_dir/getchunk/payload00000.bin ]
+    assert [ -e headers.txt ]
+
+    run bash -c 'cat headers.txt | grep "Content-Type" | xargs'
+    assert_success
+    assert_output --partial "Content-Type: application/octet-stream"
+
+    run bash -c 'cat headers.txt | grep "Content-Length" | xargs'
+    assert_success
+    assert_output --partial "Content-Length: $content_length"
+
+    rm headers.txt
+}
diff --git a/src/note-c/test/hitl/scripts/md5srv.py b/src/note-c/test/hitl/scripts/md5srv.py
new file mode 100755
index 0000000..43340d4
--- /dev/null
+++ b/src/note-c/test/hitl/scripts/md5srv.py
@@ -0,0 +1,318 @@
+import traceback
+import shutil
+import hashlib
+import os
+import json
+import base64
+import argparse
+from functools import cached_property
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qsl, urlparse
+
+
+def log(s: str):
+    print(s, flush=True)
+
+
+log_sensitive_enabled = False
+
+
+def log_sensitive(s: str):
+    if log_sensitive_enabled:
+        log(s)
+
+
+class HTTPException(Exception):
+    def __init__(self, status_code, message, detail=None):
+        self.status_code = status_code
+        self.message = message
+        self.detail = detail
+
+
+class WebRequestHandler(BaseHTTPRequestHandler):
+    """
+    GET: retrieves the total length and md5 of all chunks in a directory denoted by the URL path. The URL path
+      is interpreted relative to the serving directory.
+    If the query parameter "note" is present, the request body is parsed as JSON and the payload saved to 
+    a file using the `chunk` event body property.
+    POST/PUT: saves the body to a file, with an optional `chunk` query parameter for writing one or more chunks. 
+    If no chunk number is given, the file `payload.bin` is written to the directory. Otherwise payloadXXXXX.bin is written
+    where XXXXX is the zero-padded chunk number.
+    Returns a 409 (Conflict) error if the file already exists.
+
+    DELETE: deletes a directory containing one or more chunks.
+
+    Paths are fully sanitized.
+    """
+
+    def __init__(self, args, *others) -> None:
+        self.args = args
+        if self.args is None:
+            raise Exception("invalid args")
+        super().__init__(*others)
+
+    # caching properties is done on a per request basis so this is safe.
+    @cached_property
+    def url(self):
+        return urlparse(self.path)
+
+    @cached_property
+    def query_data(self):
+        return dict(parse_qsl(self.url.query))
+
+    @cached_property
+    def post_data(self):
+        content_length = int(self.headers.get("Content-Length", 0))
+        return self.rfile.read(content_length)
+
+    @cached_property
+    def form_data(self):
+        return dict(parse_qsl(self.post_data.decode("utf-8")))
+
+    def do_GET(self):
+        self.do(self.get_md5)
+
+    def do_DELETE(self):
+        self.do(self.delete_files)
+
+    def do_POST(self):
+        self.do(self.write_file_or_note)
+
+    def do_PUT(self):
+        self.do(self.write_file_or_note)
+
+    def send_status(self, code: int, message: str, detail: str | dict | bytes, headers: dict = {}):
+        """ Send a status code with a message and optional detail, which is returned as JSON in the response body. """
+        self.send_response(code, message)
+        for header in headers.items():
+            self.send_header(*header)
+        self.send_header("Content-Type", "application/json" if type(detail) is not bytes else "application/octet-stream")
+        self.end_headers()
+        detail = detail or message
+        if detail is not None:
+            if type(detail) is bytes:
+                self.wfile.write(detail)
+            else:
+                key = "err" if code > 400 else "text" if not type(detail) is dict else None
+                json_str = json.dumps(detail)
+                reply_body = json_str if key is None else f'{{"{key}":{json_str},"code":{code}}}'
+                reply_body = reply_body + '\n'
+                self.wfile.write(reply_body.encode('utf-8'))
+
+    def do(self, handler):
+        """ Handle a request. If an exception is thrown, raises an internal server error. """
+        try:
+            # print(self.dump_request())
+            self.validate_token()
+            handler()
+        except HTTPException as e:
+            self.send_status(e.status_code, e.message, e.detail)
+        except Exception as e:
+            traceback.print_exc()
+            self.send_status(500, "Internal server error.", str(e))
+
+    def validate_token(self):
+        requested = self.headers['X-Access-Token'] or ''
+        token = self.args.token or ''
+        if token and requested != token:
+            raise HTTPException(403, "Forbidden") if requested else HTTPException(401, "Unauthorized")
+
+    def get_md5(self):
+        dirname = self.validate_url_path(self.url.path)
+        if not os.path.exists(dirname):
+            raise HTTPException(404, "Not Found", f"Directory {self.url.path} not found.")
+
+        chunk = self.query_data.get('chunk')
+        headers = {}
+        if chunk is None:
+            response = self.md5_for_directory(dirname)
+        else:
+            response = self.chunk_content(dirname, chunk)
+            headers = {"Content-Length": len(response)}
+        self.send_status(200, "ok", response, headers)
+
+    def chunk_content(self, dirname, chunk):
+        return self._read_file(dirname, chunk)
+
+    def md5_for_directory(self, dirname):
+        files = os.listdir(dirname)
+        files.sort()
+
+        md5context = hashlib.md5()
+        length = 0
+        for filename in files:
+            abs_filename = os.path.join(dirname, filename)
+            self.validate_path(abs_filename)
+            if not os.path.isfile(abs_filename):
+                raise HTTPException(403, "Not a file.", f"{os.path.join(self.url.path,filename)} is not a file")
+
+            with open(abs_filename, 'rb') as file:
+                data = file.read()
+                length = length + len(data)
+                md5context.update(data)
+
+        md5str = md5context.hexdigest()
+        response = {"md5": md5str, "length": length, "chunks": len(files)}
+        return response
+
+    def delete_files(self):
+        dirname = self.validate_url_path(self.url.path)
+        if os.path.exists(dirname):
+            log(f"deleting {self.url.path}")
+            shutil.rmtree(dirname)
+        self.send_status(200, "Ok", f"Deleted {self.url.path}")
+
+    def write_file_or_note(self):
+        if self.query_data.get('note') is not None:
+            self.do(self.write_note)
+        else:
+            self.do(self.write_file)
+
+    def write_note(self):
+        content_type = self.headers['Content-Type']
+        if content_type != 'application/json':
+            raise HTTPException(400, f"Unsupported content type: {content_type}")
+        data = self.post_data
+        try:
+            event = json.loads(data)
+        except json.decoder.JSONDecodeError as e:
+            print(f"JSON decode error: {data} {e}")
+            raise e
+        body = event['body']     # non-optional keys
+        name = body['name']
+        length = body['length']
+        md5 = body['md5']
+        # todo - could check the offset
+        payload = base64.b64decode(event['payload'])
+        payload_length = event.get('payload_length')
+        if payload_length is not None and payload_length != length:
+            raise HTTPException(400, "Payload length mismatch", f"payload_length {payload_length}!=length {length}")
+        chunk = body.get('chunk') # optional
+        self._write_file(name, chunk, length, payload, md5)
+
+    def write_file(self):
+        length = int(self.headers['Content-Length'])
+        if not length:
+            raise HTTPException(400, "Request body is empty.")
+        chunk = self.query_data.get("chunk", None)
+        return self._write_file(self.url.path, chunk, length, self.post_data, None)
+
+    def _read_file(self, path, chunk):
+        filename = self._chunk_file(path, chunk)
+        if not os.path.exists(filename):
+            raise HTTPException(404, 'Not found')
+        with open(filename, 'rb') as output_file:
+            data = output_file.read()
+        return data
+
+    def _chunk_file(self, dirname, chunk):
+        chunk_index = None if chunk is None else int(chunk)
+        filename = os.path.join(dirname, f"payload{chunk_index:05d}.bin" if chunk_index is not None else "payload.bin")
+        self.validate_path(filename)
+        return filename
+
+    def _write_file(self, path, chunk, length, data, md5):
+        """ Write the request body to a file and returns the MD5 """
+        dirname = self.validate_url_path(path)
+        if self.args.save:
+            if not os.path.exists(dirname):
+                log_sensitive(f"Creating directory {dirname}")
+                log(f"creating directory {path}")
+                os.makedirs(dirname)
+
+            filename = self._chunk_file(dirname, chunk)
+            if os.path.exists(filename):
+                raise HTTPException(409, "Conflict", f"Chunk {chunk} already exists for {self.url.path}"
+                                    if chunk else f"File {self.url.path} already exists.")
+
+        if len(data) != length:
+            raise HTTPException(400, "Invalid content length.",
+                                f"Payload length does not equal given length {len(data)}!={length}")
+
+        if self.args.save:
+            with open(filename, 'wb') as output_file:
+                output_file.write(data)
+        md5str = hashlib.md5(data).hexdigest()
+        if md5 and md5str != md5:
+            raise HTTPException(400, f"MD5 mismatch. actual {md5str}!=expected {md5}")
+        response = {"md5": md5str, "length": length}
+        content_type = self.headers['Content-Type']
+        if content_type is not None:
+            response['Content-Type'] = content_type
+        self.send_status(200, "Ok", response)
+
+    def validate_url_path(self, urlpath):
+        return self.validate_path(os.path.join(self.args.directory, urlpath.lstrip('/')))
+
+    def validate_path(self, path):
+        abs_path = os.path.realpath(os.path.abspath(path))
+        common = os.path.commonpath((abs_path, self.args.directory))
+        if common != self.args.directory:
+            raise HTTPException(401, "Denied", "Take a hike.")
+        return abs_path
+
+    def dump_request(self) -> str:
+        return json.dumps(
+            {
+                "path": self.url.path,
+                "query_data": self.query_data,
+                "post_data": self.post_data.decode("utf-8"),
+                "form_data": self.form_data
+            }
+        )
+
+
+def main(args):
+    if args.save and not args.token:
+        raise Exception("Token must be provided when files are saved.")
+
+    if args.save and not os.path.exists(args.directory):
+        raise OSError("Directory does not exist.")
+
+    log(f'Serving directory {args.directory} at {args.address}:{args.port}')
+
+    def build_request_handler(*request_args):
+        return WebRequestHandler(args, *request_args)
+
+    server = HTTPServer((args.address, int(args.port)), build_request_handler)
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    port = os.environ.get("MD5SRV_PORT")
+    address = os.environ.get("MD5SRV_ADDRESS")
+    token = os.environ.get("MD5SRV_TOKEN")
+
+    parser = argparse.ArgumentParser(
+        description='Run a simple webserver to save and validate web.post requests.')
+    parser.add_argument(
+        '--port',
+        default=port or "8080",
+        required=False,
+        help='The TCP port to bind to.')
+    parser.add_argument('--address',
+                        default=address or "0.0.0.0",
+                        required=False,
+                        help='The IP address to bind to.')
+    parser.add_argument('--dir',
+                        dest="directory",
+                        required=False,
+                        help='The working directory. All files are stored and retrieved from here.')
+    # parser.add_argument('--timeout',
+    #                     default=5,
+    #                     required=False,
+    #                     help='Set the request timeout.')
+    parser.add_argument('--save',
+                        default=False,
+                        required=False,
+                        action='store_true',
+                        help='Save the content received to the filesystem.')
+    parser.add_argument('--token',
+                        default=None,
+                        required=False,
+                        help='The authorization token required in X-Access-Token header.')
+
+    args = parser.parse_args()
+    args.token = args.token or token
+    args.directory = os.getcwd() if not args.directory else os.path.abspath(args.directory)
+    main(args)
diff --git a/src/note-c/test/hitl/scripts/note.json b/src/note-c/test/hitl/scripts/note.json
new file mode 100644
index 0000000..b7cc104
--- /dev/null
+++ b/src/note-c/test/hitl/scripts/note.json
@@ -0,0 +1,37 @@
+{
+    "event": "0235b92a-b61a-4c40-8255-174e1b88777b",
+    "session": "ae49d814-c654-4d5f-a1f5-0601dce42514",
+    "best_id": "dev:867730051643363",
+    "device": "dev:867730051643363",
+    "product": "product:com.blues.mat:test",
+    "app": "app:76193b20-9ab4-4099-91a7-8c449382160f",
+    "received": 1693956822.370742,
+    "req": "note.add",
+    "when": 1693956814,
+    "file": "cardbinary.qo",
+    "body": {
+        "length": 10230,
+        "md5": "f54095bd47b357cbd57ace4b4da76eaa",
+        "name": "Random_1234",
+        "offset": 0,
+        "total": 10230
+    },
+    "payload": "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",
+    "best_location_type": "tower",
+    "best_location_when": 1693956805,
+    "best_lat": 38.3676875,
+    "best_lon": -122.678265625,
+    "best_location": "Rohnert Park CA",
+    "best_country": "US",
+    "best_timezone": "America/Los_Angeles",
+    "tower_when": 1693956805,
+    "tower_lat": 38.3676875,
+    "tower_lon": -122.678265625,
+    "tower_country": "US",
+    "tower_location": "Rohnert Park CA",
+    "tower_timezone": "America/Los_Angeles",
+    "tower_id": "310,410,35651,169102351",
+    "fleets": [
+        "fleet:0c730eb5-23ea-4921-b592-0a8db7376905"
+    ]
+}
\ No newline at end of file
diff --git a/src/note-c/test/include/fff.h b/src/note-c/test/include/fff.h
new file mode 100644
index 0000000..d60f788
--- /dev/null
+++ b/src/note-c/test/include/fff.h
@@ -0,0 +1,6649 @@
+/*
+LICENSE
+
+The MIT License (MIT)
+
+Copyright (c) 2010 Michael Long
+
+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
+AUTHORS OR COPYRIGHT HOLDERS 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.
+*/
+#ifndef FAKE_FUNCTIONS
+#define FAKE_FUNCTIONS
+
+#include <stdarg.h>
+#include <string.h> /* For memset and memcpy */
+
+#define FFF_MAX_ARGS (20u)
+#ifndef FFF_ARG_HISTORY_LEN
+    #define FFF_ARG_HISTORY_LEN (50u)
+#endif
+#ifndef FFF_CALL_HISTORY_LEN
+    #define FFF_CALL_HISTORY_LEN (50u)
+#endif
+#ifndef FFF_GCC_FUNCTION_ATTRIBUTES
+    #define FFF_GCC_FUNCTION_ATTRIBUTES
+#endif
+#ifndef CUSTOM_FFF_FUNCTION_TEMPLATE
+#define CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN, FUNCNAME, ...) \
+    RETURN(*FUNCNAME)(__VA_ARGS__)
+#endif /* CUSTOM_FFF_FUNCTION_TEMPLATE */
+/* -- INTERNAL HELPER MACROS -- */
+#define SET_RETURN_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \
+    FUNCNAME##_fake.return_val_seq = ARRAY_POINTER; \
+    FUNCNAME##_fake.return_val_seq_len = ARRAY_LEN;
+#define SET_CUSTOM_FAKE_SEQ(FUNCNAME, ARRAY_POINTER, ARRAY_LEN) \
+    FUNCNAME##_fake.custom_fake_seq = ARRAY_POINTER; \
+    FUNCNAME##_fake.custom_fake_seq_len = ARRAY_LEN;
+
+/* Defining a function to reset a fake function */
+#define RESET_FAKE(FUNCNAME) { \
+    FUNCNAME##_reset(); \
+} \
+
+
+#define DECLARE_ARG(type, n, FUNCNAME) \
+    type arg##n##_val; \
+    type arg##n##_history[FFF_ARG_HISTORY_LEN];
+
+#define DECLARE_ALL_FUNC_COMMON \
+    unsigned int call_count; \
+    unsigned int arg_history_len; \
+    unsigned int arg_histories_dropped; \
+
+#define DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+    RETURN_TYPE return_val_history[FFF_ARG_HISTORY_LEN];
+
+#define SAVE_ARG(FUNCNAME, n) \
+    memcpy((void*)&FUNCNAME##_fake.arg##n##_val, (void*)&arg##n, sizeof(arg##n));
+
+#define ROOM_FOR_MORE_HISTORY(FUNCNAME) \
+    FUNCNAME##_fake.call_count < FFF_ARG_HISTORY_LEN
+
+#define SAVE_RET_HISTORY(FUNCNAME, RETVAL) \
+    if ((FUNCNAME##_fake.call_count - 1) < FFF_ARG_HISTORY_LEN) \
+        memcpy((void *)&FUNCNAME##_fake.return_val_history[FUNCNAME##_fake.call_count - 1], (const void *) &RETVAL, sizeof(RETVAL)); \
+
+#define SAVE_ARG_HISTORY(FUNCNAME, ARGN) \
+    memcpy((void*)&FUNCNAME##_fake.arg##ARGN##_history[FUNCNAME##_fake.call_count], (void*)&arg##ARGN, sizeof(arg##ARGN));
+
+#define HISTORY_DROPPED(FUNCNAME) \
+    FUNCNAME##_fake.arg_histories_dropped++
+
+#define DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+    RETURN_TYPE return_val; \
+    int return_val_seq_len; \
+    int return_val_seq_idx; \
+    RETURN_TYPE * return_val_seq; \
+
+#define DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+    int custom_fake_seq_len; \
+    int custom_fake_seq_idx; \
+
+#define INCREMENT_CALL_COUNT(FUNCNAME) \
+    FUNCNAME##_fake.call_count++
+
+#define RETURN_FAKE_RESULT(FUNCNAME) \
+    if (FUNCNAME##_fake.return_val_seq_len){ /* then its a sequence */ \
+        if(FUNCNAME##_fake.return_val_seq_idx < FUNCNAME##_fake.return_val_seq_len) { \
+            SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx]) \
+            return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_idx++]; \
+        } \
+        SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]) \
+        return FUNCNAME##_fake.return_val_seq[FUNCNAME##_fake.return_val_seq_len-1]; /* return last element */ \
+    } \
+    SAVE_RET_HISTORY(FUNCNAME, FUNCNAME##_fake.return_val) \
+    return FUNCNAME##_fake.return_val; \
+
+#ifdef __cplusplus
+    #define FFF_EXTERN_C extern "C"{
+    #define FFF_END_EXTERN_C } 
+#else  /* ansi c */
+    #define FFF_EXTERN_C 
+    #define FFF_END_EXTERN_C 
+#endif  /* cpp/ansi c */
+
+#define DEFINE_RESET_FUNCTION(FUNCNAME) \
+    void FUNCNAME##_reset(void){ \
+        memset((void*)&FUNCNAME##_fake, 0, sizeof(FUNCNAME##_fake) - sizeof(FUNCNAME##_fake.custom_fake) - sizeof(FUNCNAME##_fake.custom_fake_seq)); \
+        FUNCNAME##_fake.custom_fake = NULL; \
+        FUNCNAME##_fake.custom_fake_seq = NULL; \
+        FUNCNAME##_fake.arg_history_len = FFF_ARG_HISTORY_LEN; \
+    }
+/* -- END INTERNAL HELPER MACROS -- */
+
+typedef void (*fff_function_t)(void);
+typedef struct { 
+    fff_function_t call_history[FFF_CALL_HISTORY_LEN];
+    unsigned int call_history_idx;
+} fff_globals_t;
+
+FFF_EXTERN_C
+extern fff_globals_t fff;
+FFF_END_EXTERN_C
+
+#define DEFINE_FFF_GLOBALS \
+    FFF_EXTERN_C \
+        fff_globals_t fff; \
+    FFF_END_EXTERN_C
+
+#define FFF_RESET_HISTORY() \
+    fff.call_history_idx = 0; \
+    memset(fff.call_history, 0, sizeof(fff.call_history));
+
+#define REGISTER_CALL(function) \
+    if(fff.call_history_idx < FFF_CALL_HISTORY_LEN) \
+        fff.call_history[fff.call_history_idx++] = (fff_function_t)function;
+
+#define DECLARE_FAKE_VOID_FUNC0(FUNCNAME) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, void); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, void); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(void); \
+
+#define DEFINE_FAKE_VOID_FUNC0(FUNCNAME) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(void){ \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC0(FUNCNAME) \
+    DECLARE_FAKE_VOID_FUNC0(FUNCNAME) \
+    DEFINE_FAKE_VOID_FUNC0(FUNCNAME) \
+
+
+#define DECLARE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0); \
+
+#define DEFINE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \
+    DECLARE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \
+    DEFINE_FAKE_VOID_FUNC1(FUNCNAME, ARG0_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1); \
+
+#define DEFINE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    DECLARE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    DEFINE_FAKE_VOID_FUNC2(FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
+
+#define DEFINE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    DECLARE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    DEFINE_FAKE_VOID_FUNC3(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
+
+#define DEFINE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    DECLARE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    DEFINE_FAKE_VOID_FUNC4(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
+
+#define DEFINE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    DECLARE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    DEFINE_FAKE_VOID_FUNC5(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
+
+#define DEFINE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    DECLARE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    DEFINE_FAKE_VOID_FUNC6(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
+
+#define DEFINE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    DECLARE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    DEFINE_FAKE_VOID_FUNC7(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
+
+#define DEFINE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    DECLARE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    DEFINE_FAKE_VOID_FUNC8(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
+
+#define DEFINE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    DECLARE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    DEFINE_FAKE_VOID_FUNC9(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
+
+#define DEFINE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    DECLARE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    DEFINE_FAKE_VOID_FUNC10(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
+
+#define DEFINE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    DECLARE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    DEFINE_FAKE_VOID_FUNC11(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
+
+#define DEFINE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    DECLARE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    DEFINE_FAKE_VOID_FUNC12(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
+
+#define DEFINE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    DECLARE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    DEFINE_FAKE_VOID_FUNC13(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
+
+#define DEFINE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    DECLARE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    DEFINE_FAKE_VOID_FUNC14(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
+
+#define DEFINE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    DECLARE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    DEFINE_FAKE_VOID_FUNC15(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
+
+#define DEFINE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    DECLARE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    DEFINE_FAKE_VOID_FUNC16(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
+
+#define DEFINE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    DECLARE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    DEFINE_FAKE_VOID_FUNC17(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
+
+#define DEFINE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    DECLARE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    DEFINE_FAKE_VOID_FUNC18(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
+
+#define DEFINE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        SAVE_ARG(FUNCNAME, 18); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+            SAVE_ARG_HISTORY(FUNCNAME, 18); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    DECLARE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    DEFINE_FAKE_VOID_FUNC19(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \
+        DECLARE_ARG(ARG19_TYPE, 19, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
+
+#define DEFINE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        SAVE_ARG(FUNCNAME, 18); \
+        SAVE_ARG(FUNCNAME, 19); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+            SAVE_ARG_HISTORY(FUNCNAME, 18); \
+            SAVE_ARG_HISTORY(FUNCNAME, 19); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+            } \
+            else{ \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    DECLARE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    DEFINE_FAKE_VOID_FUNC20(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, void); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, void); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(void); \
+
+#define DEFINE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(void){ \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \
+    DECLARE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \
+    DEFINE_FAKE_VALUE_FUNC0(RETURN_TYPE, FUNCNAME) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0); \
+
+#define DEFINE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC1(RETURN_TYPE, FUNCNAME, ARG0_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1); \
+
+#define DEFINE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC2(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2); \
+
+#define DEFINE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC3(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3); \
+
+#define DEFINE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC4(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4); \
+
+#define DEFINE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC5(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5); \
+
+#define DEFINE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC6(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6); \
+
+#define DEFINE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC7(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7); \
+
+#define DEFINE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC8(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8); \
+
+#define DEFINE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC9(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9); \
+
+#define DEFINE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC10(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10); \
+
+#define DEFINE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC11(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11); \
+
+#define DEFINE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC12(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12); \
+
+#define DEFINE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC13(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13); \
+
+#define DEFINE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC14(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14); \
+
+#define DEFINE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC15(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15); \
+
+#define DEFINE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC16(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16); \
+
+#define DEFINE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC17(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17); \
+
+#define DEFINE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC18(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18); \
+
+#define DEFINE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        SAVE_ARG(FUNCNAME, 18); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+            SAVE_ARG_HISTORY(FUNCNAME, 18); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC19(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \
+        DECLARE_ARG(ARG19_TYPE, 19, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19); \
+
+#define DEFINE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ARG19_TYPE arg19){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        SAVE_ARG(FUNCNAME, 18); \
+        SAVE_ARG(FUNCNAME, 19); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+            SAVE_ARG_HISTORY(FUNCNAME, 18); \
+            SAVE_ARG_HISTORY(FUNCNAME, 19); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+            } \
+            else{ \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+            } \
+        } \
+        if (FUNCNAME##_fake.custom_fake != NULL){  \
+            RETURN_TYPE ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+            return FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, arg19); \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    DECLARE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+    DEFINE_FAKE_VALUE_FUNC20(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ARG19_TYPE) \
+
+
+#define DECLARE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg0); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg0); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg0); \
+            FUNCNAME##_fake.custom_fake(arg0, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC2_VARARG(FUNCNAME, ARG0_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg1); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg1); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg1); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC3_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg2); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg2); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg2); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC4_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg3); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg3); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg3); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC5_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg4); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg4); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg4); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC6_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg5); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg5); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg5); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC7_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg6); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg6); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg6); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC8_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg7); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg7); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg7); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC9_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg8); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg8); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg8); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC10_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg9); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg9); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg9); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC11_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg10); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg10); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg10); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC12_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg11); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg11); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg11); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC13_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg12); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg12); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg12); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC14_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg13); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg13); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg13); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC15_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg14); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg14); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg14); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC16_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg15); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg15); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg15); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC17_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg16); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg16); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg16); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC18_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg17); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg17); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg17); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC19_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(void, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...); \
+
+#define DEFINE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        SAVE_ARG(FUNCNAME, 18); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+            SAVE_ARG_HISTORY(FUNCNAME, 18); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg18); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+                va_end(ap); \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg18); \
+                FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+                va_end(ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            va_list ap; \
+            va_start(ap, arg18); \
+            FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+            va_end(ap); \
+        } \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    DECLARE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    DEFINE_FAKE_VOID_FUNC20_VARARG(FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg0); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg0); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg0); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC2_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg1); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg1); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg1); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC3_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg2); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg2); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg2); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC4_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg3); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg3); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg3); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC5_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg4); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg4); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg4); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC6_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg5); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg5); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg5); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC7_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg6); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg6); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg6); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC8_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg7); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg7); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg7); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC9_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg8); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg8); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg8); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC10_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg9); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg9); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg9); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC11_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg10); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg10); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg10); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC12_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg11); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg11); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg11); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC13_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg12); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg12); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg12); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC14_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg13); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg13); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg13); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC15_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg14); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg14); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg14); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC16_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg15); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg15); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg15); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC17_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg16); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg16); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg16); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC18_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg17); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg17); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg17); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC19_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ...) \
+
+
+#define DECLARE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    typedef struct FUNCNAME##_Fake { \
+        DECLARE_ARG(ARG0_TYPE, 0, FUNCNAME) \
+        DECLARE_ARG(ARG1_TYPE, 1, FUNCNAME) \
+        DECLARE_ARG(ARG2_TYPE, 2, FUNCNAME) \
+        DECLARE_ARG(ARG3_TYPE, 3, FUNCNAME) \
+        DECLARE_ARG(ARG4_TYPE, 4, FUNCNAME) \
+        DECLARE_ARG(ARG5_TYPE, 5, FUNCNAME) \
+        DECLARE_ARG(ARG6_TYPE, 6, FUNCNAME) \
+        DECLARE_ARG(ARG7_TYPE, 7, FUNCNAME) \
+        DECLARE_ARG(ARG8_TYPE, 8, FUNCNAME) \
+        DECLARE_ARG(ARG9_TYPE, 9, FUNCNAME) \
+        DECLARE_ARG(ARG10_TYPE, 10, FUNCNAME) \
+        DECLARE_ARG(ARG11_TYPE, 11, FUNCNAME) \
+        DECLARE_ARG(ARG12_TYPE, 12, FUNCNAME) \
+        DECLARE_ARG(ARG13_TYPE, 13, FUNCNAME) \
+        DECLARE_ARG(ARG14_TYPE, 14, FUNCNAME) \
+        DECLARE_ARG(ARG15_TYPE, 15, FUNCNAME) \
+        DECLARE_ARG(ARG16_TYPE, 16, FUNCNAME) \
+        DECLARE_ARG(ARG17_TYPE, 17, FUNCNAME) \
+        DECLARE_ARG(ARG18_TYPE, 18, FUNCNAME) \
+        DECLARE_ALL_FUNC_COMMON \
+        DECLARE_VALUE_FUNCTION_VARIABLES(RETURN_TYPE) \
+        DECLARE_RETURN_VALUE_HISTORY(RETURN_TYPE) \
+        DECLARE_CUSTOM_FAKE_SEQ_VARIABLES \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, custom_fake, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, va_list ap); \
+        CUSTOM_FFF_FUNCTION_TEMPLATE(RETURN_TYPE, *custom_fake_seq, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, va_list ap); \
+    } FUNCNAME##_Fake; \
+    extern FUNCNAME##_Fake FUNCNAME##_fake; \
+    void FUNCNAME##_reset(void); \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...); \
+
+#define DEFINE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    FUNCNAME##_Fake FUNCNAME##_fake; \
+    RETURN_TYPE FFF_GCC_FUNCTION_ATTRIBUTES FUNCNAME(ARG0_TYPE arg0, ARG1_TYPE arg1, ARG2_TYPE arg2, ARG3_TYPE arg3, ARG4_TYPE arg4, ARG5_TYPE arg5, ARG6_TYPE arg6, ARG7_TYPE arg7, ARG8_TYPE arg8, ARG9_TYPE arg9, ARG10_TYPE arg10, ARG11_TYPE arg11, ARG12_TYPE arg12, ARG13_TYPE arg13, ARG14_TYPE arg14, ARG15_TYPE arg15, ARG16_TYPE arg16, ARG17_TYPE arg17, ARG18_TYPE arg18, ...){ \
+        SAVE_ARG(FUNCNAME, 0); \
+        SAVE_ARG(FUNCNAME, 1); \
+        SAVE_ARG(FUNCNAME, 2); \
+        SAVE_ARG(FUNCNAME, 3); \
+        SAVE_ARG(FUNCNAME, 4); \
+        SAVE_ARG(FUNCNAME, 5); \
+        SAVE_ARG(FUNCNAME, 6); \
+        SAVE_ARG(FUNCNAME, 7); \
+        SAVE_ARG(FUNCNAME, 8); \
+        SAVE_ARG(FUNCNAME, 9); \
+        SAVE_ARG(FUNCNAME, 10); \
+        SAVE_ARG(FUNCNAME, 11); \
+        SAVE_ARG(FUNCNAME, 12); \
+        SAVE_ARG(FUNCNAME, 13); \
+        SAVE_ARG(FUNCNAME, 14); \
+        SAVE_ARG(FUNCNAME, 15); \
+        SAVE_ARG(FUNCNAME, 16); \
+        SAVE_ARG(FUNCNAME, 17); \
+        SAVE_ARG(FUNCNAME, 18); \
+        if(ROOM_FOR_MORE_HISTORY(FUNCNAME)){ \
+            SAVE_ARG_HISTORY(FUNCNAME, 0); \
+            SAVE_ARG_HISTORY(FUNCNAME, 1); \
+            SAVE_ARG_HISTORY(FUNCNAME, 2); \
+            SAVE_ARG_HISTORY(FUNCNAME, 3); \
+            SAVE_ARG_HISTORY(FUNCNAME, 4); \
+            SAVE_ARG_HISTORY(FUNCNAME, 5); \
+            SAVE_ARG_HISTORY(FUNCNAME, 6); \
+            SAVE_ARG_HISTORY(FUNCNAME, 7); \
+            SAVE_ARG_HISTORY(FUNCNAME, 8); \
+            SAVE_ARG_HISTORY(FUNCNAME, 9); \
+            SAVE_ARG_HISTORY(FUNCNAME, 10); \
+            SAVE_ARG_HISTORY(FUNCNAME, 11); \
+            SAVE_ARG_HISTORY(FUNCNAME, 12); \
+            SAVE_ARG_HISTORY(FUNCNAME, 13); \
+            SAVE_ARG_HISTORY(FUNCNAME, 14); \
+            SAVE_ARG_HISTORY(FUNCNAME, 15); \
+            SAVE_ARG_HISTORY(FUNCNAME, 16); \
+            SAVE_ARG_HISTORY(FUNCNAME, 17); \
+            SAVE_ARG_HISTORY(FUNCNAME, 18); \
+        } \
+        else{ \
+            HISTORY_DROPPED(FUNCNAME); \
+        } \
+        INCREMENT_CALL_COUNT(FUNCNAME); \
+        REGISTER_CALL(FUNCNAME); \
+        if (FUNCNAME##_fake.custom_fake_seq_len){ /* a sequence of custom fakes */ \
+            if (FUNCNAME##_fake.custom_fake_seq_idx < FUNCNAME##_fake.custom_fake_seq_len){ \
+                va_list ap; \
+                va_start(ap, arg18); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_idx++](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+            } \
+            else{ \
+                va_list ap; \
+                va_start(ap, arg18); \
+                RETURN_TYPE ret = FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+                SAVE_RET_HISTORY(FUNCNAME, ret); \
+                va_end(ap); \
+                return ret; \
+                return FUNCNAME##_fake.custom_fake_seq[FUNCNAME##_fake.custom_fake_seq_len-1](arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+            } \
+        } \
+        if(FUNCNAME##_fake.custom_fake){ \
+            RETURN_TYPE ret; \
+            va_list ap; \
+            va_start(ap, arg18); \
+            ret = FUNCNAME##_fake.custom_fake(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16, arg17, arg18, ap); \
+            va_end(ap); \
+            SAVE_RET_HISTORY(FUNCNAME, ret); \
+            return ret; \
+        } \
+        RETURN_FAKE_RESULT(FUNCNAME) \
+    } \
+    DEFINE_RESET_FUNCTION(FUNCNAME) \
+
+#define FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    DECLARE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+    DEFINE_FAKE_VALUE_FUNC20_VARARG(RETURN_TYPE, FUNCNAME, ARG0_TYPE, ARG1_TYPE, ARG2_TYPE, ARG3_TYPE, ARG4_TYPE, ARG5_TYPE, ARG6_TYPE, ARG7_TYPE, ARG8_TYPE, ARG9_TYPE, ARG10_TYPE, ARG11_TYPE, ARG12_TYPE, ARG13_TYPE, ARG14_TYPE, ARG15_TYPE, ARG16_TYPE, ARG17_TYPE, ARG18_TYPE, ...) \
+
+/* MSVC expand macro fix */
+#define EXPAND(x) x
+
+#define PP_NARG_MINUS2(...)   EXPAND(PP_NARG_MINUS2_(__VA_ARGS__, PP_RSEQ_N_MINUS2()))
+
+#define PP_NARG_MINUS2_(...)   EXPAND(PP_ARG_MINUS2_N(__VA_ARGS__))
+
+#define PP_ARG_MINUS2_N(returnVal,  _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, N, ...)   N
+
+#define PP_RSEQ_N_MINUS2()   20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+
+#define PP_NARG_MINUS1(...)   EXPAND(PP_NARG_MINUS1_(__VA_ARGS__, PP_RSEQ_N_MINUS1()))
+
+#define PP_NARG_MINUS1_(...)   EXPAND(PP_ARG_MINUS1_N(__VA_ARGS__))
+
+#define PP_ARG_MINUS1_N( _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, N, ...)   N
+
+#define PP_RSEQ_N_MINUS1()   20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
+
+
+
+/* DECLARE AND DEFINE FAKE FUNCTIONS - PLACE IN TEST FILES */
+
+#define FAKE_VALUE_FUNC(...)     EXPAND(FUNC_VALUE_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__))
+
+#define FUNC_VALUE_(N,...)     EXPAND(FUNC_VALUE_N(N,__VA_ARGS__))
+
+#define FUNC_VALUE_N(N,...)     EXPAND(FAKE_VALUE_FUNC ## N(__VA_ARGS__))
+
+
+#define FAKE_VOID_FUNC(...)     EXPAND(FUNC_VOID_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__))
+
+#define FUNC_VOID_(N,...)     EXPAND(FUNC_VOID_N(N,__VA_ARGS__))
+
+#define FUNC_VOID_N(N,...)     EXPAND(FAKE_VOID_FUNC ## N(__VA_ARGS__))
+
+
+#define FAKE_VALUE_FUNC_VARARG(...)     EXPAND(FUNC_VALUE_VARARG_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__))
+
+#define FUNC_VALUE_VARARG_(N,...)     EXPAND(FUNC_VALUE_VARARG_N(N,__VA_ARGS__))
+
+#define FUNC_VALUE_VARARG_N(N,...)     EXPAND(FAKE_VALUE_FUNC ## N ## _VARARG(__VA_ARGS__))
+
+
+#define FAKE_VOID_FUNC_VARARG(...)     EXPAND(FUNC_VOID_VARARG_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__))
+
+#define FUNC_VOID_VARARG_(N,...)     EXPAND(FUNC_VOID_VARARG_N(N,__VA_ARGS__))
+
+#define FUNC_VOID_VARARG_N(N,...)     EXPAND(FAKE_VOID_FUNC ## N ## _VARARG(__VA_ARGS__))
+
+
+
+/* DECLARE FAKE FUNCTIONS - PLACE IN HEADER FILES */
+
+#define DECLARE_FAKE_VALUE_FUNC(...)     EXPAND(DECLARE_FUNC_VALUE_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__))
+
+#define DECLARE_FUNC_VALUE_(N,...)     EXPAND(DECLARE_FUNC_VALUE_N(N,__VA_ARGS__))
+
+#define DECLARE_FUNC_VALUE_N(N,...)     EXPAND(DECLARE_FAKE_VALUE_FUNC ## N(__VA_ARGS__))
+
+
+#define DECLARE_FAKE_VOID_FUNC(...)     EXPAND(DECLARE_FUNC_VOID_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__))
+
+#define DECLARE_FUNC_VOID_(N,...)     EXPAND(DECLARE_FUNC_VOID_N(N,__VA_ARGS__))
+
+#define DECLARE_FUNC_VOID_N(N,...)     EXPAND(DECLARE_FAKE_VOID_FUNC ## N(__VA_ARGS__))
+
+
+#define DECLARE_FAKE_VALUE_FUNC_VARARG(...)     EXPAND(DECLARE_FUNC_VALUE_VARARG_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__))
+
+#define DECLARE_FUNC_VALUE_VARARG_(N,...)     EXPAND(DECLARE_FUNC_VALUE_VARARG_N(N,__VA_ARGS__))
+
+#define DECLARE_FUNC_VALUE_VARARG_N(N,...)     EXPAND(DECLARE_FAKE_VALUE_FUNC ## N ## _VARARG(__VA_ARGS__))
+
+
+#define DECLARE_FAKE_VOID_FUNC_VARARG(...)     EXPAND(DECLARE_FUNC_VOID_VARARG_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__))
+
+#define DECLARE_FUNC_VOID_VARARG_(N,...)     EXPAND(DECLARE_FUNC_VOID_VARARG_N(N,__VA_ARGS__))
+
+#define DECLARE_FUNC_VOID_VARARG_N(N,...)     EXPAND(DECLARE_FAKE_VOID_FUNC ## N ## _VARARG(__VA_ARGS__))
+
+
+
+/* DEFINE FAKE FUNCTIONS - PLACE IN SOURCE FILES */
+
+#define DEFINE_FAKE_VALUE_FUNC(...)     EXPAND(DEFINE_FUNC_VALUE_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__))
+
+#define DEFINE_FUNC_VALUE_(N,...)     EXPAND(DEFINE_FUNC_VALUE_N(N,__VA_ARGS__))
+
+#define DEFINE_FUNC_VALUE_N(N,...)     EXPAND(DEFINE_FAKE_VALUE_FUNC ## N(__VA_ARGS__))
+
+
+#define DEFINE_FAKE_VOID_FUNC(...)     EXPAND(DEFINE_FUNC_VOID_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__))
+
+#define DEFINE_FUNC_VOID_(N,...)     EXPAND(DEFINE_FUNC_VOID_N(N,__VA_ARGS__))
+
+#define DEFINE_FUNC_VOID_N(N,...)     EXPAND(DEFINE_FAKE_VOID_FUNC ## N(__VA_ARGS__))
+
+
+#define DEFINE_FAKE_VALUE_FUNC_VARARG(...)     EXPAND(DEFINE_FUNC_VALUE_VARARG_(PP_NARG_MINUS2(__VA_ARGS__), __VA_ARGS__))
+
+#define DEFINE_FUNC_VALUE_VARARG_(N,...)     EXPAND(DEFINE_FUNC_VALUE_VARARG_N(N,__VA_ARGS__))
+
+#define DEFINE_FUNC_VALUE_VARARG_N(N,...)     EXPAND(DEFINE_FAKE_VALUE_FUNC ## N ## _VARARG(__VA_ARGS__))
+
+
+#define DEFINE_FAKE_VOID_FUNC_VARARG(...)     EXPAND(DEFINE_FUNC_VOID_VARARG_(PP_NARG_MINUS1(__VA_ARGS__), __VA_ARGS__))
+
+#define DEFINE_FUNC_VOID_VARARG_(N,...)     EXPAND(DEFINE_FUNC_VOID_VARARG_N(N,__VA_ARGS__))
+
+#define DEFINE_FUNC_VOID_VARARG_N(N,...)     EXPAND(DEFINE_FAKE_VOID_FUNC ## N ## _VARARG(__VA_ARGS__))
+
+
+
+
+#endif /* FAKE_FUNCTIONS */
diff --git a/src/note-c/test/include/test_static.h b/src/note-c/test/include/test_static.h
new file mode 100644
index 0000000..5e67990
--- /dev/null
+++ b/src/note-c/test/include/test_static.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "n_lib.h"
+
+// If we're building the tests, NOTE_C_STATIC is defined to nothing. This allows
+// the tests to access the static functions in note-c. Among other things, this
+// let's us mock these normally static functions.
+#define NOTE_C_STATIC
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Make these normally static functions externally visible if building tests.
+char *crcAdd(char *json, uint16_t seqno);
+bool crcError(char *json, uint16_t shouldBeSeqno);
+void delayIO(void);
+const char * i2cNoteQueryLength(uint32_t * available, uint32_t timeoutMs);
+void setTime(JTIME seconds);
+bool timerExpiredSecs(uint32_t *timer, uint32_t periodSecs);
+char Jtolower(char c);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/note-c/test/include/time_mocks.h b/src/note-c/test/include/time_mocks.h
new file mode 100644
index 0000000..b93d78a
--- /dev/null
+++ b/src/note-c/test/include/time_mocks.h
@@ -0,0 +1,24 @@
+/*!
+ * @file time_mocks.h
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#pragma once
+
+uint32_t NoteGetMsIncrement(void)
+{
+    static long unsigned int count = 0;
+
+    // increment by 1 second
+    count += 1000;
+    // return count pre-increment
+    return count - 1000;
+}
diff --git a/src/note-c/test/src/JAddBinaryToObject_test.cpp b/src/note-c/test/src/JAddBinaryToObject_test.cpp
new file mode 100644
index 0000000..a756233
--- /dev/null
+++ b/src/note-c/test/src/JAddBinaryToObject_test.cpp
@@ -0,0 +1,86 @@
+/*!
+ * @file JAddBinaryToObject_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+FAKE_VALUE_FUNC(J *, JCreateStringValue, const char *)
+
+namespace
+{
+
+J *JCreateStringValueCustom(const char *string)
+{
+    J *node = (J*)_Malloc(sizeof(J));
+    if (node) {
+        memset(node, '\0', sizeof(J));
+        node->type = JString;
+        node->valuestring = (char*)string;
+    }
+
+    return node;
+}
+
+SCENARIO("JAddBinaryToObject")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+    NoteMalloc_fake.custom_fake = malloc;
+
+    const char field[] = "req";
+    const char val[] = "Here's a string to base64 encode";
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+
+    SECTION("NULL JSON") {
+        CHECK(!JAddBinaryToObject(NULL, field, val, sizeof(val)));
+    }
+
+    SECTION("NoteMalloc fails") {
+        NoteMalloc_fake.custom_fake = NULL;
+        NoteMalloc_fake.return_val = NULL;
+
+        CHECK(!JAddBinaryToObject(json, field, val, sizeof(val)));
+    }
+
+    SECTION("JCreateStringValue fails") {
+        JCreateStringValue_fake.return_val = NULL;
+
+        CHECK(!JAddBinaryToObject(json, field, val, sizeof(val)));
+    }
+
+    SECTION("Success") {
+        JCreateStringValue_fake.custom_fake = JCreateStringValueCustom;
+
+        CHECK(JAddBinaryToObject(json, field, val, sizeof(val)));
+        char *b64 = JGetString(json, field);
+        REQUIRE(b64 != NULL);
+        char decoded[sizeof(val)];
+        REQUIRE(JB64Decode(decoded, b64) == sizeof(val));
+        CHECK(strcmp(decoded, val) == 0);
+    }
+
+    JDelete(json);
+
+    RESET_FAKE(NoteMalloc);
+    RESET_FAKE(JCreateStringValue);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JAllocString_test.cpp b/src/note-c/test/src/JAllocString_test.cpp
new file mode 100644
index 0000000..cf50049
--- /dev/null
+++ b/src/note-c/test/src/JAllocString_test.cpp
@@ -0,0 +1,62 @@
+/*!
+ * @file JAllocString_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+
+namespace
+{
+
+SCENARIO("JAllocString")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+    NoteMalloc_fake.custom_fake = malloc;
+
+    // "Hello Blues!"
+    uint8_t buf[] = {
+        0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x42, 0x6c, 0x75, 0x65, 0x73, 0x21
+    };
+    uint32_t len = sizeof(buf);
+
+    SECTION("0 length") {
+        char *str = JAllocString(buf, 0);
+        CHECK(strcmp(str, "") == 0);
+        NoteFree(str);
+    }
+
+    SECTION("NoteMalloc fails") {
+        NoteMalloc_fake.custom_fake = NULL;
+        NoteMalloc_fake.return_val = NULL;
+
+        CHECK(JAllocString(buf, len) == NULL);
+    }
+
+    SECTION(">0 length") {
+        char *str = JAllocString(buf, len);
+        CHECK(strcmp(str, "Hello Blues!") == 0);
+        NoteFree(str);
+    }
+
+    RESET_FAKE(NoteMalloc);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JAtoI_test.cpp b/src/note-c/test/src/JAtoI_test.cpp
new file mode 100644
index 0000000..87d1d6e
--- /dev/null
+++ b/src/note-c/test/src/JAtoI_test.cpp
@@ -0,0 +1,57 @@
+/*!
+ * @file JAtoI_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JAtoI")
+{
+    const char* strings[] = {
+        "0",
+        "1",
+        "1000",
+        "0001",
+        "   50",
+        "+12345",
+        "50   ",
+        "-1",
+        "-1000",
+        "-0001",
+        "   -50",
+        "-50   "
+    };
+    JINTEGER nums[] = {
+        0,
+        1,
+        1000,
+        1,
+        50,
+        12345,
+        50,
+        -1,
+        -1000,
+        -1,
+        -50,
+        -50
+    };
+
+    for (size_t i = 0; i < sizeof(strings) / sizeof(*strings); ++i) {
+        CHECK(JAtoI(strings[i]) == nums[i]);
+    }
+}
+
+}
diff --git a/src/note-c/test/src/JAtoN_test.cpp b/src/note-c/test/src/JAtoN_test.cpp
new file mode 100644
index 0000000..5c94df7
--- /dev/null
+++ b/src/note-c/test/src/JAtoN_test.cpp
@@ -0,0 +1,64 @@
+/*!
+ * @file JAtoN_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2024 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <cmath>
+
+#include "n_lib.h"
+
+namespace
+{
+
+#ifdef NOTE_C_LOW_MEM
+const JNUMBER expectedNums[] = {
+    3.40282e+38, // Approximate largest single-precision float value
+    1.17549e-38, // Approximate smallest single-precision float value
+};
+
+const char *numStrs[] = {
+    "3.40282e+38",
+    "1.17549e-38"
+};
+#else
+const JNUMBER expectedNums[] = {
+    1.79769e+308, // Approximate largest double-precision float value
+    2.22507e-308, // Approximate smallest double-precision float value
+};
+
+const char *numStrs[] = {
+    "1.79769e+308",
+    "2.22507e-308"
+};
+#endif // NOTE_C_LOW_MEM
+
+const size_t NUM_TESTS = sizeof(expectedNums) / sizeof(expectedNums[0]);
+const JNUMBER TOLERANCE = 1e-15;
+
+SCENARIO("JAtoN")
+{
+    for (size_t i = 0; i < NUM_TESTS; ++i) {
+        GIVEN(std::string("The string to convert to a JNUMBER is ") + numStrs[i]) {
+            WHEN("JAtoN is called on that string") {
+                JNUMBER num = JAtoN(numStrs[i], NULL);
+
+                THEN(std::string("The number returned is (approximately) ") + numStrs[i]) {
+                    JNUMBER diff = fabs(num - expectedNums[i]);
+                    JNUMBER err = diff / expectedNums[i];
+                    CHECK(err < TOLERANCE);
+                }
+            }
+        }
+    }
+}
+
+}
diff --git a/src/note-c/test/src/JBaseItemType_test.cpp b/src/note-c/test/src/JBaseItemType_test.cpp
new file mode 100644
index 0000000..ca34296
--- /dev/null
+++ b/src/note-c/test/src/JBaseItemType_test.cpp
@@ -0,0 +1,103 @@
+/*!
+ * @file JBaseItemType_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JBaseItemType")
+{
+    GIVEN("A BOOL JSON") {
+        WHEN("The value is JTYPE_BOOL_TRUE") {
+            THEN("The type is JTYPE_BOOL") {
+                CHECK(JBaseItemType(JTYPE_BOOL_TRUE) == JTYPE_BOOL);
+            }
+        }
+        WHEN("The value is JTYPE_BOOL_FALSE") {
+            THEN("The type is JTYPE_BOOL") {
+                CHECK(JBaseItemType(JTYPE_BOOL_FALSE) == JTYPE_BOOL);
+            }
+        }
+    }
+
+    GIVEN("A NUMBER JSON") {
+        WHEN("The value is JTYPE_NUMBER_ZERO") {
+            THEN("The type is JTYPE_NUMBER") {
+                CHECK(JBaseItemType(JTYPE_NUMBER_ZERO) == JTYPE_NUMBER);
+            }
+        }
+    }
+
+    GIVEN("A STRING JSON") {
+        WHEN("The value is JTYPE_STRING_BLANK") {
+            THEN("The type is JTYPE_STRING") {
+                CHECK(JBaseItemType(JTYPE_STRING_BLANK) == JTYPE_STRING);
+            }
+        }
+        WHEN("The value is JTYPE_STRING_ZERO") {
+            THEN("The type is JTYPE_STRING") {
+                CHECK(JBaseItemType(JTYPE_STRING_ZERO) == JTYPE_STRING);
+            }
+        }
+        WHEN("The value is JTYPE_STRING_NUMBER") {
+            THEN("The type is JTYPE_STRING") {
+                CHECK(JBaseItemType(JTYPE_STRING_NUMBER) == JTYPE_STRING);
+            }
+        }
+        WHEN("The value is JTYPE_STRING_BOOL_TRUE") {
+            THEN("The type is JTYPE_STRING") {
+                CHECK(JBaseItemType(JTYPE_STRING_BOOL_TRUE) == JTYPE_STRING);
+            }
+        }
+        WHEN("The value is JTYPE_STRING_BOOL_FALSE") {
+            THEN("The type is JTYPE_STRING") {
+                CHECK(JBaseItemType(JTYPE_STRING_BOOL_FALSE) == JTYPE_STRING);
+            }
+        }
+    }
+
+    GIVEN("A BASE TYPE JSON") {
+        WHEN("The value is JTYPE_BOOL") {
+            THEN("The type is JTYPE_BOOL") {
+                CHECK(JBaseItemType(JTYPE_BOOL) == JTYPE_BOOL);
+            }
+        }
+        WHEN("The value is JTYPE_NUMBER") {
+            THEN("The type is JTYPE_NUMBER") {
+                CHECK(JBaseItemType(JTYPE_NUMBER) == JTYPE_NUMBER);
+            }
+        }
+        WHEN("The value is JTYPE_STRING") {
+            THEN("The type is JTYPE_STRING") {
+                CHECK(JBaseItemType(JTYPE_STRING) == JTYPE_STRING);
+            }
+        }
+        WHEN("The value is JTYPE_ARRAY") {
+            THEN("The type is JTYPE_ARRAY") {
+                CHECK(JBaseItemType(JTYPE_ARRAY) == JTYPE_ARRAY);
+            }
+        }
+        WHEN("The value is JTYPE_OBJECT") {
+            THEN("The type is JTYPE_OBJECT") {
+                CHECK(JBaseItemType(JTYPE_OBJECT) == JTYPE_OBJECT);
+            }
+        }
+    }
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JBoolValue_test.cpp b/src/note-c/test/src/JBoolValue_test.cpp
new file mode 100644
index 0000000..1c2f1f7
--- /dev/null
+++ b/src/note-c/test/src/JBoolValue_test.cpp
@@ -0,0 +1,53 @@
+/*!
+ * @file JBoolValue_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JBoolValue")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = NULL;
+
+    SECTION("NULL JSON") {
+        CHECK(!JBoolValue(NULL));
+    }
+
+    SECTION("False") {
+        json = JCreateBool(false);
+        CHECK(!JBoolValue(json));
+    }
+
+    SECTION("True") {
+        json = JCreateBool(true);
+        CHECK(JBoolValue(json));
+    }
+
+    SECTION("Not a bool") {
+        json = JCreateNumber(1);
+        CHECK(!JBoolValue(json));
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JContainsString_test.cpp b/src/note-c/test/src/JContainsString_test.cpp
new file mode 100644
index 0000000..9e0b31a
--- /dev/null
+++ b/src/note-c/test/src/JContainsString_test.cpp
@@ -0,0 +1,71 @@
+/*!
+ * @file JContainsString_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JContainsString")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    const char field[] = "field";
+    const char val[] = "value";
+    const char substr[] = "alu";
+
+    SECTION("NULL JSON") {
+        CHECK(!JContainsString(NULL, field, substr));
+    }
+
+    SECTION("Field doesn't exist") {
+        CHECK(!JContainsString(json, "abc", substr));
+    }
+
+    SECTION("Not a string") {
+        JAddNumberToObject(json, field, 1.5);
+        CHECK(!JContainsString(json, field, substr));
+    }
+
+    SECTION("valuestring is null") {
+        JAddStringToObject(json, field, val);
+        J *string = JGetObjectItem(json, field);
+        REQUIRE(string != NULL);
+        char *tmp = string->valuestring;
+        string->valuestring = NULL;
+        CHECK(!JContainsString(json, field, substr));
+        string->valuestring = tmp;
+    }
+
+    SECTION("Empty string") {
+        JAddStringToObject(json, field, val);
+        CHECK(!JContainsString(json, field, ""));
+    }
+
+    SECTION("Match") {
+        JAddStringToObject(json, field, val);
+        CHECK(JContainsString(json, field, substr));
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetArray_test.cpp b/src/note-c/test/src/JGetArray_test.cpp
new file mode 100644
index 0000000..1328816
--- /dev/null
+++ b/src/note-c/test/src/JGetArray_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file JGetArray_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetArray")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char field[] = "list";
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    J *list = JCreateArray();
+    REQUIRE(list != NULL);
+    JAddItemToObject(json, field, list);
+
+    SECTION("NULL JSON") {
+        CHECK(JGetArray(NULL, "") == NULL);
+    }
+
+    SECTION("Field not present") {
+        CHECK(JGetArray(json, "array") == NULL);
+    }
+
+    SECTION("Field isn't an array") {
+        JAddNumberToObject(json, "num", 5);
+        CHECK(JGetArray(json, "num") == NULL);
+    }
+
+    SECTION("Valid") {
+        CHECK(JGetArray(json, field) != NULL);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetBinaryFromObject_test.cpp b/src/note-c/test/src/JGetBinaryFromObject_test.cpp
new file mode 100644
index 0000000..9d54244
--- /dev/null
+++ b/src/note-c/test/src/JGetBinaryFromObject_test.cpp
@@ -0,0 +1,90 @@
+/*!
+ * @file JGetBinaryFromObject_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+
+namespace
+{
+
+SCENARIO("JGetBinaryFromObject")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+    NoteMalloc_fake.custom_fake = malloc;
+
+    const char field[] = "req";
+    const char val[] = "Here's a string to base64 encode";
+    uint8_t *binData;
+    uint32_t binDataLen;
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+
+    GIVEN("Bad parameters") {
+        WHEN("NULL JSON") {
+            CHECK(!JGetBinaryFromObject(NULL, field, &binData, &binDataLen));
+        }
+
+        WHEN("Empty string") {
+            JAddStringToObject(json, field, "");
+
+            CHECK(!JGetBinaryFromObject(json, field, &binData, &binDataLen));
+        }
+
+        CHECK(binData == NULL);
+        CHECK(binDataLen == 0);
+    }
+
+    GIVEN("Internal failure") {
+        WHEN("NoteMalloc fails") {
+            JAddStringToObject(json, field, "string");
+
+            NoteMalloc_fake.custom_fake = NULL;
+            NoteMalloc_fake.return_val = NULL;
+
+            CHECK(!JGetBinaryFromObject(json, field, &binData, &binDataLen));
+        }
+
+        CHECK(binData == NULL);
+        CHECK(binDataLen == 0);
+    }
+
+    GIVEN("Success") {
+        REQUIRE(JAddBinaryToObject(json, field, val, sizeof(val)));
+
+        WHEN("With field specifier") {
+            REQUIRE(JGetBinaryFromObject(json, field, &binData, &binDataLen));
+        }
+
+        WHEN("Without field specifier") {
+            char *str = JGetString(json, field);
+            REQUIRE(JGetBinaryFromObject((J *)str, NULL, &binData, &binDataLen));
+        }
+
+        REQUIRE(binDataLen == sizeof(val));
+        CHECK(memcmp(binData, val, sizeof(val)) == 0);
+
+        NoteFree(binData);
+    }
+
+    JDelete(json);
+
+    RESET_FAKE(NoteMalloc);
+}
+
+}
diff --git a/src/note-c/test/src/JGetBool_test.cpp b/src/note-c/test/src/JGetBool_test.cpp
new file mode 100644
index 0000000..c4174c2
--- /dev/null
+++ b/src/note-c/test/src/JGetBool_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file JGetBool_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetBool")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    const char field[] = "field";
+    bool val = true;
+
+    SECTION("NULL JSON") {
+        CHECK(JGetBool(NULL, field) == 0);
+    }
+
+    SECTION("Wrong field") {
+        JAddBoolToObject(json, field, val);
+        CHECK(!JGetBool(json, "abc"));
+    }
+
+    SECTION("Not a bool") {
+        JAddStringToObject(json, field, "value");
+        CHECK(!JGetBool(json, field));
+    }
+
+    SECTION("Valid bol") {
+        JAddBoolToObject(json, field, val);
+        CHECK(JGetBool(json, field));
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetInt_test.cpp b/src/note-c/test/src/JGetInt_test.cpp
new file mode 100644
index 0000000..20b1676
--- /dev/null
+++ b/src/note-c/test/src/JGetInt_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file JGetInt_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetInt")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    const char field[] = "field";
+    long int val = 123;
+
+    SECTION("NULL JSON") {
+        CHECK(JGetInt(NULL, field) == 0);
+    }
+
+    SECTION("Wrong field") {
+        JAddNumberToObject(json, field, val);
+        CHECK(JGetInt(json, "abc") == 0);
+    }
+
+    SECTION("Not a number") {
+        JAddStringToObject(json, field, "value");
+        CHECK(JGetInt(json, field) == 0);
+    }
+
+    SECTION("Valid number") {
+        JAddNumberToObject(json, field, val);
+        CHECK(JGetInt(json, field) == val);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetItemName_test.cpp b/src/note-c/test/src/JGetItemName_test.cpp
new file mode 100644
index 0000000..dc8712f
--- /dev/null
+++ b/src/note-c/test/src/JGetItemName_test.cpp
@@ -0,0 +1,50 @@
+/*!
+ * @file JGetItemName_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetItemName")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+
+    SECTION("Item NULL") {
+        CHECK(strcmp(JGetItemName(NULL), "") == 0);
+    }
+
+    SECTION("No name") {
+        CHECK(strcmp(JGetItemName(json), "") == 0);
+    }
+
+    SECTION("Valid name") {
+        const char field[] = "req";
+        JAddStringToObject(json, field, "note.add");
+        J *item = JGetObjectItem(json, field);
+        CHECK(strcmp(JGetItemName(item), field) == 0);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetNumber_test.cpp b/src/note-c/test/src/JGetNumber_test.cpp
new file mode 100644
index 0000000..7e6e3a7
--- /dev/null
+++ b/src/note-c/test/src/JGetNumber_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file JGetNumber_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetNumber")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    const char field[] = "field";
+    JNUMBER val = 1.5;
+
+    SECTION("NULL JSON") {
+        CHECK(JGetNumber(NULL, field) == 0);
+    }
+
+    SECTION("Wrong field") {
+        JAddNumberToObject(json, field, val);
+        CHECK(JGetNumber(json, "abc") == 0);
+    }
+
+    SECTION("Not a number") {
+        JAddStringToObject(json, field, "value");
+        CHECK(JGetNumber(json, field) == 0);
+    }
+
+    SECTION("Valid number") {
+        JAddNumberToObject(json, field, val);
+        CHECK(JGetNumber(json, field) == val);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetObject_test.cpp b/src/note-c/test/src/JGetObject_test.cpp
new file mode 100644
index 0000000..cf022d2
--- /dev/null
+++ b/src/note-c/test/src/JGetObject_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file JGetObject_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetObject")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char field[] = "body";
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    J *body = JCreateObject();
+    REQUIRE(body != NULL);
+    JAddItemToObject(json, field, body);
+
+    SECTION("NULL JSON") {
+        CHECK(JGetObject(NULL, "") == NULL);
+    }
+
+    SECTION("Field not present") {
+        CHECK(JGetObject(json, "req") == NULL);
+    }
+
+    SECTION("Field isn't an object") {
+        JAddNumberToObject(json, "num", 5);
+        CHECK(JGetObject(json, "num") == NULL);
+    }
+
+    SECTION("Valid") {
+        CHECK(JGetObject(json, field) != NULL);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetString_test.cpp b/src/note-c/test/src/JGetString_test.cpp
new file mode 100644
index 0000000..5aada58
--- /dev/null
+++ b/src/note-c/test/src/JGetString_test.cpp
@@ -0,0 +1,69 @@
+/*!
+ * @file JGetString_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetString")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char field[] = "req";
+    const char val[] = "note.add";
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    JAddStringToObject(json, field, val);
+
+    SECTION("NULL JSON") {
+        char *ret = JGetString(NULL, "");
+        CHECK(strcmp(ret, "") == 0);
+    }
+
+    SECTION("Field not present") {
+        char *ret = JGetString(json, "cmd");
+        CHECK(strcmp(ret, "") == 0);
+    }
+
+    SECTION("Field isn't a string") {
+        JAddNumberToObject(json, "num", 5);
+        char *ret = JGetString(json, "num");
+        CHECK(strcmp(ret, "") == 0);
+    }
+
+    SECTION("valuestring is null") {
+        J *string = JGetObjectItem(json, field);
+        REQUIRE(string != NULL);
+        char *tmp = string->valuestring;
+        string->valuestring = NULL;
+        char *ret = JGetString(json, field);
+        string->valuestring = tmp;
+        CHECK(strcmp(ret, "") == 0);
+    }
+
+    SECTION("Valid") {
+        char *ret = JGetString(json, field);
+        CHECK(strcmp(ret, val) == 0);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JGetType_test.cpp b/src/note-c/test/src/JGetType_test.cpp
new file mode 100644
index 0000000..68f5e96
--- /dev/null
+++ b/src/note-c/test/src/JGetType_test.cpp
@@ -0,0 +1,154 @@
+/*!
+ * @file JGetType_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JGetType")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char field[] = "field";
+    J *json = JCreateObject();
+
+    SECTION("NULL JSON") {
+        CHECK(JGetType(NULL, field) == JTYPE_NOT_PRESENT);
+    }
+
+    SECTION("NULL field") {
+        CHECK(JGetType(json, NULL) == JTYPE_NOT_PRESENT);
+    }
+
+    SECTION("Wrong field") {
+        CHECK(JGetType(json, "wrong_field") == JTYPE_NOT_PRESENT);
+    }
+
+    SECTION("JTrue") {
+        JAddBoolToObject(json, field, true);
+        CHECK(JGetType(json, field) == JTYPE_BOOL_TRUE);
+    }
+
+    SECTION("JFalse") {
+        JAddBoolToObject(json, field, false);
+        CHECK(JGetType(json, field) == JTYPE_BOOL_FALSE);
+    }
+
+    SECTION("JNumber") {
+        SECTION("Zero") {
+            JAddNumberToObject(json, field, 0);
+            CHECK(JGetType(json, field) == JTYPE_NUMBER_ZERO);
+        }
+
+        SECTION("Non-zero") {
+            JAddNumberToObject(json, field, 1234);
+            CHECK(JGetType(json, field) == JTYPE_NUMBER);
+        }
+    }
+
+    SECTION("Strings") {
+        typedef J *(*AddStringFn)(J *, const char * const, const char * const);
+        // Run this set of tests with both JAddStringToObject and
+        // JAddRawToObject.
+        AddStringFn addStringFns[] = {JAddStringToObject, JAddRawToObject};
+
+        for (size_t i=0; i < sizeof(addStringFns)/sizeof(*addStringFns); ++i) {
+            // Sections have to have unique names, hence we incorporate the loop
+            // counter into the name. See https://github.com/catchorg/Catch2/blob/devel/docs/limitations.md#sections-nested-in-loops.
+            DYNAMIC_SECTION("Regular string " << i) {
+                addStringFns[i](json, field, "string");
+                CHECK(JGetType(json, field) == JTYPE_STRING);
+            }
+
+            DYNAMIC_SECTION("Empty string " << i) {
+                addStringFns[i](json, field, "");
+                CHECK(JGetType(json, field) == JTYPE_STRING_BLANK);
+            }
+
+            DYNAMIC_SECTION("NULL valuestring " << i) {
+                addStringFns[i](json, field, "string");
+                J *string = JGetObjectItem(json, field);
+                char *tmp = string->valuestring;
+                string->valuestring = NULL;
+                CHECK(JGetType(json, field) == JTYPE_STRING_BLANK);
+                string->valuestring = tmp;
+            }
+
+            DYNAMIC_SECTION("Number string " << i) {
+                DYNAMIC_SECTION("Zero " << i) {
+                    addStringFns[i](json, field, "0.0");
+                    CHECK(JGetType(json, field) == JTYPE_STRING_ZERO);
+                }
+
+                DYNAMIC_SECTION("Non-zero " << i) {
+                    addStringFns[i](json, field, "123.45");
+                    CHECK(JGetType(json, field) == JTYPE_STRING_NUMBER);
+                }
+            }
+
+            DYNAMIC_SECTION("Boolean string " << i) {
+                DYNAMIC_SECTION("True " << i) {
+                    DYNAMIC_SECTION("Lowercase " << i) {
+                        addStringFns[i](json, field, "true");
+                    }
+
+                    DYNAMIC_SECTION("Uppercase " << i) {
+                        addStringFns[i](json, field, "TRUE");
+                    }
+
+                    CHECK(JGetType(json, field) == JTYPE_STRING_BOOL_TRUE);
+                }
+
+                DYNAMIC_SECTION("False " << i) {
+                    DYNAMIC_SECTION("Lowercase " << i) {
+                        addStringFns[i](json, field, "false");
+                    }
+
+                    DYNAMIC_SECTION("Uppercase " << i) {
+                        addStringFns[i](json, field, "FALSE");
+                    }
+
+                    CHECK(JGetType(json, field) == JTYPE_STRING_BOOL_FALSE);
+                }
+            }
+        }
+    }
+
+    SECTION("JObject") {
+        JAddObjectToObject(json, field);
+        CHECK(JGetType(json, field) == JTYPE_OBJECT);
+    }
+
+    SECTION("JArray") {
+        JAddArrayToObject(json, field);
+        CHECK(JGetType(json, field) == JTYPE_ARRAY);
+    }
+
+    SECTION("JInvalid") {
+        J *invalid = (J*)NoteMalloc(sizeof(J));
+        memset(invalid, 0, sizeof(J));
+        invalid->type = JInvalid;
+        JAddItemToObject(json, field, invalid);
+
+        CHECK(JGetType(json, field) == JTYPE_NOT_PRESENT);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JIntValue_test.cpp b/src/note-c/test/src/JIntValue_test.cpp
new file mode 100644
index 0000000..fa2e8f6
--- /dev/null
+++ b/src/note-c/test/src/JIntValue_test.cpp
@@ -0,0 +1,49 @@
+/*!
+ * @file JIntValue_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JIntValue")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = NULL;
+
+    SECTION("NULL JSON") {
+        CHECK(JIntValue(NULL) == 0);
+    }
+
+    SECTION("Not a number") {
+        json = JCreateString("test");
+        CHECK(JIntValue(json) == 0);
+    }
+
+    SECTION("Valid number") {
+        long int num = 123;
+        json = JCreateNumber(num);
+        CHECK(JIntValue(json) == num);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JIsExactString_test.cpp b/src/note-c/test/src/JIsExactString_test.cpp
new file mode 100644
index 0000000..3b8cc6d
--- /dev/null
+++ b/src/note-c/test/src/JIsExactString_test.cpp
@@ -0,0 +1,74 @@
+/*!
+ * @file JIsExactString_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JIsExactString")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    const char field[] = "field";
+    const char val[] = "val";
+
+    SECTION("NULL JSON") {
+        CHECK(!JIsExactString(NULL, field, val));
+    }
+
+    SECTION("Field doesn't exist") {
+        CHECK(!JIsExactString(json, "abc", val));
+    }
+
+    SECTION("Not a string") {
+        JAddNumberToObject(json, field, 1.5);
+        CHECK(!JIsExactString(json, field, val));
+    }
+
+    SECTION("valuestring is null") {
+        JAddStringToObject(json, field, val);
+        J *string = JGetObjectItem(json, field);
+        REQUIRE(string != NULL);
+        char *tmp = string->valuestring;
+        string->valuestring = NULL;
+        CHECK(!JIsExactString(json, field, val));
+        string->valuestring = tmp;
+    }
+
+    SECTION("Empty string") {
+        JAddStringToObject(json, field, "");
+        /*
+         * For some reason, trying to match the empty string always returns
+         * false.
+         */
+        CHECK(!JIsExactString(json, field, ""));
+    }
+
+    SECTION("Match") {
+        JAddStringToObject(json, field, val);
+        CHECK(JIsExactString(json, field, val));
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JIsNullString_test.cpp b/src/note-c/test/src/JIsNullString_test.cpp
new file mode 100644
index 0000000..ff1ea9e
--- /dev/null
+++ b/src/note-c/test/src/JIsNullString_test.cpp
@@ -0,0 +1,64 @@
+/*!
+ * @file JIsNullString_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JIsNullString")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    const char field[] = "field";
+
+    SECTION("NULL JSON") {
+        CHECK(!JIsNullString(NULL, field));
+    }
+
+    SECTION("Field doesn't exist") {
+        CHECK(JIsNullString(json, "abc"));
+    }
+
+    SECTION("Not a string") {
+        JAddNumberToObject(json, field, 1.5);
+        CHECK(!JIsNullString(json, field));
+    }
+
+    SECTION("valuestring is null") {
+        JAddStringToObject(json, field, "string");
+        J *string = JGetObjectItem(json, field);
+        REQUIRE(string != NULL);
+        char *tmp = string->valuestring;
+        string->valuestring = NULL;
+        CHECK(JIsNullString(json, field));
+        string->valuestring = tmp;
+    }
+
+    SECTION("String is NULL") {
+        JAddStringToObject(json, field, "");
+        CHECK(JIsNullString(json, field));
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JIsPresent_test.cpp b/src/note-c/test/src/JIsPresent_test.cpp
new file mode 100644
index 0000000..dd7b93f
--- /dev/null
+++ b/src/note-c/test/src/JIsPresent_test.cpp
@@ -0,0 +1,53 @@
+/*!
+ * @file JIsPresent_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JIsPresent")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char field[] = "req";
+    J *json = JCreateObject();
+    REQUIRE(json != NULL);
+    JAddStringToObject(json, field, "note.add");
+
+    SECTION("NULL JSON") {
+        CHECK(!JIsPresent(NULL, ""));
+    }
+
+    SECTION("NULL field") {
+        CHECK(!JIsPresent(json, NULL));
+    }
+
+    SECTION("Field not present") {
+        CHECK(!JIsPresent(json, "cmd"));
+    }
+
+    SECTION("Field present") {
+        CHECK(JIsPresent(json, "req"));
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JItoA_test.cpp b/src/note-c/test/src/JItoA_test.cpp
new file mode 100644
index 0000000..65c5dde
--- /dev/null
+++ b/src/note-c/test/src/JItoA_test.cpp
@@ -0,0 +1,118 @@
+/*!
+ * @file JItoA_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+#if JINTEGER_MIN == -2147483648
+const char JINTEGER_MIN_STR[] = "-2147483648";
+// The weird form of the RHS of this conditional resolves this warning:
+// "warning: integer constant is so large that it is unsigned". See:
+// https://stackoverflow.com/a/65008305
+#elif JINTEGER_MIN == (-9223372036854775807 - 1)
+const char JINTEGER_MIN_STR[] = "-9223372036854775808";
+#else
+#error "Couldn't determine value of JINTEGER_MIN."
+#endif
+
+#if JINTEGER_MAX == 2147483647
+const char JINTEGER_MAX_STR[] = "2147483647";
+#elif JINTEGER_MAX == 9223372036854775807
+const char JINTEGER_MAX_STR[] = "9223372036854775807";
+#else
+#error "Couldn't determine value of JINTEGER_MAX."
+#endif
+
+SCENARIO("JItoA")
+{
+    JINTEGER n;
+    char text[16];
+
+    GIVEN("The number to convert to a string is 0") {
+        n = 0;
+
+        WHEN("JItoA is called on it") {
+            JItoA(n, text);
+
+            THEN("The correct string is produced") {
+                CHECK(strcmp(text, "0") == 0);
+            }
+        }
+    }
+
+    GIVEN("The number to convert to a string is non-zero") {
+        n = 1;
+
+        WHEN("JItoA is called on it") {
+            JItoA(n, text);
+
+            THEN("The correct string is produced") {
+                CHECK(strcmp(text, "1") == 0);
+            }
+        }
+    }
+
+    GIVEN("The number to convert to a string is positive with trailing zeros") {
+        n = 1234500;
+
+        WHEN("JItoA is called on it") {
+            JItoA(n, text);
+
+            THEN("The correct string is produced") {
+                CHECK(strcmp(text, "1234500") == 0);
+            }
+        }
+    }
+
+    GIVEN("The number to convert to a string is negative with trailing zeros") {
+        n = -1234500;
+
+        WHEN("JItoA is called on it") {
+            JItoA(n, text);
+
+            THEN("The correct string is produced") {
+                CHECK(strcmp(text, "-1234500") == 0);
+            }
+        }
+    }
+
+    GIVEN("The number to convert to a string is JINTEGER_MIN") {
+        n = JINTEGER_MIN;
+
+        WHEN("JItoA is called on it") {
+            JItoA(n, text);
+
+            THEN("The correct string is produced") {
+                CHECK(strcmp(text, JINTEGER_MIN_STR) == 0);
+            }
+        }
+    }
+
+    GIVEN("The number to convert to a string is JINTEGER_MAX") {
+        n = JINTEGER_MAX;
+
+        WHEN("JItoA is called on it") {
+            JItoA(n, text);
+
+            THEN("The correct string is produced") {
+                CHECK(strcmp(text, JINTEGER_MAX_STR) == 0);
+            }
+        }
+    }
+}
+
+}
diff --git a/src/note-c/test/src/JNtoA_test.cpp b/src/note-c/test/src/JNtoA_test.cpp
new file mode 100644
index 0000000..d23fb7e
--- /dev/null
+++ b/src/note-c/test/src/JNtoA_test.cpp
@@ -0,0 +1,71 @@
+/*!
+ * @file JNtoA_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2024 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <cmath>
+
+#include "n_lib.h"
+
+namespace
+{
+
+#ifdef NOTE_C_LOW_MEM
+const JNUMBER nums[] = {
+    3.40282e+38, // Approximate largest single-precision float value
+    1.17549e-38, // Approximate smallest single-precision float value
+};
+
+const char *expectedNumStrs[] = {
+    "3.40282e+38",
+    "1.17549e-38"
+};
+
+const JNUMBER TOLERANCE = 1e-8;
+#else
+const JNUMBER nums[] = {
+    1.79769e+308, // Approximate largest double-precision float value
+    2.22507e-308, // Approximate smallest double-precision float value
+};
+
+const char *expectedNumStrs[] = {
+    "1.79769e+308",
+    "2.22507e-308"
+};
+
+const JNUMBER TOLERANCE = 1e-8;
+#endif // NOTE_C_LOW_MEM
+
+const size_t NUM_TESTS = sizeof(nums) / sizeof(nums[0]);
+
+SCENARIO("JNtoA")
+{
+    char numStr[JNTOA_MAX] = {0};
+
+    for (size_t i = 0; i < NUM_TESTS; ++i) {
+        GIVEN(std::string("The number to convert to a string is ") + expectedNumStrs[i]) {
+            WHEN("JNtoA is called on that number") {
+                JNtoA(nums[i], numStr, -1);
+
+                THEN(std::string("The string returned is (approximately)") + expectedNumStrs[i]) {
+                    double extractedNum;
+                    sscanf(expectedNumStrs[i], "%lf", &extractedNum);
+                    JNUMBER diff = fabs(extractedNum - nums[i]);
+                    JNUMBER err = diff / nums[i];
+                    CHECK(err < TOLERANCE);
+                }
+            }
+        }
+    }
+}
+
+}
diff --git a/src/note-c/test/src/JNumberValue_test.cpp b/src/note-c/test/src/JNumberValue_test.cpp
new file mode 100644
index 0000000..9a57e5b
--- /dev/null
+++ b/src/note-c/test/src/JNumberValue_test.cpp
@@ -0,0 +1,49 @@
+/*!
+ * @file JNumberValue_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JNumberValue")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = NULL;
+
+    SECTION("NULL JSON") {
+        CHECK(JNumberValue(NULL) == 0);
+    }
+
+    SECTION("Not a number") {
+        json = JCreateString("test");
+        CHECK(JNumberValue(json) == 0);
+    }
+
+    SECTION("Valid number") {
+        JNUMBER num = 1.5;
+        json = JCreateNumber(num);
+        CHECK(JNumberValue(json) == num);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JPrintUnformatted_test.cpp b/src/note-c/test/src/JPrintUnformatted_test.cpp
new file mode 100644
index 0000000..981fb53
--- /dev/null
+++ b/src/note-c/test/src/JPrintUnformatted_test.cpp
@@ -0,0 +1,66 @@
+/*!
+ * @file JPrintUnformatted_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+// We typically don't write unit tests for cJSON functions. This is an exception
+// because we modified some of the internal cJSON printing code to use strlcpy
+// instead of strcpy, and we want to make sure we didn't introduce a bug.
+SCENARIO("JPrintUnformatted")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    GIVEN("A valid JSON object") {
+        J *jsonObj = JParse("{"
+                            "\"string\": \"Hello, World!\","
+                            "\"number\": 42,"
+                            "\"boolean\": true,"
+                            "\"nullValue\": null,"
+                            "\"array\": [1, \"two\", false, 3.14],"
+                            "\"nestedObject\": {"
+                            "\"key1\": \"value1\","
+                            "\"key2\": 123,"
+                            "\"key3\": {"
+                            "\"subKey1\": true,"
+                            "\"subKey2\": [\"apple\", \"banana\", \"cherry\"]"
+                            "}"
+                            "}"
+                            "}");
+
+        REQUIRE(jsonObj != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *result = JPrintUnformatted(jsonObj);
+
+            THEN("A non-NULL, non-zero length string is returned") {
+                REQUIRE(result != NULL);
+                CHECK(strlen(result) > 0);
+            }
+
+            JFree(result);
+        }
+
+        JDelete(jsonObj);
+    }
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JSON_number_handling_test.cpp b/src/note-c/test/src/JSON_number_handling_test.cpp
new file mode 100644
index 0000000..9c63689
--- /dev/null
+++ b/src/note-c/test/src/JSON_number_handling_test.cpp
@@ -0,0 +1,417 @@
+/*!
+ * @file JSON_number_handling_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2024 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+// We treat most of the JSON code as "tested" in the sense that it comes from a
+// tested third party library. However, we have made some changes to the
+// underlying code. For example, we've tweaked the number parsing code (see
+// parse_number and print_number in n_cjson.c).
+
+namespace
+{
+
+#define FIELD "num"
+
+#define JINTEGER_MAX_STR "9223372036854775807"
+// "Integers between 2^(n) and 2^(n+1) round to a multiple of 2^(n−52)."
+// (https://en.wikipedia.org/wiki/Double-precision_floating-point_format)
+// 9223372036854775807 == 2^63 - 1, so its JNUMBER representation should be rounded
+// up to the nearest multiple of 2^10 (1024).
+#define JINTEGER_MAX_TO_FLOAT ((JNUMBER)9223372036854775808UL)
+#define JINTEGER_MAX_TO_FLOAT_STR "9223372036854775808"
+
+// 9223372036854779903 is between 2^63 and 2^64, so conversion to floating point
+// should round to the nearest multiple of 2^11 (2048).
+#define JINTEGER_MAX_PLUS_4096 9223372036854779903UL
+#define JINTEGER_MAX_PLUS_4096_STR "9223372036854779903"
+// The nearest multiple of 2048.
+#define JINTEGER_MAX_PLUS_4096_TO_FLOAT ((JNUMBER)9223372036854780000UL)
+#define JINTEGER_MAX_PLUS_4096_TO_FLOAT_STR "9.22337203685478e+18"
+
+#define JINTEGER_MIN_STR "-9223372036854775808"
+// -9223372036854775808 is already a multiple of 1024, so it can be represented
+// exactly as a floating point number.
+#define JINTEGER_MIN_TO_FLOAT -((JNUMBER)9223372036854775808UL)
+#define JINTEGER_MIN_TO_FLOAT_STR "-9223372036854775808"
+
+#define JINTEGER_MIN_MINUS_4096 -((JNUMBER)9223372036854779904UL)
+#define JINTEGER_MIN_MINUS_4096_STR "-9223372036854779904"
+// The nearest multiple of 2048.
+#define JINTEGER_MIN_MINUS_4096_TO_FLOAT -((JNUMBER)9223372036854780000UL)
+#define JINTEGER_MIN_MINUS_4096_TO_FLOAT_STR "-9.22337203685478e+18"
+
+#define SMALL_FLOAT 0.0009765625
+#define SMALL_FLOAT_STR "0.0009765625"
+
+#define UNIX_TIMESTAMP 1705699768
+#define UNIX_TIMESTAMP_STR "1705699768"
+
+SCENARIO("Unmarshalling")
+{
+    J *obj;
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    GIVEN("A JSON string with a numeric field with value 0") {
+        const char json[] = "{\"" FIELD "\":0}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetInt on the object returns 0") {
+                CHECK(JGetInt(obj, FIELD) == 0);
+            }
+
+            THEN("JGetNumber on the object returns 0") {
+                CHECK(JGetNumber(obj, FIELD) == 0);
+            }
+
+            JDelete(obj);
+        }
+    }
+
+    GIVEN("A JSON string with a numeric field with the max value of JINTEGER") {
+        const char json[] = "{\"" FIELD "\":" JINTEGER_MAX_STR "}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetInt on the object returns the max value of JINTEGER") {
+                CHECK(JGetInt(obj, FIELD) == JINTEGER_MAX);
+            }
+
+            THEN("JGetNumber on the object returns the max value of JINTEGER "
+                 "rounded to the expected power of 2") {
+                CHECK(JGetNumber(obj, FIELD) == JINTEGER_MAX_TO_FLOAT);
+            }
+
+            JDelete(obj);
+        }
+    }
+
+    GIVEN("A JSON string with a numeric field with the max value of JINTEGER "
+          "plus 4096") {
+        const char json[] = "{\"" FIELD "\":" JINTEGER_MAX_PLUS_4096_STR "}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetInt on the object returns the max value of JINTEGER "
+                 "(saturation)") {
+                CHECK(JGetInt(obj, FIELD) == JINTEGER_MAX);
+            }
+
+            THEN("JGetNumber on the object returns the max value of JINTEGER "
+                 "plus 4096 rounded to the expected power of 2") {
+                CHECK(JGetNumber(obj, FIELD) == JINTEGER_MAX_PLUS_4096_TO_FLOAT);
+            }
+
+            JDelete(obj);
+        }
+    }
+
+    GIVEN("A JSON string with a numeric field with the min value of JINTEGER") {
+        const char json[] = "{\"" FIELD "\":" JINTEGER_MIN_STR "}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetInt on the object returns the min value of JINTEGER") {
+                CHECK(JGetInt(obj, FIELD) == JINTEGER_MIN);
+            }
+
+            THEN("JGetNumber on the object returns the min value of JINTEGER "
+                 "rounded to the expected power of 2") {
+                CHECK(JGetNumber(obj, FIELD) == JINTEGER_MIN_TO_FLOAT);
+            }
+
+            JDelete(obj);
+        }
+    }
+
+    GIVEN("A JSON string with a numeric field with the min value of JINTEGER "
+          "minus 4096") {
+        const char json[] = "{\"" FIELD "\":" JINTEGER_MIN_MINUS_4096_STR "}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetInt on the object returns the min value of JINTEGER "
+                 "(saturation)") {
+                CHECK(JGetInt(obj, FIELD) == JINTEGER_MIN);
+            }
+
+            THEN("JGetNumber on the object returns the min value of JINTEGER "
+                 "rounded to the expected power of 2") {
+                CHECK(JGetNumber(obj, FIELD) ==
+                      JINTEGER_MIN_MINUS_4096_TO_FLOAT);
+            }
+
+            JDelete(obj);
+        }
+    }
+
+    GIVEN("A JSON string with a numeric field with a small floating point "
+          "value") {
+        const char json[] = "{\"" FIELD "\":" SMALL_FLOAT_STR "}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetNumber on the object returns the small floating point "
+                 "value") {
+                CHECK(JGetNumber(obj, FIELD) == SMALL_FLOAT);
+            }
+
+            JDelete(obj);
+        }
+    }
+
+    GIVEN("A JSON string with a numeric field with a number that's accurately "
+          "represented by a 32-bit int but not a single precision float (e.g. a"
+          " Unix timestamp") {
+        const char json[] = "{\"" FIELD "\":" UNIX_TIMESTAMP_STR "}";
+
+        WHEN("JParse is called on that string") {
+            obj = JParse(json);
+
+            REQUIRE(obj != NULL);
+
+            THEN("JGetNumber on the object returns the small floating point "
+                 "value") {
+                CHECK(JGetNumber(obj, FIELD) == UNIX_TIMESTAMP);
+            }
+
+            JDelete(obj);
+        }
+    }
+}
+
+SCENARIO("Marshalling")
+{
+    J *obj;
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    GIVEN("A JSON object with a numeric field with value 0") {
+        const char expected[] = "{\"" FIELD "\":0}";
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddNumberToObject(obj, FIELD, 0) != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("0 is printed accurately") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A JSON object with a numeric field with the max value of JINTEGER") {
+        const char expected[] = "{\"" FIELD "\":" JINTEGER_MAX_STR "}";
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddIntToObject(obj, FIELD, JINTEGER_MAX) != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("The value is printed accurately") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A JSON object with a numeric field with the max value of JINTEGER "
+          "plus 4096") {
+#ifdef NOTE_C_TEST_SINGLE_PRECISION
+        // In the NOTE_C_TEST_SINGLE_PRECISION case, where JNUMBER is a
+        // single-precision float, JINTEGER_MAX_PLUS_4096 is indistinguishable
+        // from JINTEGER_MAX.
+        const char expected[] = "{\"" FIELD "\":" JINTEGER_MAX_STR "}";
+#else
+        const char expected[] = "{\"" FIELD "\":" \
+                                JINTEGER_MAX_PLUS_4096_TO_FLOAT_STR "}";
+#endif
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddNumberToObject(obj, FIELD, JINTEGER_MAX_PLUS_4096) != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("The value printed is the max value of JINTEGER plus 4096 "
+                 "rounded to the expected power of 2") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A JSON object with a numeric field with the min value of JINTEGER") {
+        const char expected[] = "{\"" FIELD "\":" JINTEGER_MIN_TO_FLOAT_STR "}";
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddNumberToObject(obj, FIELD, JINTEGER_MIN) != NULL);
+
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("The value printed is the min value of JINTEGER") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A JSON object with a numeric field with the min value of JINTEGER "
+          "minus one") {
+        const char expected[] = "{\"" FIELD "\":" JINTEGER_MIN_STR "}";
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddNumberToObject(obj, FIELD, JINTEGER_MIN) != NULL);
+
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("The value printed is the min value of JINTEGER "
+                 "(saturation)") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A J object with a numeric field with the min value of JINTEGER minus"
+          " 4096") {
+#ifdef NOTE_C_TEST_SINGLE_PRECISION
+        // In the NOTE_C_TEST_SINGLE_PRECISION case, where JNUMBER is a
+        // single-precision float, JINTEGER_MIN_MINUS_4096 is indistinguishable
+        // from JINTEGER_MIN.
+        const char expected[] = "{\"" FIELD "\":" JINTEGER_MIN_STR "}";
+#else
+        const char expected[] = "{\"" FIELD "\":" \
+                                JINTEGER_MIN_MINUS_4096_TO_FLOAT_STR "}";
+#endif
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddNumberToObject(obj, FIELD, JINTEGER_MIN_MINUS_4096) != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("The value printed is the value rounded to the expected power "
+                 "of 2") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A J object with a numeric field with a small floating point value") {
+        const char expected[] = "{\"" FIELD "\":" SMALL_FLOAT_STR "}";
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddNumberToObject(obj, FIELD, SMALL_FLOAT) != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+            // Replace closing '}' with null-terminator so we only pick out the
+            // number when using sccanf.
+            out[strlen(out) - 1] = '\0';
+            const char prefix[] = "\"num\":";
+            const char *numStart = strstr(out, prefix);
+            numStart += strlen(prefix);
+            double numValue;
+            sscanf(numStart, "%lf", &numValue);
+
+            THEN("The value printed is (approximately) the small floating point"
+                 "value") {
+                // If the two values are within 1e-11 of each other, call that
+                // equal.
+                CHECK((numValue - SMALL_FLOAT) < 1e-11);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+
+    GIVEN("A J object with a numeric field with a number that's accurately "
+          "represented by an 32-bit int but not a single precision float (e.g."
+          "a Unix timestamp") {
+        const char expected[] = "{\"" FIELD "\":" UNIX_TIMESTAMP_STR "}";
+        obj = JCreateObject();
+        REQUIRE(obj != NULL);
+        REQUIRE(JAddIntToObject(obj, FIELD, UNIX_TIMESTAMP) != NULL);
+
+        WHEN("JPrintUnformatted is called on that object") {
+            char *out = JPrintUnformatted(obj);
+            REQUIRE(out != NULL);
+
+            THEN("The timestamp is printed accurately") {
+                CHECK(strcmp(expected, out) == 0);
+            }
+
+            JFree(out);
+        }
+
+        JDelete(obj);
+    }
+}
+
+}
diff --git a/src/note-c/test/src/JStringValue_test.cpp b/src/note-c/test/src/JStringValue_test.cpp
new file mode 100644
index 0000000..084054a
--- /dev/null
+++ b/src/note-c/test/src/JStringValue_test.cpp
@@ -0,0 +1,49 @@
+/*!
+ * @file JStringValue_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JStringValue")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *json = NULL;
+
+    SECTION("NULL JSON") {
+        CHECK(strcmp(JStringValue(NULL), "") == 0);
+    }
+
+    SECTION("Not a string") {
+        json = JCreateNumber(1);
+        CHECK(JStringValue(json) == NULL);
+    }
+
+    SECTION("Valid string") {
+        const char str[] = "test";
+        json = JCreateString(str);
+        CHECK(strcmp(JStringValue(json), str) == 0);
+    }
+
+    JDelete(json);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/JType_test.cpp b/src/note-c/test/src/JType_test.cpp
new file mode 100644
index 0000000..7d6bf90
--- /dev/null
+++ b/src/note-c/test/src/JType_test.cpp
@@ -0,0 +1,63 @@
+/*!
+ * @file JType_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("JType")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("NULL JSON") {
+        CHECK(strcmp(JType(NULL), "") == 0);
+    }
+
+    SECTION("J Types") {
+        J *items[] = {
+            (J *)NoteMalloc(sizeof(J)),
+            JCreateBool(true),
+            JCreateBool(false),
+            JCreateNumber(1.5),
+            JCreateString("string"),
+            JCreateRaw("raw"),
+            JCreateObject(),
+            JCreateArray()
+        };
+        memset(items[0], 0, sizeof(J));
+        items[0]->type = JInvalid;
+
+        const char *strings[] = {
+            "invalid",
+            "bool",
+            "bool",
+            "number",
+            "string",
+            "string",
+            "object",
+            "array"
+        };
+
+        for (size_t i = 0; i < sizeof(items) / sizeof(*items); ++i) {
+            CHECK(strcmp(JType(items[i]), strings[i]) == 0);
+            JDelete(items[i]);
+        }
+    }
+}
+
+}
+
+
diff --git a/src/note-c/test/src/Jtolower_test.cpp b/src/note-c/test/src/Jtolower_test.cpp
new file mode 100644
index 0000000..6707422
--- /dev/null
+++ b/src/note-c/test/src/Jtolower_test.cpp
@@ -0,0 +1,73 @@
+/*!
+ * @file Jtolower_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+#include "test_static.h"
+
+namespace
+{
+
+SCENARIO("Jtolower")
+{
+    const char alphabetUpper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const char alphabetLower[] = "abcdefghijklmnopqrstuvwxyz";
+    char result[sizeof(alphabetUpper)] = {0};
+
+    GIVEN("The uppercase characters of the alphabet") {
+        WHEN("Jtolower is called on each letter") {
+            for (size_t i = 0; i < sizeof(alphabetUpper); ++i) {
+                result[i] = Jtolower(alphabetUpper[i]);
+            }
+
+            THEN("The corresponding lowercase letter is returned") {
+                for (size_t i = 0; i < sizeof(alphabetUpper); ++i) {
+                    CHECK(result[i] == alphabetLower[i]);
+                }
+            }
+        }
+    }
+
+    GIVEN("The lowercase characters of the alphabet") {
+        WHEN("Jtolower is called on each letter") {
+            for (size_t i = 0; i < sizeof(alphabetLower); ++i) {
+                result[i] = Jtolower(alphabetLower[i]);
+            }
+
+            THEN("The same lowercase letter is returned") {
+                for (size_t i = 0; i < sizeof(alphabetLower); ++i) {
+                    CHECK(result[i] == alphabetLower[i]);
+                }
+            }
+        }
+    }
+
+    GIVEN("A non-letter char") {
+        char invalid = '.';
+
+        WHEN("Jtolower is called on that char") {
+            char invalidResult = Jtolower(invalid);
+
+            THEN("The non-letter char is returned") {
+                CHECK(invalidResult == invalid);
+            }
+        }
+    }
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteAdd_test.cpp b/src/note-c/test/src/NoteAdd_test.cpp
new file mode 100644
index 0000000..e54575e
--- /dev/null
+++ b/src/note-c/test/src/NoteAdd_test.cpp
@@ -0,0 +1,75 @@
+/*!
+ * @file NoteAdd_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteAdd")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char file[] = "data.qo";
+    J *body = JCreateObject();
+    REQUIRE(body != NULL);
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteAdd(file, body, false));
+    }
+
+    SECTION("NoteRequest") {
+        J *req = JCreateObject();
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteAdd(file, body, false));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            SECTION("Not urgent") {
+                CHECK(NoteAdd(file, body, false));
+                CHECK(!JGetBool(req, "start"));
+            }
+
+            SECTION("Urgent") {
+                CHECK(NoteAdd(file, body, true));
+                CHECK(JGetBool(req, "start"));
+            }
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryCodecDecode_test.cpp b/src/note-c/test/src/NoteBinaryCodecDecode_test.cpp
new file mode 100644
index 0000000..78a79cf
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryCodecDecode_test.cpp
@@ -0,0 +1,91 @@
+/*!
+ * @file NoteBinaryCodecDecode_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(uint32_t, cobsDecode, uint8_t *, uint32_t, uint8_t, uint8_t *)
+
+uint8_t encData[12];
+const uint32_t encDataLen = sizeof(encData);
+uint8_t decBuf[10];
+const uint32_t decBufLen = sizeof(decBuf);
+uint32_t decLen;
+
+namespace
+{
+
+SCENARIO("NoteBinaryCodecDecode")
+{
+    // Reset variables(s)
+    decLen = 0;
+
+    GIVEN("Bad parameters are supplied") {
+        decLen = 79;
+        WHEN("encData is NULL") {
+            decLen = NoteBinaryCodecDecode(NULL, encDataLen, decBuf, decBufLen);
+
+            THEN("The decoded length is zero") {
+                CHECK(decLen == 0);
+            }
+        }
+        WHEN("decBuf is NULL") {
+            decLen = NoteBinaryCodecDecode(encData, encDataLen, NULL, decBufLen);
+
+            THEN("The decoded length is zero") {
+                CHECK(decLen == 0);
+            }
+        }
+        WHEN("decBufLen is less than the size required for the worst-case decoding") {
+            uint32_t badDecLen = (cobsGuaranteedFit(encDataLen) - 1);
+            decLen = NoteBinaryCodecDecode(encData, encDataLen, decBuf, badDecLen);
+
+            THEN("The decoded length is zero") {
+                CHECK(decLen == 0);
+            }
+        }
+    }
+
+    GIVEN("Parameters are in order") {
+        const uint32_t EXPECTED_RESULT = 79;
+        cobsDecode_fake.return_val = EXPECTED_RESULT;
+        decLen = NoteBinaryCodecDecode(encData, encDataLen, decBuf, decBufLen);
+
+        THEN("cobsDecode is invoked") {
+            CHECK(cobsDecode_fake.call_count > 0);
+        }
+
+        WHEN("cobsDecode is invoked") {
+            THEN("The parameters are passed without modification") {
+                CHECK(cobsDecode_fake.arg0_val == encData);
+                CHECK(cobsDecode_fake.arg1_val == encDataLen);
+                CHECK(cobsDecode_fake.arg3_val == decBuf);
+            }
+
+            THEN("The result is returned without modification") {
+                CHECK(EXPECTED_RESULT == decLen);
+            }
+        }
+    }
+
+    RESET_FAKE(cobsDecode);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryCodecEncode_test.cpp b/src/note-c/test/src/NoteBinaryCodecEncode_test.cpp
new file mode 100644
index 0000000..595855e
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryCodecEncode_test.cpp
@@ -0,0 +1,92 @@
+/*!
+ * @file NoteBinaryCodecEncode_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <string.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(uint32_t, cobsEncode, uint8_t *, uint32_t, uint8_t, uint8_t *)
+
+uint8_t decData[10] = "Hi Blues!";
+uint32_t decDataLen = strlen((const char *)decData);
+uint8_t encBuf[12];
+uint32_t encBufLen = sizeof(encBuf);
+uint32_t encLen;
+
+namespace
+{
+
+SCENARIO("NoteBinaryCodecEncode")
+{
+    // Reset variables(s)
+    encLen = 0;
+
+    GIVEN("Bad parameters are supplied") {
+        WHEN("decData is NULL") {
+            encLen = NoteBinaryCodecEncode(NULL, decDataLen, encBuf, encBufLen);
+
+            THEN("The encoded length is zero") {
+                CHECK(encLen == 0);
+            }
+        }
+        WHEN("encBuf is NULL") {
+            encLen = NoteBinaryCodecEncode(decData, decDataLen, NULL, encBufLen);
+
+            THEN("The encoded length is zero") {
+                CHECK(encLen == 0);
+            }
+        }
+        WHEN("encBufLen is less than the size required for in place encoding") {
+            uint32_t badOutLen = (cobsEncodedLength(decData, decDataLen) - 1);
+            encLen = NoteBinaryCodecEncode(decData, decDataLen, encBuf, badOutLen);
+
+            THEN("The encoded length is zero") {
+                CHECK(encLen == 0);
+            }
+        }
+    }
+
+    GIVEN("Parameters are in order") {
+        const uint32_t EXPECTED_RESULT = 79;
+        cobsEncode_fake.return_val = EXPECTED_RESULT;
+        encLen = NoteBinaryCodecEncode(decData, decDataLen, encBuf, encBufLen);
+
+        THEN("cobsEncode is invoked") {
+            CHECK(cobsEncode_fake.call_count > 0);
+        }
+
+        WHEN("cobsEncode is invoked") {
+            THEN("The parameters are passed without modification") {
+                CHECK(cobsEncode_fake.arg0_val == decData);
+                CHECK(cobsEncode_fake.arg1_val == decDataLen);
+                CHECK(cobsEncode_fake.arg3_val == encBuf);
+            }
+
+            THEN("The result is returned without modification") {
+                CHECK(EXPECTED_RESULT == encLen);
+            }
+        }
+    }
+
+    RESET_FAKE(cobsEncode);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryCodecMaxDecodedLength_test.cpp b/src/note-c/test/src/NoteBinaryCodecMaxDecodedLength_test.cpp
new file mode 100644
index 0000000..e59fc23
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryCodecMaxDecodedLength_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file NoteBinaryCodecMaxDecodedLength_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(uint32_t, cobsGuaranteedFit, uint32_t)
+
+const uint32_t bufferSize = 10;
+
+namespace
+{
+
+SCENARIO("NoteBinaryCodecMaxDecodedLength")
+{
+    GIVEN("Parameters are in order") {
+        const uint32_t EXPECTED_RESULT = 79;
+        cobsGuaranteedFit_fake.return_val = EXPECTED_RESULT;
+        const uint32_t result = NoteBinaryCodecMaxDecodedLength(bufferSize);
+
+        THEN("cobsGuaranteedFit is invoked") {
+            CHECK(cobsGuaranteedFit_fake.call_count > 0);
+        }
+
+        WHEN("cobsGuaranteedFit is invoked") {
+            THEN("The parameters are passed without modification") {
+                CHECK(cobsGuaranteedFit_fake.arg0_val == bufferSize);
+            }
+
+            THEN("The result is returned without modification") {
+                CHECK(EXPECTED_RESULT == result);
+            }
+        }
+    }
+
+    RESET_FAKE(cobsGuaranteedFit);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryCodecMaxEncodedLength_test.cpp b/src/note-c/test/src/NoteBinaryCodecMaxEncodedLength_test.cpp
new file mode 100644
index 0000000..7608938
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryCodecMaxEncodedLength_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file NoteBinaryCodecMaxEncodedLength_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(uint32_t, cobsEncodedMaxLength, uint32_t)
+
+const uint32_t unencodedLen = 10;
+
+namespace
+{
+
+SCENARIO("NoteBinaryCodecMaxEncodedLength")
+{
+    GIVEN("Parameters are in order") {
+        const uint32_t EXPECTED_RESULT = 79;
+        cobsEncodedMaxLength_fake.return_val = EXPECTED_RESULT;
+        const uint32_t result = NoteBinaryCodecMaxEncodedLength(unencodedLen);
+
+        THEN("cobsEncodedMaxLength is invoked") {
+            CHECK(cobsEncodedMaxLength_fake.call_count > 0);
+        }
+
+        WHEN("cobsEncodedMaxLength is invoked") {
+            THEN("The parameters are passed without modification") {
+                CHECK(cobsEncodedMaxLength_fake.arg0_val == unencodedLen);
+            }
+
+            THEN("The result is returned without modification") {
+                CHECK(EXPECTED_RESULT == result);
+            }
+        }
+    }
+
+    RESET_FAKE(cobsEncodedMaxLength);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryStoreDecodedLength_test.cpp b/src/note-c/test/src/NoteBinaryStoreDecodedLength_test.cpp
new file mode 100644
index 0000000..2a7757e
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryStoreDecodedLength_test.cpp
@@ -0,0 +1,135 @@
+/*!
+ * @file NoteBinaryStoreDecodedLength_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+const size_t len = 10;
+
+namespace
+{
+
+SCENARIO("NoteBinaryStoreDecodedLength")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    uint32_t size = 1;
+
+    GIVEN("Bad parameters are supplied") {
+        WHEN("Length is NULL") {
+            const char *err = NoteBinaryStoreDecodedLength(NULL);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The card.binary request fails") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+
+            return NULL;
+        };
+
+        WHEN("NoteBinaryStoreDecodedLength is called") {
+            const char *err = NoteBinaryStoreDecodedLength(&size);
+
+            REQUIRE(NoteRequestResponse_fake.call_count > 0);
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request has an error") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddStringToObject(rsp, "err", "some error");
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreDecodedLength is called") {
+            const char *err = NoteBinaryStoreDecodedLength(&size);
+
+            REQUIRE(NoteRequestResponse_fake.call_count > 0);
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request indicates there's nothing to"
+          " read") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddIntToObject(rsp, "length", 0);
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreDecodedLength is called") {
+            const char *err = NoteBinaryStoreDecodedLength(&size);
+
+            REQUIRE(NoteRequestResponse_fake.call_count > 0);
+            THEN("An error is not returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The size out parameter is 0") {
+                CHECK(size == 0);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request indicates there's data "
+          "to read") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddIntToObject(rsp, "length", len);
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreDecodedLength is called") {
+            const char *err = NoteBinaryStoreDecodedLength(&size);
+
+            REQUIRE(NoteRequestResponse_fake.call_count > 0);
+            THEN("An error is not returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The size out parameter is the length value in the "
+                 "card.binary response") {
+                CHECK(size == len);
+            }
+        }
+    }
+
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryStoreEncodedLength_test.cpp b/src/note-c/test/src/NoteBinaryStoreEncodedLength_test.cpp
new file mode 100644
index 0000000..7b24ad3
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryStoreEncodedLength_test.cpp
@@ -0,0 +1,133 @@
+/*!
+ * @file NoteBinaryStoreEncodedLength_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+const char * NoteBinaryStoreEncodedLength(uint32_t *);
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+const uint32_t cobsLen = 10;
+
+namespace
+{
+
+SCENARIO("NoteBinaryStoreEncodedLength")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    uint32_t size = 1;
+
+    GIVEN("Bad parameters are supplied") {
+        WHEN("Length is NULL") {
+            const char *err = NoteBinaryStoreEncodedLength(NULL);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The card.binary request fails") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+
+            return NULL;
+        };
+
+        WHEN("NoteBinaryStoreEncodedLength is called") {
+            const char *err = NoteBinaryStoreEncodedLength(&size);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request has an error") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddStringToObject(rsp, "err", "some error");
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreEncodedLength is called") {
+            const char *err = NoteBinaryStoreEncodedLength(&size);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request indicates there's nothing to"
+          " read") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddIntToObject(rsp, "cobs", 0);
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreEncodedLength is called") {
+            const char *err = NoteBinaryStoreEncodedLength(&size);
+
+            THEN("An error is not returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The size out parameter is 0") {
+                CHECK(size == 0);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request indicates there's data "
+          "to read") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddIntToObject(rsp, "cobs", cobsLen);
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreEncodedLength is called") {
+            const char *err = NoteBinaryStoreEncodedLength(&size);
+
+            THEN("An error is not returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The size out parameter is the cobs value in the card.binary "
+                 "response") {
+                CHECK(size == cobsLen);
+            }
+        }
+    }
+
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryStoreReceive_test.cpp b/src/note-c/test/src/NoteBinaryStoreReceive_test.cpp
new file mode 100644
index 0000000..3161532
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryStoreReceive_test.cpp
@@ -0,0 +1,245 @@
+/*!
+ * @file NoteBinaryStoreReceive_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(uint32_t, NoteBinaryCodecDecode, const uint8_t *, uint32_t, uint8_t *,
+                uint32_t)
+FAKE_VALUE_FUNC(const char *, NoteBinaryStoreEncodedLength, uint32_t *)
+FAKE_VALUE_FUNC(J *, noteTransactionShouldLock, J *, bool)
+FAKE_VALUE_FUNC(const char *, noteChunkedReceive, uint8_t *, uint32_t *, bool,
+                uint32_t, uint32_t *)
+FAKE_VOID_FUNC(noteLockNote)
+FAKE_VOID_FUNC(noteUnlockNote)
+
+// Most of these variables have to be global because they're accessed in
+// lambda functions used as fakes for various note-c functions. They can't be
+// captured by the lambdas because the lambdas need to be convertible to plain
+// old function pointers in order to be used by the fff mocking/fake framework.
+// If a lambda captures anything, it can't be converted in this way, and you get
+// a compiler error.
+uint8_t buf[32];
+uint32_t bufLen = sizeof(buf);
+uint32_t decodedOffset = 0;
+uint32_t decodedLen = 17;
+
+char rawMsg[] = "Hello Blues!";
+uint32_t rawMsgLen = strlen(rawMsg);
+
+namespace
+{
+
+SCENARIO("NoteBinaryStoreReceive")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    // These fakes are the default. Tests below may override them to exercise
+    // different scenarios.
+    NoteNewRequest_fake.custom_fake = [](const char *req) -> J* {
+        return JCreateObject();
+    };
+    NoteBinaryStoreEncodedLength_fake.custom_fake = [](uint32_t *size)
+    -> const char * {
+        *size = bufLen;
+
+        return NULL;
+    };
+    noteTransactionShouldLock_fake.custom_fake = [](J *req, bool) -> J * {
+        J *rsp = JCreateObject();
+        char hash[NOTE_MD5_HASH_STRING_SIZE] = {0};
+        NoteMD5HashString((unsigned char *)rawMsg, rawMsgLen, hash,
+                          NOTE_MD5_HASH_STRING_SIZE);
+        JAddStringToObject(rsp, "status", hash);
+
+        return rsp;
+    };
+
+    GIVEN("Bad parameters are supplied") {
+        WHEN("buffer is NULL") {
+            const char *err = NoteBinaryStoreReceive(NULL, bufLen, decodedOffset, decodedLen);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+        WHEN("bufLen is too small") {
+            const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, bufLen);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+        WHEN("decodedLen is zero") {
+            const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, 0);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("Allocating the card.binary.get request fails") {
+        NoteNewRequest_fake.custom_fake = NULL;
+        NoteNewRequest_fake.return_val = NULL;
+
+        WHEN("NoteBinaryStoreReceive is called") {
+            const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+            REQUIRE(NoteNewRequest_fake.call_count > 0);
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary.get request has an error") {
+        noteTransactionShouldLock_fake.custom_fake = [](J *req, bool) -> J * {
+            J *rsp = JCreateObject();
+            JAddStringToObject(rsp, "err", "some error");
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreReceive is called") {
+            const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+            REQUIRE(noteTransactionShouldLock_fake.call_count > 0);
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("noteChunkedReceive returns an error") {
+        noteChunkedReceive_fake.return_val = "some error";
+
+        WHEN("NoteBinaryStoreReceive is called") {
+            const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+            REQUIRE(noteChunkedReceive_fake.call_count > 0);
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("noteChunkedReceive indicates there's unexpectedly more data "
+          "available") {
+        noteChunkedReceive_fake.custom_fake = [](uint8_t *, uint32_t *, bool,
+        uint32_t, uint32_t *available) -> const char* {
+            *available = 1;
+
+            return NULL;
+        };
+
+        WHEN("NoteBinaryStoreReceive is called") {
+            const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+            REQUIRE(noteChunkedReceive_fake.call_count > 0);
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The binary payload is received") {
+        NoteBinaryCodecDecode_fake.custom_fake = [](const uint8_t *encData, uint32_t encDataLen, uint8_t *decBuf, uint32_t) -> uint32_t {
+            return cobsDecode((uint8_t *)encData, encDataLen, '\n', decBuf);
+        };
+        noteChunkedReceive_fake.custom_fake = [](uint8_t *buffer, uint32_t *size,
+        bool, uint32_t, uint32_t *available) -> const char* {
+            uint32_t outLen = NoteBinaryCodecEncode((uint8_t *)rawMsg, rawMsgLen, buffer, *size);
+
+            buffer[outLen] = '\n';
+            *size = outLen + 1;
+            *available = 0;
+
+            return NULL;
+        };
+
+        AND_GIVEN("The computed MD5 hash doesn't match the status field") {
+            noteTransactionShouldLock_fake.custom_fake = [](J *req, bool) -> J * {
+                J *rsp = JCreateObject();
+                JAddStringToObject(rsp, "status", "garbage");
+
+                return rsp;
+            };
+            decodedLen = rawMsgLen;
+
+            WHEN("NoteBinaryStoreReceive is called") {
+                const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+                REQUIRE(noteChunkedReceive_fake.call_count > 0);
+                REQUIRE(noteTransactionShouldLock_fake.call_count > 0);
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("The decoded length does not match the reqeusted length") {
+            decodedLen = rawMsgLen;
+            NoteBinaryCodecDecode_fake.custom_fake = [](const uint8_t *encData, uint32_t encDataLen, uint8_t *decBuf, uint32_t) -> uint32_t {
+                return (cobsDecode((uint8_t *)encData, encDataLen, '\n', decBuf) - 1);
+            };
+
+            WHEN("NoteBinaryStoreReceive is called") {
+                const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+                REQUIRE(noteChunkedReceive_fake.call_count > 0);
+                REQUIRE(noteTransactionShouldLock_fake.call_count > 0);
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("The computed MD5 matches the status field") {
+            WHEN("NoteBinaryStoreReceive is called") {
+                uint32_t decodedLen = rawMsgLen;
+                const char *err = NoteBinaryStoreReceive(buf, bufLen, decodedOffset, decodedLen);
+
+                REQUIRE(noteChunkedReceive_fake.call_count > 0);
+                THEN("No error is returned") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("The decoded payload is as expected, with no trailing "
+                     "newline") {
+                    CHECK(memcmp(buf, rawMsg, decodedLen) == 0);
+                }
+            }
+        }
+    }
+
+    CHECK(noteLockNote_fake.call_count == noteUnlockNote_fake.call_count);
+
+    RESET_FAKE(noteTransactionShouldLock);
+    RESET_FAKE(NoteBinaryCodecDecode);
+    RESET_FAKE(NoteBinaryStoreEncodedLength);
+    RESET_FAKE(noteChunkedReceive);
+    RESET_FAKE(noteLockNote);
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(noteUnlockNote);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryStoreReset_test.cpp b/src/note-c/test/src/NoteBinaryStoreReset_test.cpp
new file mode 100644
index 0000000..9164cc7
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryStoreReset_test.cpp
@@ -0,0 +1,87 @@
+/*!
+ * @file NoteBinaryStoreReset_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteBinaryStoreReset")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    NoteNewRequest_fake.custom_fake = [](const char *req) -> J * {
+        return JCreateObject();
+    };
+    NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+        JDelete(req);
+        return JCreateObject();
+    };
+
+    GIVEN("NoteNewRequest fails to allocate the card.binary request") {
+        NoteNewRequest_fake.custom_fake = NULL;
+        NoteNewRequest_fake.return_val = NULL;
+
+        WHEN("NoteBinaryStoreReset is called") {
+            const char *err = NoteBinaryStoreReset();
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary request has an error") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddStringToObject(rsp, "err", "some error");
+
+            return rsp;
+        };
+
+        WHEN("NoteBinaryStoreReset is called") {
+            const char *err = NoteBinaryStoreReset();
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the card.binary indicates success") {
+        WHEN("NoteBinaryStoreReset is called") {
+            const char *err = NoteBinaryStoreReset();
+
+            THEN("An error is not returned") {
+                CHECK(err == NULL);
+            }
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteBinaryStoreTransmit_test.cpp b/src/note-c/test/src/NoteBinaryStoreTransmit_test.cpp
new file mode 100644
index 0000000..5de140b
--- /dev/null
+++ b/src/note-c/test/src/NoteBinaryStoreTransmit_test.cpp
@@ -0,0 +1,407 @@
+/*!
+ * @file NoteBinaryStoreTransmit_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+FAKE_VALUE_FUNC(J *, noteTransactionShouldLock, J *, bool)
+FAKE_VALUE_FUNC(const char *, noteChunkedTransmit, uint8_t *, uint32_t, bool)
+FAKE_VOID_FUNC(noteLockNote)
+FAKE_VOID_FUNC(noteUnlockNote)
+
+uint8_t buf[32] = {0xDE, 0xAD, 0xBE, 0xEF};
+uint32_t dataLen = 4;
+uint32_t bufLen = sizeof(buf);
+
+namespace
+{
+
+SCENARIO("NoteBinaryStoreTransmit")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    NoteNewRequest_fake.custom_fake = [](const char *) -> J * {
+        return JCreateObject();
+    };
+
+    GIVEN("Bad parameters are supplied") {
+        WHEN("unencodedData is NULL") {
+            const char *err = NoteBinaryStoreTransmit(NULL, dataLen, bufLen, 0);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response to the initial card.binary request to get the length "
+          "and max parameters indicates a problem") {
+
+        AND_GIVEN("The response is NULL") {
+            NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+                JDelete(req);
+
+                return NULL;
+            };
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("The response has a generic error") {
+            NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+                JDelete(req);
+                J *rsp = JCreateObject();
+                JAddStringToObject(rsp, "err", "some error");
+
+                return rsp;
+            };
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("The max parameter is 0") {
+            NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+                JDelete(req);
+                J *rsp = JCreateObject();
+                JAddIntToObject(rsp, "max", 0);
+
+                return rsp;
+            };
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("The offset doesn't match the length returned by the "
+                  "Notecard") {
+            NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+                JDelete(req);
+                J *rsp = JCreateObject();
+                JAddIntToObject(rsp, "length", dataLen);
+                JAddIntToObject(rsp, "max", dataLen * 2);
+
+                return rsp;
+            };
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("The remaining space implied by max and length is too small "
+                  "to hold the caller's data") {
+
+            AND_GIVEN("The length parameter is 0") {
+                NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+                    JDelete(req);
+                    J *rsp = JCreateObject();
+                    JAddIntToObject(rsp, "length", 0);
+                    JAddIntToObject(rsp, "max", dataLen - 1);
+
+                    return rsp;
+                };
+
+                WHEN("NoteBinaryStoreTransmit is called") {
+                    const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                    THEN("An error is returned") {
+                        CHECK(err != NULL);
+                    }
+                }
+            }
+
+            AND_GIVEN("The length parameter is non-zero and the buffer is being"
+                      " appended to existing data") {
+                size_t currLen = dataLen;
+                NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+                    JDelete(req);
+                    J *rsp = JCreateObject();
+                    JAddIntToObject(rsp, "length", dataLen);
+                    JAddIntToObject(rsp, "max", dataLen * 2 - 1);
+
+                    return rsp;
+                };
+
+                WHEN("NoteBinaryStoreTransmit is called") {
+                    const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, dataLen);
+
+                    THEN("An error is returned") {
+                        CHECK(err != NULL);
+                    }
+                }
+            }
+        }
+    }
+
+    GIVEN("The encoded length is exactly the same size as the "
+          "buffer, leaving no room for the terminating newline") {
+        NoteRequestResponse_fake.custom_fake = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddIntToObject(rsp, "length", 0);
+            JAddIntToObject(rsp, "max", 1024);
+
+            return rsp;
+        };
+
+        // Discover the actual encoded length of the data
+        const uint32_t tempBufLen = cobsEncodedMaxLength(dataLen);
+        uint8_t *tempBuf = (uint8_t *)malloc(tempBufLen);
+        uint32_t encLen = NoteBinaryCodecEncode(buf, dataLen, tempBuf, tempBufLen);
+        REQUIRE(encLen > 0);
+        free(tempBuf);
+
+        WHEN("NoteBinaryStoreTransmit is called") {
+            const char *err = NoteBinaryStoreTransmit(buf, dataLen, encLen, 0);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The initial card.binary response is ok") {
+        auto cardBinaryRspInitial = [](J *req) -> J * {
+            JDelete(req);
+            J *rsp = JCreateObject();
+            JAddIntToObject(rsp, "length", 0);
+            JAddIntToObject(rsp, "max", 1024);
+
+            return rsp;
+        };
+        NoteRequestResponse_fake.custom_fake = cardBinaryRspInitial;
+        uint8_t originalData[sizeof(buf)];
+        memcpy(originalData, buf, dataLen);
+
+        AND_GIVEN("Allocating the card.binary.put request fails") {
+            NoteNewRequest_fake.custom_fake = NULL;
+            J *noteNewReqRetSequence[] = {JCreateObject(), NULL};
+            SET_RETURN_SEQ(NoteNewRequest, noteNewReqRetSequence, 2);
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+
+                THEN("The input buffer contains the original, unencoded data") {
+                    CHECK(memcmp(buf, originalData, dataLen) == 0);
+                }
+            }
+        }
+
+        AND_GIVEN("The card.binary.put request fails") {
+            noteTransactionShouldLock_fake.custom_fake = [](J *req, bool) -> J * {
+                return NULL;
+            };
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+
+                THEN("The input buffer contains the original, unencoded data") {
+                    CHECK(memcmp(buf, originalData, dataLen) == 0);
+                }
+            }
+        }
+
+        AND_GIVEN("noteChunkedTransmit fails") {
+            noteTransactionShouldLock_fake.custom_fake = [](J *req, bool) -> J * {
+                return JCreateObject();
+            };
+            noteChunkedTransmit_fake.return_val = "some error";
+
+            WHEN("NoteBinaryStoreTransmit is called") {
+                const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                THEN("An error is returned") {
+                    CHECK(err != NULL);
+                }
+
+                THEN("The input buffer contains the original, unencoded data") {
+                    CHECK(memcmp(buf, originalData, dataLen) == 0);
+                }
+            }
+        }
+
+        AND_GIVEN("The response to the card.binary request after the "
+                  "transmission indicates a problem") {
+            noteTransactionShouldLock_fake.custom_fake = [](J *req, bool) -> J * {
+                return JCreateObject();
+            };
+            noteChunkedTransmit_fake.return_val = NULL;
+
+            auto initial = [](J *req) -> J * {
+                JDelete(req);
+                J *rsp = JCreateObject();
+                JAddIntToObject(rsp, "length", 0);
+                JAddIntToObject(rsp, "max", 1024);
+
+                return rsp;
+            };
+            J *(*reqRespFakeSequence[])(J *) = {
+                initial,
+                NULL
+            };
+            SET_CUSTOM_FAKE_SEQ(NoteRequestResponse, reqRespFakeSequence, 2);
+
+            AND_GIVEN("The response is NULL") {
+                reqRespFakeSequence[1] = [](J *req) -> J * {
+                    JDelete(req);
+
+                    return NULL;
+                };
+
+                WHEN("NoteBinaryStoreTransmit is called") {
+                    const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                    THEN("An error is returned") {
+                        CHECK(err != NULL);
+                    }
+
+                    THEN("The input buffer contains the original, unencoded "
+                         "data") {
+                        CHECK(memcmp(buf, originalData, dataLen) == 0);
+                    }
+                }
+            }
+
+            AND_GIVEN("The response has a generic error") {
+                reqRespFakeSequence[1] = [](J *req) -> J * {
+                    JDelete(req);
+                    J *rsp = JCreateObject();
+                    JAddStringToObject(rsp, "err", "some error");
+
+                    return rsp;
+                };
+
+                WHEN("NoteBinaryStoreTransmit is called") {
+                    const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                    THEN("An error is returned") {
+                        CHECK(err != NULL);
+                    }
+
+                    THEN("The input buffer contains the original, unencoded "
+                         "data") {
+                        CHECK(memcmp(buf, originalData, dataLen) == 0);
+                    }
+                }
+            }
+
+            AND_GIVEN("The response has repeated {bad-bin} errors until retries"
+                      " are exhausted") {
+                reqRespFakeSequence[1] = [](J *req) -> J * {
+                    JDelete(req);
+                    J *rsp = JCreateObject();
+                    JAddStringToObject(rsp, "err", c_badbinerr);
+
+                    return rsp;
+                };
+
+                WHEN("NoteBinaryStoreTransmit is called") {
+                    const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                    THEN("An error is returned") {
+                        CHECK(err != NULL);
+                    }
+
+                    THEN("The input buffer contains the original, unencoded "
+                         "data") {
+                        CHECK(memcmp(buf, originalData, dataLen) == 0);
+                    }
+                }
+            }
+
+            AND_GIVEN("The response has a {bad-bin} error but a subsequent "
+                      "response is ok") {
+                auto badBin = [](J *req) -> J * {
+                    JDelete(req);
+                    J *rsp = JCreateObject();
+                    JAddStringToObject(rsp, "err", c_badbinerr);
+
+                    return rsp;
+                };
+                auto ok = [](J *req) -> J * {
+                    JDelete(req);
+
+                    return JCreateObject();
+                };
+                J *(*reqRespFakeSequenceSuccess[])(J *) = {
+                    cardBinaryRspInitial,
+                    badBin,
+                    ok
+                };
+                SET_CUSTOM_FAKE_SEQ(NoteRequestResponse,
+                                    reqRespFakeSequenceSuccess, 3);
+
+                WHEN("NoteBinaryStoreTransmit is called") {
+                    const char *err = NoteBinaryStoreTransmit(buf, dataLen, bufLen, 0);
+
+                    THEN("No error is returned") {
+                        CHECK(err == NULL);
+                    }
+
+                    THEN("The input buffer has been modified") {
+                        CHECK(memcmp(buf, originalData, dataLen) != 0);
+                    }
+                }
+            }
+        }
+    }
+
+    CHECK(noteLockNote_fake.call_count == noteUnlockNote_fake.call_count);
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+    RESET_FAKE(noteTransactionShouldLock);
+    RESET_FAKE(noteChunkedTransmit);
+    RESET_FAKE(noteLockNote);
+    RESET_FAKE(noteUnlockNote);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteClearLocation_test.cpp b/src/note-c/test/src/NoteClearLocation_test.cpp
new file mode 100644
index 0000000..ffbe924
--- /dev/null
+++ b/src/note-c/test/src/NoteClearLocation_test.cpp
@@ -0,0 +1,65 @@
+/*!
+ * @file NoteClearLocation_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteClearLocation")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteClearLocation());
+        CHECK(NoteRequest_fake.call_count == 0);
+    }
+
+    SECTION("NoteRequest") {
+        NoteNewRequest_fake.return_val = JCreateObject();
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteClearLocation());
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteClearLocation());
+        }
+
+        CHECK(NoteRequest_fake.call_count > 0);
+
+        JDelete(NoteNewRequest_fake.return_val);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteDebugSyncStatus_test.cpp b/src/note-c/test/src/NoteDebugSyncStatus_test.cpp
new file mode 100644
index 0000000..982a9bf
--- /dev/null
+++ b/src/note-c/test/src/NoteDebugSyncStatus_test.cpp
@@ -0,0 +1,170 @@
+/*!
+ * @file NoteDebugSyncStatus_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "time_mocks.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+FAKE_VOID_FUNC(NoteDebug, const char *)
+
+namespace
+{
+
+SCENARIO("NoteDebugSyncStatus")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    int pollFrequencyMs = 2000;
+    int maxLevel = 3;
+
+    J *req = JCreateObject();
+    REQUIRE(req != NULL);
+    NoteGetMs_fake.custom_fake = NoteGetMsIncrement;
+
+    SECTION("Errors") {
+        SECTION("NoteNewRequest fails") {
+            NoteNewRequest_fake.return_val = NULL;
+
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+        }
+
+        SECTION("NoteRequestResponse fails") {
+            NoteNewRequest_fake.return_val = req;
+            NoteRequestResponse_fake.return_val = NULL;
+
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+        }
+
+        SECTION("Response has error") {
+            NoteNewRequest_fake.return_val = req;
+            J *rsp = JCreateObject();
+            REQUIRE(rsp != NULL);
+            NoteRequestResponse_fake.return_val = rsp;
+            JAddStringToObject(rsp, "err", "an error");
+
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+        }
+    }
+
+    SECTION("Suppression") {
+        NoteNewRequest_fake.return_val = req;
+        J *rsp = JCreateObject();
+        REQUIRE(rsp != NULL);
+        JAddStringToObject(rsp, "err", "an error");
+        NoteRequestResponse_fake.return_val = rsp;
+
+        // This first call should fail because there's an error in the response.
+        // It should save the current millisecond counter and use that to
+        // suppress subsequent calls that come in before the interval implied by
+        // pollFrequencyMs has lapsed.
+        SECTION("Successful suppression") {
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+            // There should be no Notecard request for the second call, since it
+            // should be suppressed.
+            CHECK(NoteRequestResponse_fake.call_count == 1);
+        }
+
+        SECTION("Millisecond rollover") {
+            NoteGetMs_fake.custom_fake = NULL;
+            uint32_t getMsReturnVals[3] = {8000, 9000, 500};
+            SET_RETURN_SEQ(NoteGetMs, getMsReturnVals, 3);
+
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+
+            rsp = JCreateObject();
+            REQUIRE(rsp != NULL);
+            JAddStringToObject(rsp, "err", "an error");
+            NoteRequestResponse_fake.return_val = rsp;
+
+            // This call should not be suppressed, but it will still fail
+            // because there's an error in the response.
+            CHECK(!NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+            // Confirm it wasn't suppressed by making sure a Notecard request
+            // was made for both NoteDebugSyncStatus calls.
+            CHECK(NoteRequestResponse_fake.call_count == 2);
+        }
+    }
+
+    SECTION("Success") {
+        NoteNewRequest_fake.return_val = req;
+        J *rsp = JCreateObject();
+        REQUIRE(rsp != NULL);
+        NoteRequestResponse_fake.return_val = rsp;
+
+        SECTION("No body in response") {
+            CHECK(NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+        }
+
+        SECTION("Response has valid body") {
+            J *body = JCreateObject();
+            REQUIRE(body != NULL);
+            JAddStringToObject(body, "subsystem", "subsystem");
+            JAddStringToObject(body, "text", "text");
+            JAddItemToObject(rsp, "body", body);
+
+            SECTION("Synclog level above max") {
+                JAddNumberToObject(body, "level", maxLevel + 1);
+
+                CHECK(NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+
+                // Synclog level in the response was greater than the max, so we
+                // shouldn't see any NoteDebug calls.
+                CHECK(NoteDebug_fake.call_count == 0);
+            }
+
+            SECTION("Synclog level at max") {
+                JAddNumberToObject(body, "level", maxLevel);
+
+                CHECK(NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+
+                CHECK(NoteDebug_fake.call_count > 0);
+            }
+
+            SECTION("Synclog level below max") {
+                JAddNumberToObject(body, "level", maxLevel - 1);
+
+                CHECK(NoteDebugSyncStatus(pollFrequencyMs, maxLevel));
+
+                CHECK(NoteDebug_fake.call_count > 0);
+            }
+
+            SECTION("Negative max level (log everything)") {
+                JAddNumberToObject(body, "level", 1);
+
+                CHECK(NoteDebugSyncStatus(pollFrequencyMs, -1));
+
+                CHECK(NoteDebug_fake.call_count > 0);
+            }
+        }
+    }
+
+    JDelete(req);
+
+    RESET_FAKE(NoteGetMs);
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+    RESET_FAKE(NoteDebug);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteDebug_test.cpp b/src/note-c/test/src/NoteDebug_test.cpp
new file mode 100644
index 0000000..377dc23
--- /dev/null
+++ b/src/note-c/test/src/NoteDebug_test.cpp
@@ -0,0 +1,127 @@
+/*!
+ * @file NoteDebug_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+typedef struct {
+    char debugBuf[256];
+    size_t debugBufIdx;
+    bool debugOutputCalled;
+} TestState;
+
+TestState state;
+
+size_t MyDebugOutput(const char *line)
+{
+    size_t len = 0;
+    state.debugOutputCalled = true;
+
+    if (line != NULL) {
+        len = strlcpy(state.debugBuf + state.debugBufIdx, line,
+                      sizeof(state.debugBuf) - state.debugBufIdx);
+        state.debugBufIdx += len;
+    }
+
+    return len;
+}
+
+SCENARIO("NoteDebug")
+{
+    memset(&state, 0, sizeof(state));
+
+    SECTION("Hook not set") {
+        CHECK(!noteIsDebugOutputActive());
+
+        NoteDebug(NULL);
+        CHECK(!state.debugOutputCalled);
+    }
+
+    SECTION("Hook set") {
+        NoteSetFnDebugOutput(MyDebugOutput);
+
+        SECTION("Active") {
+            CHECK(noteIsDebugOutputActive());
+        }
+
+        SECTION("Hook called") {
+            NoteDebug(NULL);
+
+#ifdef NOTE_NODEBUG
+            CHECK(!state.debugOutputCalled);
+#else
+            CHECK(state.debugOutputCalled);
+#endif
+        }
+
+        SECTION("NoteDebugln") {
+            NoteDebugln("test");
+            CHECK(!strcmp(state.debugBuf, "test\r\n"));
+        }
+
+        SECTION("NoteDebugIntln") {
+            const char* expectedString;
+
+            SECTION("Just number") {
+                expectedString = "1\r\n";
+                NoteDebugIntln(NULL, 1);
+            }
+
+            SECTION("String and number") {
+                expectedString = "test1\r\n";
+                NoteDebugIntln("test", 1);
+            }
+
+#ifdef NOTE_NODEBUG
+            CHECK(!state.debugOutputCalled);
+#else
+            CHECK(state.debugOutputCalled);
+            CHECK(!strcmp(state.debugBuf, expectedString));
+#endif
+        }
+
+        SECTION("NoteDebugWithLevel") {
+            const char msg[] = "my message";
+
+            SECTION("Debug level messages NOT logged by default") {
+                NOTE_C_LOG_DEBUG(msg);
+
+                CHECK(!state.debugOutputCalled);
+            }
+
+            SECTION("Error level messages logged by default") {
+                NOTE_C_LOG_ERROR(msg);
+
+#ifdef NOTE_NODEBUG
+                CHECK(!state.debugOutputCalled);
+#else
+                CHECK(state.debugOutputCalled);
+                CHECK(strstr(state.debugBuf, msg) != NULL);
+#ifdef NOTE_C_LOG_SHOW_FILE_AND_LINE
+                CHECK(strstr(state.debugBuf, __FILE__) != NULL);
+#endif // NOTE_C_LOG_SHOW_FILE_AND_LINE
+#endif // NOTE_NODEBUG
+            }
+        }
+    }
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteDebugf_test.cpp b/src/note-c/test/src/NoteDebugf_test.cpp
new file mode 100644
index 0000000..50e7f40
--- /dev/null
+++ b/src/note-c/test/src/NoteDebugf_test.cpp
@@ -0,0 +1,49 @@
+/*!
+ * @file NoteDebugf_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+char buf[32] = {0};
+
+size_t DebugHook(const char *text)
+{
+    strcpy(buf, text);
+    return strlen(text);
+}
+
+SCENARIO("NoteDebugf")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+    const char msg[] = "Hello world!";
+    NoteSetFnDebugOutput(DebugHook);
+
+    NoteDebugf("Hello %s!", "world");
+    CHECK(strcmp(buf, msg) == 0);
+    buf[0] = '\0';
+
+    // Unset the hook and make sure it wasn't called again.
+    NoteSetFnDebugOutput(NULL);
+    NoteDebugf("Hello %s!", "world");
+    CHECK(strcmp(buf, "") == 0);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteErrorClean_test.cpp b/src/note-c/test/src/NoteErrorClean_test.cpp
new file mode 100644
index 0000000..6a4d75f
--- /dev/null
+++ b/src/note-c/test/src/NoteErrorClean_test.cpp
@@ -0,0 +1,50 @@
+/*!
+ * @file NoteErrorClean_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+SCENARIO("NoteErrorClean")
+{
+    SECTION("hub.status response") {
+        char str[] = "connected (session open) {connected}";
+
+        NoteErrorClean(str);
+        CHECK(strcmp(str, "connected (session open)") == 0);
+    }
+
+    SECTION("Multiple brace pairs") {
+        char str[] = "connected (session open) {connected} {something else}";
+
+        NoteErrorClean(str);
+        CHECK(strcmp(str, "connected (session open)") == 0);
+    }
+
+    SECTION("No end brace") {
+        char str[] = "connected (session open) {connected";
+
+        NoteErrorClean(str);
+        // String should be unchanged if there's no end brace.
+        CHECK(strcmp(str, "connected (session open) {connected") == 0);
+    }
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteFactoryReset_test.cpp b/src/note-c/test/src/NoteFactoryReset_test.cpp
new file mode 100644
index 0000000..bfa680c
--- /dev/null
+++ b/src/note-c/test/src/NoteFactoryReset_test.cpp
@@ -0,0 +1,85 @@
+/*!
+ * @file NoteFactoryReset_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+FAKE_VALUE_FUNC(bool, NoteReset)
+
+namespace
+{
+
+SCENARIO("NoteFactoryReset")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteFactoryReset(true));
+    }
+
+    SECTION("NoteRequest fails") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+        NoteRequest_fake.return_val = false;
+
+        CHECK(!NoteFactoryReset(true));
+
+        JDelete(req);
+    }
+
+    SECTION("NoteRequest succeeds") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+        NoteRequest_fake.return_val = true;
+        NoteReset_fake.return_val = true;
+
+        SECTION("Delete config") {
+            CHECK(NoteFactoryReset(true));
+            CHECK(JGetBool(req, "delete"));
+        }
+
+        SECTION("Don't delete config") {
+            CHECK(NoteFactoryReset(false));
+            CHECK(!JGetBool(req, "delete"));
+        }
+
+        SECTION("NoteReset fails the first time") {
+            bool noteResetRetVals[] = {false, true};
+            SET_RETURN_SEQ(NoteReset, noteResetRetVals, 2);
+
+            CHECK(NoteFactoryReset(true));
+            CHECK(NoteReset_fake.call_count > 1);
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+    RESET_FAKE(NoteReset);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetContact_test.cpp b/src/note-c/test/src/NoteGetContact_test.cpp
new file mode 100644
index 0000000..0da8f8c
--- /dev/null
+++ b/src/note-c/test/src/NoteGetContact_test.cpp
@@ -0,0 +1,110 @@
+/*!
+ * @file NoteGetContact_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetContact")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char nameBuf[16];
+    // Set the first character of each buffer to something non-zero so that we
+    // can verify that, on failure, each buffer holds the empty string.
+    nameBuf[0] = 'a';
+    char orgBuf[16];
+    orgBuf[0] = 'a';
+    char roleBuf[16];
+    roleBuf[0] = 'a';
+    char emailBuf[16];
+    emailBuf[0] = 'a';
+
+    J *req = JCreateObject();
+    REQUIRE(req != NULL);
+    J *rsp = JCreateObject();
+    REQUIRE(rsp != NULL);
+
+    SECTION("Errors") {
+        SECTION("NoteNewRequest fails") {
+            NoteNewRequest_fake.return_val = NULL;
+        }
+
+        SECTION("NoteRequestResponse fails") {
+            NoteNewRequest_fake.return_val = req;
+            NoteRequestResponse_fake.return_val = NULL;
+        }
+
+        SECTION("Response has error") {
+            J *rsp = JCreateObject();
+            REQUIRE(rsp != NULL);
+            NoteRequestResponse_fake.return_val = rsp;
+            JAddStringToObject(rsp, "err", "an error");
+        }
+
+        CHECK(!NoteGetContact(nameBuf, sizeof(nameBuf), orgBuf, sizeof(orgBuf),
+                              roleBuf, sizeof(roleBuf), emailBuf, sizeof(emailBuf)));
+        CHECK(strcmp(nameBuf, "") == 0);
+        CHECK(strcmp(orgBuf, "") == 0);
+        CHECK(strcmp(roleBuf, "") == 0);
+        CHECK(strcmp(emailBuf, "") == 0);
+
+        JDelete(rsp);
+    }
+
+    SECTION("Success") {
+        char rspName[] = "abc";
+        char rspOrg[] = "blues";
+        char rspRole[] = "engineer";
+        char rspEmail[] = "abc@blues.com";
+        NoteNewRequest_fake.return_val = req;
+        NoteRequestResponse_fake.return_val = rsp;
+        JAddStringToObject(rsp, "name", rspName);
+        JAddStringToObject(rsp, "org", rspOrg);
+        JAddStringToObject(rsp, "role", rspRole);
+        JAddStringToObject(rsp, "email", rspEmail);
+
+        SECTION("NULL buffers") {
+            CHECK(NoteGetContact(NULL, 0, NULL, 0, NULL, 0, NULL, 0));
+        }
+
+        SECTION("Valid buffers") {
+            CHECK(NoteGetContact(nameBuf, sizeof(nameBuf), orgBuf, sizeof(orgBuf),
+                                 roleBuf, sizeof(roleBuf), emailBuf, sizeof(emailBuf)));
+
+            CHECK(strcmp(nameBuf, rspName) == 0);
+            CHECK(strcmp(orgBuf, rspOrg) == 0);
+            CHECK(strcmp(roleBuf, rspRole) == 0);
+            CHECK(strcmp(emailBuf, rspEmail) == 0);
+        }
+    }
+
+    JDelete(req);
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetEnvNumber_test.cpp b/src/note-c/test/src/NoteGetEnvNumber_test.cpp
new file mode 100644
index 0000000..6ffe8c1
--- /dev/null
+++ b/src/note-c/test/src/NoteGetEnvNumber_test.cpp
@@ -0,0 +1,70 @@
+/*!
+ * @file NoteGetEnvNumber_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NoteGetEnv, const char *, const char *, char *, uint32_t)
+
+namespace
+{
+
+const long int num = 112345;
+const char numStr[] = "112345";
+
+bool NoteGetEnvVarExists(const char *variable, const char *defaultVal,
+                         char *buf, uint32_t buflen)
+{
+    strcpy(buf, numStr);
+
+    return true;
+}
+
+bool NoteGetEnvVarNotFound(const char *variable, const char *defaultVal,
+                           char *buf, uint32_t buflen)
+{
+    strcpy(buf, defaultVal);
+
+    return false;
+}
+
+SCENARIO("NoteGetEnvNumber, NoteGetEnvInt")
+{
+    const char var[] = "var";
+    long int defaultVal = -7897;
+
+    SECTION("Var exists") {
+        NoteGetEnv_fake.custom_fake = NoteGetEnvVarExists;
+
+        CHECK(NoteGetEnvNumber(var, defaultVal) == num);
+        CHECK(NoteGetEnvInt(var, defaultVal) == num);
+    }
+
+    SECTION("Var does not exist") {
+        NoteGetEnv_fake.custom_fake = NoteGetEnvVarNotFound;
+
+        CHECK(NoteGetEnvNumber(var, defaultVal) == defaultVal);
+        CHECK(NoteGetEnvInt(var, defaultVal) == defaultVal);
+    }
+
+    RESET_FAKE(NoteGetEnv);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetEnv_test.cpp b/src/note-c/test/src/NoteGetEnv_test.cpp
new file mode 100644
index 0000000..c967d7d
--- /dev/null
+++ b/src/note-c/test/src/NoteGetEnv_test.cpp
@@ -0,0 +1,102 @@
+/*!
+ * @file NoteGetEnv_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetEnv")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char envKey[] = "MyKey";
+    const char defaultVal[] = "my default val";
+    const char nonDefaultVal[] = "a non-default value";
+    char outBuf[32];
+
+    SECTION("NoteNewRequest returns NULL") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteGetEnv(envKey, defaultVal, outBuf, sizeof(outBuf)));
+        CHECK(NoteNewRequest_fake.call_count == 1);
+        // No request should be made if we couldn't allocate the request object.
+        CHECK(NoteRequestResponse_fake.call_count == 0);
+    }
+
+    SECTION("Response is invalid") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Response is NULL") {
+            NoteRequestResponse_fake.return_val = NULL;
+
+            CHECK(!NoteGetEnv(envKey, defaultVal, outBuf, sizeof(outBuf)));
+        }
+
+        SECTION("Response has no text field") {
+            NoteRequestResponse_fake.return_val = JCreateObject();
+
+            // The response doesn't have an error, so we expect success.
+            CHECK(NoteGetEnv(envKey, defaultVal, outBuf, sizeof(outBuf)));
+        }
+
+        SECTION("Response has an error") {
+            J *resp = JCreateObject();
+            JAddStringToObject(resp, "err", "an error");
+            NoteRequestResponse_fake.return_val = resp;
+
+            CHECK(!NoteGetEnv(envKey, defaultVal, outBuf, sizeof(outBuf)));
+        }
+
+        CHECK(NoteNewRequest_fake.call_count == 1);
+        CHECK(NoteRequestResponse_fake.call_count == 1);
+        // Ensure the default value was copied into outBuf.
+        CHECK(!strcmp(outBuf, defaultVal));
+
+        JDelete(req);
+    }
+
+    SECTION("Response is valid") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+        J *resp = JCreateObject();
+        JAddStringToObject(resp, "text", "a non-default value");
+        NoteRequestResponse_fake.return_val = resp;
+
+        CHECK(NoteGetEnv(envKey, defaultVal, outBuf, sizeof(outBuf)));
+        CHECK(NoteNewRequest_fake.call_count == 1);
+        CHECK(NoteRequestResponse_fake.call_count == 1);
+        CHECK(!strcmp(outBuf, nonDefaultVal));
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetLocationMode_test.cpp b/src/note-c/test/src/NoteGetLocationMode_test.cpp
new file mode 100644
index 0000000..4f8ecd3
--- /dev/null
+++ b/src/note-c/test/src/NoteGetLocationMode_test.cpp
@@ -0,0 +1,67 @@
+/*!
+ * @file NoteGetLocationMode_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetLocationMode")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char modeBuf[32];
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetLocationMode(modeBuf, sizeof(modeBuf)));
+    }
+
+    SECTION("Response") {
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        SECTION("Error in response") {
+            const char errMsg[] = "an error";
+            JAddStringToObject(resp, "err", errMsg);
+
+            CHECK(!NoteGetLocationMode(modeBuf, sizeof(modeBuf)));
+        }
+
+        SECTION("Valid") {
+            char mode[] = "continuous";
+            JAddStringToObject(resp, "mode", mode);
+
+            CHECK(NoteGetLocationMode(modeBuf, sizeof(modeBuf)));
+            CHECK(!strcmp(modeBuf, modeBuf));
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetLocation_test.cpp b/src/note-c/test/src/NoteGetLocation_test.cpp
new file mode 100644
index 0000000..29ebc53
--- /dev/null
+++ b/src/note-c/test/src/NoteGetLocation_test.cpp
@@ -0,0 +1,72 @@
+/*!
+ * @file NoteGetLocation_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetLocation")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    JNUMBER lat = 0;
+    JNUMBER lon = 0;
+    JTIME time = 0;
+    char statusBuf[128];
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetLocation(&lat, &lon, &time, statusBuf,
+                               sizeof(statusBuf)));
+    }
+
+    SECTION("Response") {
+        const char respStatus[] = "GPS updated (58 sec, 41dB SNR, 9 sats) "
+                                  "{gps-active} {gps-signal} {gps-sats} {gps}";
+        const float respLat = 42.577600;
+        const float respLon = -70.871340;
+        const JTIME respTime = 1598554399;
+
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        JAddStringToObject(resp, "status", respStatus);
+        JAddNumberToObject(resp, "lat", respLat);
+        JAddNumberToObject(resp, "lon", respLon);
+        JAddIntToObject(resp, "time", respTime);
+        NoteRequestResponse_fake.return_val = resp;
+
+        CHECK(NoteGetLocation(&lat, &lon, &time, statusBuf, sizeof(statusBuf)));
+        CHECK(!strcmp(statusBuf, respStatus));
+        CHECK(lat == respLat);
+        CHECK(lon == respLon);
+        CHECK(time == respTime);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetNetStatus_test.cpp b/src/note-c/test/src/NoteGetNetStatus_test.cpp
new file mode 100644
index 0000000..99dbd0a
--- /dev/null
+++ b/src/note-c/test/src/NoteGetNetStatus_test.cpp
@@ -0,0 +1,67 @@
+/*!
+ * @file NoteGetNetStatus_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetNetStatus")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char statusBuf[64];
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetNetStatus(statusBuf, sizeof(statusBuf)));
+    }
+
+    SECTION("Response") {
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        SECTION("Error in response") {
+            const char errMsg[] = "an error";
+            JAddStringToObject(resp, "err", errMsg);
+
+            CHECK(!NoteGetNetStatus(statusBuf, sizeof(statusBuf)));
+        }
+
+        SECTION("Valid") {
+            char status[] = "connected (session open) {connected}";
+            JAddStringToObject(resp, "status", status);
+
+            CHECK(NoteGetNetStatus(statusBuf, sizeof(statusBuf)));
+            CHECK(!strcmp(statusBuf, status));
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetServiceConfig_test.cpp b/src/note-c/test/src/NoteGetServiceConfig_test.cpp
new file mode 100644
index 0000000..192e49c
--- /dev/null
+++ b/src/note-c/test/src/NoteGetServiceConfig_test.cpp
@@ -0,0 +1,99 @@
+/*!
+ * @file NoteGetServiceConfig_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetServiceConfig")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const size_t BUF_SIZE = 64;
+    const char zeros[BUF_SIZE] = {0};
+    // Set first element of all these buffers to non-zero so we can verify
+    // they're zero'd out when they should be.
+    char prodBuf[BUF_SIZE] = {1};
+    char serviceBuf[BUF_SIZE] = {1};
+    char deviceBuf[BUF_SIZE] = {1};
+    char snBuf[BUF_SIZE] = {1};
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetServiceConfig(prodBuf, sizeof(prodBuf), serviceBuf,
+                                    sizeof(serviceBuf), deviceBuf, sizeof(deviceBuf), snBuf,
+                                    sizeof(snBuf)));
+        CHECK(!memcmp(prodBuf, zeros, sizeof(prodBuf)));
+        CHECK(!memcmp(serviceBuf, zeros, sizeof(serviceBuf)));
+        CHECK(!memcmp(deviceBuf, zeros, sizeof(deviceBuf)));
+        CHECK(!memcmp(snBuf, zeros, sizeof(snBuf)));
+    }
+
+    SECTION("Response") {
+        const char respProd[] = "com.your-company.your-name:your_product";
+        const char respService[] = "a.notefile.net";
+        const char respDev[] = "dev:000000000000000";
+        const char respSn[] = "your-serial-number";
+
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        JAddStringToObject(resp, "product", respProd);
+        JAddStringToObject(resp, "host", respService);
+        JAddStringToObject(resp, "device", respDev);
+        JAddStringToObject(resp, "sn", respSn);
+        NoteRequestResponse_fake.return_val = resp;
+
+        CHECK(NoteGetServiceConfig(prodBuf, sizeof(prodBuf), serviceBuf,
+                                   sizeof(serviceBuf), deviceBuf, sizeof(deviceBuf), snBuf,
+                                   sizeof(snBuf)));
+        CHECK(!strcmp(prodBuf, respProd));
+        CHECK(!strcmp(serviceBuf, respService));
+        CHECK(!strcmp(deviceBuf, respDev));
+        CHECK(!strcmp(snBuf, respSn));
+
+        SECTION("Subsequent no response returns cached values") {
+            NoteRequestResponse_fake.return_val = NULL;
+
+            memset(prodBuf, 0, sizeof(prodBuf));
+            memset(serviceBuf, 0, sizeof(serviceBuf));
+            memset(deviceBuf, 0, sizeof(deviceBuf));
+            memset(snBuf, 0, sizeof(snBuf));
+
+            CHECK(!NoteGetServiceConfig(prodBuf, sizeof(prodBuf), serviceBuf,
+                                        sizeof(serviceBuf), deviceBuf, sizeof(deviceBuf), snBuf,
+                                        sizeof(snBuf)));
+            CHECK(!strcmp(prodBuf, respProd));
+            CHECK(!strcmp(serviceBuf, respService));
+            CHECK(!strcmp(deviceBuf, respDev));
+            CHECK(!strcmp(snBuf, respSn));
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetStatus_test.cpp b/src/note-c/test/src/NoteGetStatus_test.cpp
new file mode 100644
index 0000000..628904a
--- /dev/null
+++ b/src/note-c/test/src/NoteGetStatus_test.cpp
@@ -0,0 +1,98 @@
+/*!
+ * @file NoteGetStatus_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetStatus")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char statusBuf[16] = {1};
+    JTIME bootTime = 1;
+    bool usb = true;
+    bool signals = true;
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetStatus(statusBuf, sizeof(statusBuf), &bootTime, &usb,
+                             &signals));
+        CHECK(!strcmp(statusBuf, ""));
+        CHECK(bootTime == 0);
+        CHECK(!usb);
+        CHECK(!signals);
+    }
+
+    SECTION("Response") {
+        const char respStatus[] = "{normal}";
+        JTIME respBootTime = 1599684765;
+        bool respUsb = true;
+        bool respConnected;
+        uint32_t respSignals = 1;
+        bool expectedSignals;
+
+        usb = false;
+        signals = false;
+
+        SECTION("Connected") {
+            respConnected = true;
+            expectedSignals = true;
+        }
+
+        SECTION("Not connected") {
+            respConnected = false;
+            expectedSignals = false;
+        }
+
+        SECTION("Connected but no signals") {
+            respConnected = true;
+            respSignals = 0;
+            expectedSignals = false;
+        }
+
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        JAddStringToObject(resp, "status", respStatus);
+        JAddIntToObject(resp, "time", respBootTime);
+        JAddBoolToObject(resp, "usb", respUsb);
+        JAddBoolToObject(resp, "connected", respConnected);
+        JAddNumberToObject(resp, "signals", respSignals);
+        NoteRequestResponse_fake.return_val = resp;
+
+        CHECK(NoteGetStatus(statusBuf, sizeof(statusBuf), &bootTime, &usb,
+                            &signals));
+        CHECK(!strcmp(statusBuf, respStatus));
+        CHECK(bootTime == respBootTime);
+        CHECK(usb);
+        CHECK(signals == expectedSignals);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetTemperature_test.cpp b/src/note-c/test/src/NoteGetTemperature_test.cpp
new file mode 100644
index 0000000..aa0eee3
--- /dev/null
+++ b/src/note-c/test/src/NoteGetTemperature_test.cpp
@@ -0,0 +1,81 @@
+/*!
+ * @file NoteGetTemperature_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetTemperature")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    JNUMBER temp = 1.0;
+    J *req = JCreateObject();
+    REQUIRE(req != NULL);
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteGetTemperature(&temp));
+        CHECK(temp == 0);
+    }
+
+    SECTION("NoteRequestResponse fails") {
+        NoteNewRequest_fake.return_val = req;
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetTemperature(&temp));
+        CHECK(temp == 0);
+    }
+
+    SECTION("NoteRequestResponse succeeds") {
+        NoteNewRequest_fake.return_val = req;
+        J *rsp = JCreateObject();
+        REQUIRE(rsp != NULL);
+        NoteRequestResponse_fake.return_val = rsp;
+
+        SECTION("Response has error") {
+            JAddStringToObject(rsp, "err", "an error");
+
+            CHECK(!NoteGetTemperature(&temp));
+            CHECK(temp == 0);
+        }
+
+        SECTION("Response ok") {
+            JNUMBER rspTemp = 24.5;
+            JAddNumberToObject(rsp, "value", rspTemp);
+
+            CHECK(NoteGetTemperature(&temp));
+            CHECK(temp == rspTemp);
+        }
+    }
+
+    JDelete(req);
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetVersion_test.cpp b/src/note-c/test/src/NoteGetVersion_test.cpp
new file mode 100644
index 0000000..a79b7a3
--- /dev/null
+++ b/src/note-c/test/src/NoteGetVersion_test.cpp
@@ -0,0 +1,67 @@
+/*!
+ * @file NoteGetVersion_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetVersion")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char versionBuf[32];
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetVersion(versionBuf, sizeof(versionBuf)));
+    }
+
+    SECTION("Response") {
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        SECTION("Error in response") {
+            const char errMsg[] = "an error";
+            JAddStringToObject(resp, "err", errMsg);
+
+            CHECK(!NoteGetVersion(versionBuf, sizeof(versionBuf)));
+        }
+
+        SECTION("Valid") {
+            char version[] = "notecard-3.5.1.15545";
+            JAddStringToObject(resp, "version", version);
+
+            CHECK(NoteGetVersion(versionBuf, sizeof(versionBuf)));
+            CHECK(!strcmp(versionBuf, version));
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteGetVoltage_test.cpp b/src/note-c/test/src/NoteGetVoltage_test.cpp
new file mode 100644
index 0000000..b1447dc
--- /dev/null
+++ b/src/note-c/test/src/NoteGetVoltage_test.cpp
@@ -0,0 +1,81 @@
+/*!
+ * @file NoteGetVoltage_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteGetVoltage")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    JNUMBER voltage = 1.0;
+    J *req = JCreateObject();
+    REQUIRE(req != NULL);
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteGetVoltage(&voltage));
+        CHECK(voltage == 0);
+    }
+
+    SECTION("NoteRequestResponse fails") {
+        NoteNewRequest_fake.return_val = req;
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteGetVoltage(&voltage));
+        CHECK(voltage == 0);
+    }
+
+    SECTION("NoteRequestResponse succeeds") {
+        NoteNewRequest_fake.return_val = req;
+        J *rsp = JCreateObject();
+        REQUIRE(rsp != NULL);
+        NoteRequestResponse_fake.return_val = rsp;
+
+        SECTION("Response has error") {
+            JAddStringToObject(rsp, "err", "an error");
+
+            CHECK(!NoteGetVoltage(&voltage));
+            CHECK(voltage == 0);
+        }
+
+        SECTION("Response ok") {
+            JNUMBER rspVoltage = 3.3;
+            JAddNumberToObject(rsp, "value", rspVoltage);
+
+            CHECK(NoteGetVoltage(&voltage));
+            CHECK(voltage == rspVoltage);
+        }
+    }
+
+    JDelete(req);
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteIsConnected_test.cpp b/src/note-c/test/src/NoteIsConnected_test.cpp
new file mode 100644
index 0000000..df909ad
--- /dev/null
+++ b/src/note-c/test/src/NoteIsConnected_test.cpp
@@ -0,0 +1,69 @@
+/*!
+ * @file NoteIsConnected_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteIsConnected")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteIsConnected());
+    }
+
+    SECTION("Response") {
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        SECTION("Error in response") {
+            const char errMsg[] = "an error";
+            JAddStringToObject(resp, "err", errMsg);
+
+            CHECK(!NoteIsConnected());
+        }
+
+        SECTION("Not connected") {
+            JAddBoolToObject(resp, "connected", false);
+
+            CHECK(!NoteIsConnected());
+        }
+
+        SECTION("Connected") {
+            JAddBoolToObject(resp, "connected", true);
+
+            CHECK(NoteIsConnected());
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteLocalTimeST_test.cpp b/src/note-c/test/src/NoteLocalTimeST_test.cpp
new file mode 100644
index 0000000..58e7484
--- /dev/null
+++ b/src/note-c/test/src/NoteLocalTimeST_test.cpp
@@ -0,0 +1,100 @@
+/*!
+ * @file NoteLocalTimeST_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "time_mocks.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NoteTimeValidST)
+FAKE_VALUE_FUNC(JTIME, NoteTimeST)
+FAKE_VALUE_FUNC(bool, NoteRegion, char **, char **, char **, int *)
+
+namespace
+{
+
+char country[] = "US";
+char area[] = "CA";
+char zone[] = "PDT";
+int offset = -420; // PDT = UTC-7
+
+bool NoteRegionFake(char **retCountry, char **retArea, char **retZone,
+                    int *retZoneOffset)
+{
+    if (retCountry != NULL) {
+        *retCountry = country;
+    }
+    if (retArea != NULL) {
+        *retArea = area;
+    }
+    if (retZone != NULL) {
+        *retZone = zone;
+    }
+    if (retZoneOffset != NULL) {
+        *retZoneOffset = offset;
+    }
+
+    return true;
+}
+
+SCENARIO("NoteLocalTimeST")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    uint16_t retYear;
+    uint8_t retMonth;
+    uint8_t retDay;
+    uint8_t retHour;
+    uint8_t retMinute;
+    uint8_t retSecond;
+    char *retWeekday;
+    char *retZone;
+
+    SECTION("Time not valid") {
+        NoteTimeValidST_fake.return_val = false;
+
+        CHECK(!NoteLocalTimeST(&retYear, &retMonth, &retDay, &retHour,
+                               &retMinute, &retSecond, &retWeekday, &retZone));
+    }
+
+    SECTION("Time valid") {
+        // Thu Mar 16 02:44:16 PM PDT 2023.
+        JTIME baseTime = 1679003056;
+        NoteTimeST_fake.return_val = baseTime;
+        NoteRegion_fake.custom_fake = NoteRegionFake;
+        NoteTimeValidST_fake.return_val = true;
+
+        CHECK(NoteLocalTimeST(&retYear, &retMonth, &retDay, &retHour,
+                              &retMinute, &retSecond, &retWeekday, &retZone));
+        CHECK(retYear == 2023);
+        CHECK(retMonth == 3);
+        CHECK(retDay == 16);
+        CHECK(retHour == 14);
+        CHECK(retMinute == 44);
+        CHECK(retSecond == 16);
+        CHECK(strcmp(retWeekday, "Thu") == 0);
+        CHECK(strcmp(retZone, zone) == 0);
+    }
+
+    RESET_FAKE(NoteTimeValidST);
+    RESET_FAKE(NoteTimeST);
+    RESET_FAKE(NoteRegion);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteLocationValid_test.cpp b/src/note-c/test/src/NoteLocationValid_test.cpp
new file mode 100644
index 0000000..d0e0402
--- /dev/null
+++ b/src/note-c/test/src/NoteLocationValid_test.cpp
@@ -0,0 +1,79 @@
+/*!
+ * @file NoteLocationValid_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteLocationValid")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char errBuf[32];
+
+    SECTION("No response") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        CHECK(!NoteLocationValid(errBuf, sizeof(errBuf)));
+    }
+
+    SECTION("Response") {
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        SECTION("Error in response") {
+            const char errMsg[] = "an error";
+            JAddStringToObject(resp, "err", errMsg);
+
+            CHECK(!NoteLocationValid(errBuf, sizeof(errBuf)));
+            CHECK(!strcmp(errBuf, errMsg));
+        }
+
+        SECTION("Location off") {
+            JAddStringToObject(resp, "mode", "off");
+
+            CHECK(NoteLocationValid(errBuf, sizeof(errBuf)));
+            CHECK(!strcmp(errBuf, ""));
+        }
+
+        SECTION("If previously valid, should stay valid if time-suppressed") {
+            CHECK(NoteLocationValid(errBuf, sizeof(errBuf)));
+            CHECK(!strcmp(errBuf, ""));
+
+            CHECK(NoteLocationValidST(errBuf, sizeof(errBuf)));
+            CHECK(!strcmp(errBuf, ""));
+
+            // The valid result from the first NoteLocationValid call should be
+            // cached and no subsequent NoteRequestResponse call should be made.
+            CHECK(NoteRequestResponse_fake.call_count == 1);
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteNewCommand_test.cpp b/src/note-c/test/src/NoteNewCommand_test.cpp
new file mode 100644
index 0000000..9cbeb94
--- /dev/null
+++ b/src/note-c/test/src/NoteNewCommand_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file NoteNewCommand_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, JCreateObject)
+
+namespace
+{
+
+SCENARIO("NoteNewCommand")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char req[] = "{ \"req\": \"card.info\" }";
+
+    SECTION("JCreateObject fails") {
+        JCreateObject_fake.return_val = NULL;
+
+        CHECK(!NoteNewCommand(req));
+    }
+
+    SECTION("JCreateObject succeeds") {
+        J* reqJson = (J *)NoteMalloc(sizeof(J));
+        REQUIRE(reqJson != NULL);
+        memset(reqJson, 0, sizeof(J));
+        reqJson->type = JObject;
+        JCreateObject_fake.return_val = reqJson;
+
+        CHECK(NoteNewCommand(req));
+
+        JDelete(reqJson);
+    }
+
+    RESET_FAKE(JCreateObject);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteNewRequest_test.cpp b/src/note-c/test/src/NoteNewRequest_test.cpp
new file mode 100644
index 0000000..c0a8846
--- /dev/null
+++ b/src/note-c/test/src/NoteNewRequest_test.cpp
@@ -0,0 +1,56 @@
+/*!
+ * @file NoteNewRequest_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, JCreateObject)
+
+namespace
+{
+
+SCENARIO("NoteNewRequest")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char req[] = "{ \"req\": \"card.info\" }";
+
+    SECTION("JCreateObject fails") {
+        JCreateObject_fake.return_val = NULL;
+
+        CHECK(!NoteNewRequest(req));
+    }
+
+    SECTION("JCreateObject succeeds") {
+        J* reqJson = (J *)NoteMalloc(sizeof(J));
+        REQUIRE(reqJson != NULL);
+        memset(reqJson, 0, sizeof(J));
+        reqJson->type = JObject;
+        JCreateObject_fake.return_val = reqJson;
+
+        CHECK(NoteNewRequest(req));
+
+        JDelete(reqJson);
+    }
+
+    RESET_FAKE(JCreateObject);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NotePayloadRetrieveAfterSleep_test.cpp b/src/note-c/test/src/NotePayloadRetrieveAfterSleep_test.cpp
new file mode 100644
index 0000000..1663914
--- /dev/null
+++ b/src/note-c/test/src/NotePayloadRetrieveAfterSleep_test.cpp
@@ -0,0 +1,143 @@
+/*!
+ * @file NotePayloadRetrieveAfterSleep_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NotePayloadRetrieveAfterSleep")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+
+    NoteMalloc_fake.custom_fake = malloc;
+
+    NotePayloadDesc payload = {0};
+
+    SECTION("No payload") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        J *resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteNewRequest_fake.return_val = req;
+        NoteRequestResponse_fake.return_val = resp;
+
+        CHECK(NotePayloadRetrieveAfterSleep(NULL));
+
+        JDelete(req);
+    }
+
+    SECTION("With payload") {
+
+        SECTION("Errors") {
+
+            SECTION("NoteNewRequest fails") {
+                NoteNewRequest_fake.return_val = NULL;
+
+                CHECK(!NotePayloadRetrieveAfterSleep(&payload));
+            }
+
+            SECTION("NoteRequestResponse fails") {
+                J *req = JCreateObject();
+                REQUIRE(req != NULL);
+                NoteNewRequest_fake.return_val = req;
+                NoteRequestResponse_fake.return_val = NULL;
+
+                CHECK(!NotePayloadRetrieveAfterSleep(&payload));
+
+                JDelete(req);
+            }
+
+            SECTION("Response has an error") {
+                J *req = JCreateObject();
+                REQUIRE(req != NULL);
+                J *resp = JCreateObject();
+                REQUIRE(resp != NULL);
+                JAddStringToObject(resp, "err", "an error");
+                NoteNewRequest_fake.return_val = req;
+                NoteRequestResponse_fake.return_val = resp;
+
+                CHECK(!NotePayloadRetrieveAfterSleep(&payload));
+
+                JDelete(req);
+            }
+
+            SECTION("Response has no payload") {
+                J *req = JCreateObject();
+                REQUIRE(req != NULL);
+                J *resp = JCreateObject();
+                REQUIRE(resp != NULL);
+                NoteNewRequest_fake.return_val = req;
+                NoteRequestResponse_fake.return_val = resp;
+
+                CHECK(!NotePayloadRetrieveAfterSleep(&payload));
+
+                JDelete(req);
+            }
+
+            SECTION("Payload output buffer allocation fails") {
+                J *req = JCreateObject();
+                REQUIRE(req != NULL);
+                J *resp = JCreateObject();
+                REQUIRE(resp != NULL);
+                JAddStringToObject(resp, "payload", "placeholder payload");
+                NoteNewRequest_fake.return_val = req;
+                NoteRequestResponse_fake.return_val = resp;
+                NoteMalloc_fake.custom_fake = NULL;
+                NoteMalloc_fake.return_val = NULL;
+
+                CHECK(!NotePayloadRetrieveAfterSleep(&payload));
+
+                JDelete(req);
+            }
+        }
+
+        SECTION("Success") {
+            J *req = JCreateObject();
+            REQUIRE(req != NULL);
+            J *resp = JCreateObject();
+            REQUIRE(resp != NULL);
+            const char decodedText[] = "it worked";
+            const char encodedText[] = "aXQgd29ya2Vk";
+            JAddStringToObject(resp, "payload", encodedText);
+            JAddNumberToObject(resp, "time", 1599769214);
+            NoteNewRequest_fake.return_val = req;
+            NoteRequestResponse_fake.return_val = resp;
+
+            CHECK(NotePayloadRetrieveAfterSleep(&payload));
+            CHECK(memcmp(payload.data, decodedText, payload.length) == 0);
+
+            JDelete(req);
+        }
+    }
+
+    NotePayloadFree(&payload);
+
+    RESET_FAKE(NoteMalloc);
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NotePayloadSaveAndSleep_test.cpp b/src/note-c/test/src/NotePayloadSaveAndSleep_test.cpp
new file mode 100644
index 0000000..1265ab3
--- /dev/null
+++ b/src/note-c/test/src/NotePayloadSaveAndSleep_test.cpp
@@ -0,0 +1,76 @@
+/*!
+ * @file NotePayloadSaveAndSleep_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+FAKE_VALUE_FUNC(bool, NoteSleep, char *, uint32_t, const char *)
+
+namespace
+{
+
+SCENARIO("NotePayloadSaveAndSleep")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+
+    uint8_t data[] = {0xDE, 0xAD, 0xBE, 0xEF};
+    NotePayloadDesc payload;
+    payload.data = data;
+    payload.alloc = sizeof(data);
+    payload.length = sizeof(data);
+
+    SECTION("Success") {
+        NoteMalloc_fake.custom_fake = malloc;
+        NoteSleep_fake.return_val = true;
+
+        SECTION("Valid payload") {
+            CHECK(NotePayloadSaveAndSleep(&payload, 30, NULL));
+        }
+
+        SECTION("Payload NULL data") {
+            payload.data = NULL;
+            CHECK(NotePayloadSaveAndSleep(&payload, 30, NULL));
+        }
+
+        SECTION("Payload 0 length") {
+            payload.length = 0;
+            CHECK(NotePayloadSaveAndSleep(&payload, 30, NULL));
+        }
+    }
+
+    SECTION("NoteMalloc fails") {
+        NoteMalloc_fake.return_val = NULL;
+
+        CHECK(!NotePayloadSaveAndSleep(&payload, 30, NULL));
+    }
+
+    SECTION("NoteSleep fails") {
+        NoteMalloc_fake.custom_fake = malloc;
+        NoteSleep_fake.return_val = false;
+
+        CHECK(!NotePayloadSaveAndSleep(&payload, 30, NULL));
+    }
+
+    RESET_FAKE(NoteMalloc);
+    RESET_FAKE(NoteSleep);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NotePayload_test.cpp b/src/note-c/test/src/NotePayload_test.cpp
new file mode 100644
index 0000000..852b671
--- /dev/null
+++ b/src/note-c/test/src/NotePayload_test.cpp
@@ -0,0 +1,145 @@
+/*!
+ * @file NotePayload_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+// Mocking NoteMalloc so that we can count invocations. See the "Force
+// reallocation" test below.
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+
+namespace
+{
+
+void *MallocWrapper(size_t size)
+{
+    return malloc(size);
+}
+
+SCENARIO("NotePayload")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+
+    NoteMalloc_fake.custom_fake = MallocWrapper;
+
+    NotePayloadDesc desc = {0, 0, 0};
+    const char* segIds[] = {
+        "MYID",
+        "ANID"
+    };
+    unsigned char segDataShort[] = {0xDE, 0xAD, 0xBE, 0xEF};
+    unsigned char segDataLong[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    uint8_t *findData = NULL;
+    uint32_t findLen = 1;
+
+    SECTION("Add and find") {
+
+        CHECK(NotePayloadAddSegment(&desc, segIds[0], segDataShort,
+                                    sizeof(segDataShort)));
+        CHECK(NotePayloadAddSegment(&desc, segIds[1], segDataLong,
+                                    sizeof(segDataLong)));
+
+        SECTION("Add and find segments") {
+            CHECK(NotePayloadFindSegment(&desc, segIds[0], &findData,
+                                         &findLen));
+            CHECK(sizeof(segDataShort) == findLen);
+            CHECK(!memcmp(segDataShort, findData, findLen));
+
+            CHECK(NotePayloadFindSegment(&desc, segIds[1], &findData,
+                                         &findLen));
+            CHECK(sizeof(segDataLong) == findLen);
+            CHECK(!memcmp(segDataLong, findData, findLen));
+        }
+
+        SECTION("Add and try to find non-existent segment") {
+            CHECK(!NotePayloadFindSegment(&desc, "BLUE", &findData,
+                                          &findLen));
+            CHECK(findData == NULL);
+            CHECK(findLen == 0);
+        }
+    }
+
+    SECTION("Add two segments with the same ID") {
+        CHECK(NotePayloadAddSegment(&desc, segIds[0], segDataLong,
+                                    sizeof(segDataLong)));
+        CHECK(NotePayloadAddSegment(&desc, segIds[0], segDataShort,
+                                    sizeof(segDataShort)));
+
+        CHECK(NotePayloadFindSegment(&desc, segIds[0], &findData, &findLen));
+        // Ensure that we found the first segment added.
+        REQUIRE(sizeof(segDataLong) == findLen);
+        CHECK(!memcmp(segDataLong, findData, findLen));
+    }
+
+    SECTION("NotePayloadGetSegment") {
+        const char segId[] = "MYID";
+        unsigned char segData[] = {0xDE, 0xAD, 0xBE, 0xEF};
+        unsigned char segCopy[] = {0, 0, 0, 0};
+        unsigned char* segCopyOrig = segCopy;
+
+        CHECK(NotePayloadAddSegment(&desc, segId, segData, sizeof(segData)));
+
+        SECTION("Copied") {
+            CHECK(NotePayloadGetSegment(&desc, segId, segCopy,
+                                        sizeof(segData)));
+            // Ensure NotePayloadGetSegment actually returned a copy and didn't
+            // just return a pointer to the segment.
+            CHECK(segCopyOrig == segCopy);
+        }
+
+        SECTION("Incorrect length") {
+            CHECK(!NotePayloadGetSegment(&desc, segId, segCopy,
+                                         sizeof(segData)) + 1);
+        }
+    }
+
+    SECTION("Force reallocation") {
+        // NotePayloadAddSegment allocates 512 bytes up front to hold data.
+        // Adding this 1 kB segment will force allocation of a larger buffer.
+        unsigned char segDataOneK[1024];
+        for (size_t i = 0; i < sizeof(segDataOneK); ++i) {
+            segDataOneK[i] = i;
+        }
+
+        CHECK(NotePayloadAddSegment(&desc, segIds[0], segDataLong,
+                                    sizeof(segDataLong)));
+        CHECK(NotePayloadAddSegment(&desc, segIds[1], segDataOneK,
+                                    sizeof(segDataOneK)));
+
+        // Ensure there was a second allocation.
+        CHECK(NoteMalloc_fake.call_count == 2);
+
+        CHECK(NotePayloadFindSegment(&desc, segIds[0], &findData,
+                                     &findLen));
+        REQUIRE(sizeof(segDataLong) == findLen);
+        CHECK(!memcmp(segDataLong, findData, findLen));
+
+        CHECK(NotePayloadFindSegment(&desc, segIds[1], &findData,
+                                     &findLen));
+        REQUIRE(sizeof(segDataOneK) == findLen);
+        CHECK(!memcmp(segDataOneK, findData, findLen));
+    }
+
+    NotePayloadFree(&desc);
+
+    RESET_FAKE(NoteMalloc);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NotePrint_test.cpp b/src/note-c/test/src/NotePrint_test.cpp
new file mode 100644
index 0000000..85498ab
--- /dev/null
+++ b/src/note-c/test/src/NotePrint_test.cpp
@@ -0,0 +1,86 @@
+/*!
+ * @file NotePrint_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, noteIsDebugOutputActive)
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+FAKE_VOID_FUNC(NoteDebug, const char *)
+
+namespace
+{
+
+SCENARIO("NotePrint")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char msg[] = "Hello world!";
+
+    SECTION("Debug") {
+        noteIsDebugOutputActive_fake.return_val = true;
+
+        CHECK(NotePrint(msg));
+        CHECK(NoteDebug_fake.call_count > 0);
+    }
+
+    SECTION("card.log") {
+        noteIsDebugOutputActive_fake.return_val = false;
+
+        SECTION("NoteNewRequest fails") {
+            NoteNewRequest_fake.return_val = NULL;
+
+            CHECK(!NotePrint(msg));
+        }
+
+        SECTION("NoteNewRequest succeeds") {
+            J *req = JCreateObject();
+            REQUIRE(req != NULL);
+            NoteNewRequest_fake.return_val = req;
+
+            SECTION("NoteRequest fails") {
+                NoteRequest_fake.return_val = false;
+
+                CHECK(!NotePrint(msg));
+            }
+
+            SECTION("NoteRequest succeeds") {
+                NoteRequest_fake.return_val = true;
+
+                CHECK(NotePrint(msg));
+                CHECK(NoteRequest_fake.call_count > 0);
+            }
+
+            JDelete(req);
+        }
+
+        // Should only go through card.log, never NoteDebug.
+        CHECK(NoteDebug_fake.call_count == 0);
+
+    }
+
+    RESET_FAKE(noteIsDebugOutputActive);
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+    RESET_FAKE(NoteDebug);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NotePrintf_test.cpp b/src/note-c/test/src/NotePrintf_test.cpp
new file mode 100644
index 0000000..c449290
--- /dev/null
+++ b/src/note-c/test/src/NotePrintf_test.cpp
@@ -0,0 +1,53 @@
+/*!
+ * @file NotePrintf_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NotePrint, const char *)
+
+namespace
+{
+
+char printBuf[32] = {0};
+
+bool NotePrintSave(const char* text)
+{
+    strcpy(printBuf, text);
+    return true;
+}
+
+SCENARIO("NotePrintf")
+{
+    // Arrange
+    NotePrint_fake.custom_fake = NotePrintSave;
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+    const char msg[] = "Hello world!";
+
+    // Act
+    NotePrintf("Hello %s!", "world");
+
+    // Assert
+    CHECK(strcmp(printBuf, msg) == 0);
+
+    RESET_FAKE(NotePrint);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NotePrintln_test.cpp b/src/note-c/test/src/NotePrintln_test.cpp
new file mode 100644
index 0000000..b9eadab
--- /dev/null
+++ b/src/note-c/test/src/NotePrintln_test.cpp
@@ -0,0 +1,58 @@
+/*!
+ * @file NotePrintln_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NotePrint, const char *)
+
+namespace
+{
+
+char printBuf[32];
+size_t printBufLen = 0;
+
+bool NotePrintSave(const char* text)
+{
+    strcpy(printBuf + printBufLen, text);
+    printBufLen += strlen(text);
+    printBuf[printBufLen] = '\0';
+
+    return true;
+}
+
+SCENARIO("NotePrintln")
+{
+    // Arrange
+    NotePrint_fake.custom_fake = NotePrintSave;
+    const char msg[] = "Hello world!";
+    size_t len = strlen(msg);
+
+    // Act
+    NotePrintln(msg);
+
+    // Assert
+    CHECK(!(memcmp(printBuf, msg, len)));
+    CHECK(!(memcmp(printBuf + len, c_newline, 2)));
+
+    RESET_FAKE(NotePrint);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteRegion_test.cpp b/src/note-c/test/src/NoteRegion_test.cpp
new file mode 100644
index 0000000..06b3924
--- /dev/null
+++ b/src/note-c/test/src/NoteRegion_test.cpp
@@ -0,0 +1,101 @@
+/*!
+ * @file NoteRegion_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+
+namespace
+{
+
+SCENARIO("NoteRegion")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char *country = NULL;
+    char *area = NULL;
+    char *tz = NULL;
+    int tzOffset = 1;
+
+    SECTION("Invalid") {
+        NoteRequestResponse_fake.return_val = NULL;
+
+        SECTION("NULL buffers") {
+            CHECK(!NoteRegion(NULL, NULL, NULL, NULL));
+        }
+
+        SECTION("Valid buffers") {
+            CHECK(!NoteRegion(&country, &area, &tz, &tzOffset));
+
+            REQUIRE(country != NULL);
+            CHECK(!strcmp(country, ""));
+
+            REQUIRE(area != NULL);
+            CHECK(!strcmp(area, ""));
+
+            REQUIRE(tz != NULL);
+            CHECK(!strcmp(tz, "UTC"));
+
+            CHECK(tzOffset == 0);
+        }
+    }
+
+    SECTION("Valid") {
+        char respRaw[] =
+            "{ \
+          \"time\": 1599769214, \
+          \"area\": \"Beverly, MA\", \
+          \"zone\": \"CDT,America/New York\", \
+          \"minutes\": -300, \
+          \"lat\": 42.5776, \
+          \"lon\": -70.87134, \
+          \"country\": \"US\" \
+        }";
+        J *resp = JParse(respRaw);
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        SECTION("NULL buffers") {
+            CHECK(NoteRegion(NULL, NULL, NULL, NULL));
+        }
+
+        SECTION("Valid buffers") {
+            CHECK(NoteRegion(&country, &area, &tz, &tzOffset));
+
+            REQUIRE(country != NULL);
+            CHECK(!strcmp(country, "US"));
+
+            REQUIRE(area != NULL);
+            CHECK(!strcmp(area, "Beverly, MA"));
+
+            REQUIRE(tz != NULL);
+            CHECK(!strcmp(tz, "CDT"));
+
+            CHECK(tzOffset == -300);
+        }
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteRequestResponseJSON_test.cpp b/src/note-c/test/src/NoteRequestResponseJSON_test.cpp
new file mode 100644
index 0000000..50eb4b6
--- /dev/null
+++ b/src/note-c/test/src/NoteRequestResponseJSON_test.cpp
@@ -0,0 +1,273 @@
+/*!
+ * @file NoteRequestResponseJSON_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(N_CJSON_PUBLIC(J *), JParse, const char *)
+FAKE_VALUE_FUNC(bool, noteTransactionStart, uint32_t)
+FAKE_VOID_FUNC(noteTransactionStop)
+FAKE_VOID_FUNC(noteLockNote)
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+FAKE_VOID_FUNC(NoteFree, void *)
+FAKE_VOID_FUNC(noteUnlockNote)
+FAKE_VALUE_FUNC(const char *, noteJSONTransaction, const char *, size_t, char **, uint32_t)
+
+namespace
+{
+
+SCENARIO("NoteRequestResponseJSON")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    JParse_fake.custom_fake = [](const char *value) -> J * {
+        return JParseWithOpts(value,0,0);
+    };
+    NoteMalloc_fake.custom_fake = malloc;
+    NoteFree_fake.custom_fake = free;
+    noteTransactionStart_fake.return_val = true;
+
+    GIVEN("The request is NULL") {
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON(NULL);
+
+            THEN("noteJSONTransaction is not called") {
+                CHECK(noteJSONTransaction_fake.call_count == 0);
+            }
+
+            THEN("The response is NULL") {
+                CHECK(rsp == NULL);
+            }
+        }
+    }
+
+    GIVEN("The request length is zero (0)") {
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON("");
+
+            THEN("noteJSONTransaction is not called") {
+                CHECK(noteJSONTransaction_fake.call_count == 0);
+            }
+
+            THEN("The response is NULL") {
+                CHECK(rsp == NULL);
+            }
+        }
+    }
+
+    GIVEN("The request is a command (cmd)") {
+        char req[] = "{\"cmd\":\"card.sleep\"}\n";
+
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("noteJSONTransaction is called with NULL for the response "
+                 "parameter") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(noteJSONTransaction_fake.arg2_history[0] == NULL);
+            }
+        }
+    }
+
+    GIVEN("The request is a command pipeline") {
+        char cmd1[] = "{\"cmd\":\"card.version\"}\n";
+        char cmd2[] = "{\"cmd\":\"card.sleep\"}\n";
+        char req[sizeof(cmd1) + sizeof(cmd2) - 1] = {0};
+        strlcat(req, cmd1, sizeof(req));
+        strlcat(req, cmd2, sizeof(req));
+
+        const size_t command_count = 2;
+
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("noteJSONTransaction is called once for each command") {
+                CHECK(noteJSONTransaction_fake.call_count == command_count);
+            }
+
+            THEN("noteJSONTransaction is called with the correct pointer and "
+                 "length for each command") {
+                CHECK(noteJSONTransaction_fake.arg0_history[0] == req);
+                CHECK(noteJSONTransaction_fake.arg1_history[0] ==
+                      (sizeof(cmd1) - 1));
+                CHECK(noteJSONTransaction_fake.arg0_history[1] ==
+                      (req + sizeof(cmd1) - 1));
+                CHECK(noteJSONTransaction_fake.arg1_history[1] ==
+                      (sizeof(cmd2) - 1));
+            }
+        }
+    }
+
+    GIVEN("The request is not a command (req)") {
+        char req[] = "{\"req\":\"card.version\"}\n";
+
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("noteJSONTransaction is called with a valid pointer for the "
+                 "response parameter") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(noteJSONTransaction_fake.arg2_history[0] != NULL);
+            }
+        }
+    }
+
+    GIVEN("The request is not a command but it has an inner object with a "
+          "\"cmd\" field") {
+        char req[] = "{\"req\":\"note.add\",\"body\":{\"cmd\":\"fire\"}}\n";
+
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("The request is still treated as a regular request and not a "
+                 "command") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                // The response parameter is non-NULL, meaning we expect a
+                // response (i.e. it's not a command).
+                CHECK(noteJSONTransaction_fake.arg2_history[0] != NULL);
+            }
+        }
+    }
+
+    GIVEN("The request doesn't have a terminating newline") {
+        char req[] = "{\"req\":\"card.version\"}";
+
+        WHEN("NoteMalloc fails to duplicate the request") {
+            NoteMalloc_fake.custom_fake = nullptr;
+            NoteMalloc_fake.return_val = NULL;
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("noteJSONTransaction is not called") {
+                REQUIRE(NoteMalloc_fake.call_count > 0);
+                CHECK(noteJSONTransaction_fake.call_count == 0);
+            }
+
+            THEN("NoteFree is not called") {
+                REQUIRE(NoteMalloc_fake.call_count > 0);
+                CHECK(NoteFree_fake.call_count == 0);
+            }
+
+            THEN("NoteRequestResponseJSON returns NULL") {
+                REQUIRE(NoteMalloc_fake.call_count > 0);
+                CHECK(rsp == NULL);
+            }
+        }
+
+        WHEN("NoteMalloc is able to duplicate the request") {
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("NoteMalloc is called") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(NoteMalloc_fake.call_count > 0);
+            }
+
+            THEN("noteJSONTransaction is called with the newline appended") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                REQUIRE(noteJSONTransaction_fake.arg0_val != NULL);
+                // We cannot test the value of the string passed to
+                // `noteJSONTransaction` because it is a pointer to a string
+                // freed by `NoteFree`. We can only check that the length
+                // of the string is one longer than would normally be expected.
+                CHECK(noteJSONTransaction_fake.arg1_val == sizeof(req));
+            }
+
+            THEN("NoteFree is called to free the memory allocated by malloc") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(NoteFree_fake.call_count == NoteMalloc_fake.call_count);
+            }
+        }
+
+        WHEN("The request fails to parse") {
+            char cmd[] = "{\"cmd\":\"card.version\"}";
+            JParse_fake.custom_fake = nullptr;
+            JParse_fake.return_val = NULL;
+            char *rsp = NoteRequestResponseJSON(cmd);
+
+            THEN("noteJSONTransaction is not called") {
+                REQUIRE(NoteMalloc_fake.call_count > 0);
+                CHECK(noteJSONTransaction_fake.call_count == 0);
+            }
+
+            THEN("NoteFree is called") {
+                REQUIRE(NoteMalloc_fake.call_count > 0);
+                CHECK(NoteFree_fake.call_count == NoteMalloc_fake.call_count);
+            }
+
+            THEN("NoteRequestResponseJSON returns NULL") {
+                CHECK(rsp == NULL);
+            }
+        }
+    }
+
+    GIVEN("The request is valid") {
+        char req[] = "{\"req\":\"card.version\"}\n";
+
+        WHEN("NoteRequestResponseJSON is called") {
+            char *rsp = NoteRequestResponseJSON(req);
+
+            THEN("The Notecard is locked and unlocked") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(noteLockNote_fake.call_count == 1);
+                CHECK(noteUnlockNote_fake.call_count == 1);
+            }
+
+            THEN("The transaction start/stop function are used to prepare the "
+                 "Notecard for the transaction") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(noteTransactionStart_fake.call_count == 1);
+                CHECK(noteTransactionStop_fake.call_count == 1);
+            }
+
+            THEN("NoteMalloc is not called") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(NoteMalloc_fake.call_count == 0);
+            }
+
+            THEN("NoteFree is not called") {
+                REQUIRE(noteJSONTransaction_fake.call_count > 0);
+                CHECK(NoteFree_fake.call_count == 0);
+            }
+        }
+
+        AND_GIVEN("The transaction with the Notecard fails to start") {
+            noteTransactionStart_fake.return_val = false;
+
+            WHEN("NoteRequestResponseJSON is called") {
+                char *rsp = NoteRequestResponseJSON(req);
+
+                THEN("NULL is returned") {
+                    REQUIRE(noteTransactionStart_fake.call_count > 0);
+                    CHECK(rsp == NULL);
+                }
+            }
+        }
+    }
+
+    RESET_FAKE(JParse);
+    RESET_FAKE(NoteMalloc);
+    RESET_FAKE(NoteFree);
+    RESET_FAKE(noteTransactionStart);
+    RESET_FAKE(noteTransactionStop);
+    RESET_FAKE(noteLockNote);
+    RESET_FAKE(noteUnlockNote);
+    RESET_FAKE(noteJSONTransaction);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteRequestResponseWithRetry_test.cpp b/src/note-c/test/src/NoteRequestResponseWithRetry_test.cpp
new file mode 100644
index 0000000..8a7c4af
--- /dev/null
+++ b/src/note-c/test/src/NoteRequestResponseWithRetry_test.cpp
@@ -0,0 +1,229 @@
+/*!
+ * @file NoteRequestResponseWithRetry_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2024 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteTransaction, J *)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+
+namespace
+{
+
+J *NoteTransactionIOError(J *)
+{
+    J *resp = JCreateObject();
+    assert(resp != NULL);
+    JAddStringToObject(resp, c_err, c_ioerr);
+
+    return resp;
+}
+
+J *NoteTransactionNotSupportedError(J *)
+{
+    J *resp = JCreateObject();
+    assert(resp != NULL);
+    JAddStringToObject(resp, c_err, c_unsupported);
+
+    return resp;
+}
+
+J *NoteTransactionIOAndNotSupportedErrors(J *)
+{
+    J *resp = JCreateObject();
+    assert(resp != NULL);
+    JAddStringToObject(resp, c_err, "{io} {not-supported}");
+
+    return resp;
+}
+
+J *NoteTransactionOtherError(J *)
+{
+    J *resp = JCreateObject();
+    assert(resp != NULL);
+    JAddStringToObject(resp, c_err, c_bad);
+
+    return resp;
+}
+
+TEST_CASE("NoteRequestResponseWithRetry")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    J *rsp = NULL;
+
+    GIVEN("A NULL request") {
+        J *req = NULL;
+
+        WHEN("NoteRequestResponseWithRetry is called") {
+            rsp = NoteRequestResponseWithRetry(req, 0);
+
+            THEN("The returned response is NULL") {
+                CHECK(rsp == NULL);
+            }
+        }
+    }
+
+    GIVEN("A valid request") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+
+        AND_GIVEN("A timeout of 5 seconds") {
+            const uint32_t timeoutSec = 5;
+
+            AND_GIVEN("The timeout will trigger after 1 retry") {
+                uint32_t getMsReturnVals[3] = {0, 3000, 6000};
+                SET_RETURN_SEQ(NoteGetMs, getMsReturnVals, 3);
+
+                AND_GIVEN("The response to NoteTransaction is NULL") {
+                    NoteTransaction_fake.return_val = NULL;
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response is NULL") {
+                            CHECK(rsp == NULL);
+                        }
+
+                        THEN("NoteTransaction will be called twice (1 retry)")  {
+                            CHECK(NoteTransaction_fake.call_count == 2);
+                        }
+                    }
+                }
+
+                AND_GIVEN("The response to NoteTransaction contains an I/O "
+                          "error") {
+                    NoteTransaction_fake.custom_fake = NoteTransactionIOError;
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response is NULL") {
+                            CHECK(rsp == NULL);
+                        }
+
+                        THEN("NoteTransaction will be called twice (1 "
+                             "retry)")  {
+                            CHECK(NoteTransaction_fake.call_count == 2);
+                        }
+                    }
+                }
+
+                AND_GIVEN("The response to NoteTransaction contains a not "
+                          "supported error") {
+                    NoteTransaction_fake.custom_fake = NoteTransactionNotSupportedError;
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response has a not-supported error") {
+                            CHECK(JContainsString(rsp, c_err, c_unsupported));
+                        }
+
+                        THEN("NoteTransaction is only called once (no retries)")  {
+                            CHECK(NoteTransaction_fake.call_count == 1);
+                        }
+                    }
+                }
+
+                AND_GIVEN("The response to NoteTransaction contains a not "
+                          "supported error AND an I/O error") {
+                    NoteTransaction_fake.custom_fake = NoteTransactionIOAndNotSupportedErrors;
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response has a not-supported "
+                             "error") {
+                            CHECK(JContainsString(rsp, c_err, c_unsupported));
+                        }
+
+                        THEN("The returned response has an I/O error") {
+                            CHECK(JContainsString(rsp, c_err, c_ioerr));
+                        }
+
+                        THEN("NoteTransaction is only called once (no "
+                             "retries)")  {
+                            CHECK(NoteTransaction_fake.call_count == 1);
+                        }
+                    }
+                }
+
+                AND_GIVEN("The response to NoteTransaction contains an error "
+                          "that isn't I/O or \"not supported\"") {
+                    NoteTransaction_fake.custom_fake = NoteTransactionOtherError;
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response has the error") {
+                            CHECK(JContainsString(rsp, c_err, c_bad));
+                        }
+
+                        THEN("NoteTransaction is only called once (no "
+                             "retries)")  {
+                            CHECK(NoteTransaction_fake.call_count == 1);
+                        }
+                    }
+                }
+
+                AND_GIVEN("There's a valid response on the first "
+                          " NoteTransaction attempt") {
+                    NoteTransaction_fake.return_val = JCreateObject();
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response is non-NULL") {
+                            CHECK(rsp != NULL);
+                        }
+
+                        THEN("NoteTranaction is only called once (no "
+                             "retries)") {
+                            CHECK(NoteTransaction_fake.call_count == 1);
+                        }
+                    }
+                }
+
+                AND_GIVEN("There's a valid response on the second "
+                          "NoteTransaction attempt") {
+                    J *noteTransactionReturnVals[2] = {NULL, JCreateObject()};
+                    SET_RETURN_SEQ(NoteTransaction, noteTransactionReturnVals,
+                                   2);
+
+                    WHEN("NoteRequestResponseWithRetry is called") {
+                        rsp = NoteRequestResponseWithRetry(req, timeoutSec);
+
+                        THEN("The returned response is non-NULL") {
+                            CHECK(rsp != NULL);
+                        }
+
+                        THEN("NoteTranaction is only called twice (1 retry)") {
+                            CHECK(NoteTransaction_fake.call_count == 2);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    JDelete(rsp);
+
+    RESET_FAKE(NoteTransaction);
+    RESET_FAKE(NoteGetMs);
+}
+
+}
diff --git a/src/note-c/test/src/NoteRequestResponse_test.cpp b/src/note-c/test/src/NoteRequestResponse_test.cpp
new file mode 100644
index 0000000..9fafb0e
--- /dev/null
+++ b/src/note-c/test/src/NoteRequestResponse_test.cpp
@@ -0,0 +1,67 @@
+/*!
+ * @file NoteRequestResponse_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteTransaction, J *)
+
+namespace
+{
+
+J *NoteTransactionValid(J *)
+{
+    return JCreateObject();
+}
+
+SCENARIO("NoteRequestResponse")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("Passing a NULL request returns NULL") {
+        CHECK(NoteRequestResponse(NULL) == NULL);
+    }
+
+
+    SECTION("NoteTransaction returns NULL") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        NoteTransaction_fake.return_val = NULL;
+
+        CHECK(NoteRequestResponse(req) == NULL);
+        CHECK(NoteTransaction_fake.call_count == 1);
+    }
+
+    SECTION("NoteTransaction returns a valid response") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        NoteTransaction_fake.custom_fake = NoteTransactionValid;
+
+        J *resp = NoteRequestResponse(req);
+        REQUIRE(resp != NULL);
+        CHECK(NoteTransaction_fake.call_count == 1);
+
+        JDelete(resp);
+    }
+
+    RESET_FAKE(NoteTransaction);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteRequestWithRetry_test.cpp b/src/note-c/test/src/NoteRequestWithRetry_test.cpp
new file mode 100644
index 0000000..f2de277
--- /dev/null
+++ b/src/note-c/test/src/NoteRequestWithRetry_test.cpp
@@ -0,0 +1,122 @@
+/*!
+ * @file NoteRequestWithRetry_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteTransaction, J *)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+
+namespace
+{
+
+J *NoteTransactionIOError(J *)
+{
+    J *resp = JCreateObject();
+    assert(resp != NULL);
+    JAddStringToObject(resp, c_err, c_ioerr);
+
+    return resp;
+}
+
+J *NoteTransactionNonIOError(J *)
+{
+    J *resp = JCreateObject();
+    assert(resp != NULL);
+    JAddStringToObject(resp, c_err, c_bad);
+
+    return resp;
+}
+
+SCENARIO("NoteRequestWithRetry")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("NULL request") {
+        CHECK(!NoteRequestWithRetry(NULL, 0));
+    }
+
+    SECTION("Non-NULL request") {
+        // With this timeout configuration, NoteTransaction will be retried at
+        // most one time.
+        const uint32_t timeoutSec = 5;
+        uint32_t getMsReturnVals[3];
+
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != nullptr);
+
+        SECTION("Timeout expires") {
+            SECTION("No millisecond overflow") {
+                getMsReturnVals[0] = 0;
+                getMsReturnVals[1] = 3000;
+                getMsReturnVals[2] = 6000;
+
+                SECTION("NULL responses") {
+                    NoteTransaction_fake.return_val = NULL;
+                }
+
+                SECTION("I/O error responses") {
+                    NoteTransaction_fake.custom_fake = NoteTransactionIOError;
+                }
+            }
+
+            SECTION("Millisecond overflow") {
+                const uint32_t timeoutMillis = 5 * 1000;
+                // Setup overflow condition:
+                //     1. First value is 5 seconds before overflow.
+                //     2. Second value is 4 seconds before overflow.
+                //     3. Third value is 3 seconds after overflow.
+                getMsReturnVals[0] = UINT32_MAX - timeoutMillis;
+                getMsReturnVals[1] = UINT32_MAX - (timeoutMillis  - 1000);
+                getMsReturnVals[2] = 3000;
+            }
+
+            SET_RETURN_SEQ(NoteGetMs, getMsReturnVals, 3);
+
+            CHECK(!NoteRequestWithRetry(req, timeoutSec));
+            CHECK(NoteTransaction_fake.call_count == 2);
+        }
+
+        SECTION("Non-I/O error") {
+            NoteTransaction_fake.custom_fake = NoteTransactionNonIOError;
+
+            CHECK(!NoteRequestWithRetry(req, timeoutSec));
+            CHECK(NoteTransaction_fake.call_count == 1);
+        }
+
+        SECTION("Response on first try") {
+            NoteTransaction_fake.return_val = JCreateObject();
+
+            CHECK(NoteRequestWithRetry(req, timeoutSec));
+            CHECK(NoteTransaction_fake.call_count == 1);
+        }
+
+        SECTION("Response after retry") {
+            J *noteTransactionReturnVals[2] = {NULL, JCreateObject()};
+            SET_RETURN_SEQ(NoteTransaction, noteTransactionReturnVals, 2);
+
+            CHECK(NoteRequestWithRetry(req, timeoutSec));
+            CHECK(NoteTransaction_fake.call_count == 2);
+        }
+    }
+
+    RESET_FAKE(NoteTransaction);
+    RESET_FAKE(NoteGetMs);
+}
+
+}
diff --git a/src/note-c/test/src/NoteRequest_test.cpp b/src/note-c/test/src/NoteRequest_test.cpp
new file mode 100644
index 0000000..57ecff4
--- /dev/null
+++ b/src/note-c/test/src/NoteRequest_test.cpp
@@ -0,0 +1,70 @@
+/*!
+ * @file NoteRequest_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteTransaction, J *)
+
+namespace
+{
+
+SCENARIO("NoteRequest")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("Passing a NULL request returns false") {
+        CHECK(!NoteRequest(NULL));
+    }
+
+    SECTION("NoteTransaction returns NULL") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        NoteTransaction_fake.return_val = NULL;
+
+        CHECK(!NoteRequest(req));
+        CHECK(NoteTransaction_fake.call_count == 1);
+    }
+
+    SECTION("NoteTransaction returns a response with an error") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        J *resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        CHECK(JAddStringToObject(resp, c_err, "An error.") != NULL);
+        NoteTransaction_fake.return_val = resp;
+
+        CHECK(!NoteRequest(req));
+        CHECK(NoteTransaction_fake.call_count == 1);
+    }
+
+    SECTION("NoteTransaction returns a valid response") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        NoteTransaction_fake.return_val = JCreateObject();
+
+        CHECK(NoteRequest(req));
+        CHECK(NoteTransaction_fake.call_count == 1);
+    }
+
+    RESET_FAKE(NoteTransaction);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteReset_test.cpp b/src/note-c/test/src/NoteReset_test.cpp
new file mode 100644
index 0000000..e7aa7f2
--- /dev/null
+++ b/src/note-c/test/src/NoteReset_test.cpp
@@ -0,0 +1,58 @@
+/*!
+ * @file NoteReset_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, noteHardReset)
+
+namespace
+{
+
+SCENARIO("NoteReset")
+{
+    GIVEN("NoteReset is called") {
+        NoteReset();
+
+        THEN("noteHardReset is invoked") {
+            CHECK(noteHardReset_fake.call_count > 0);
+        }
+
+        WHEN("`noteHardReset` returns `false`") {
+            noteHardReset_fake.return_val = false;
+            THEN("`NoteReset` also returns `false`") {
+                bool result = NoteReset();
+                CHECK(result == false);
+            }
+        }
+
+        WHEN("`noteHardReset` returns `true`") {
+            noteHardReset_fake.return_val = true;
+            THEN("`NoteReset` also returns `true`") {
+                bool result = NoteReset();
+                CHECK(result == true);
+            }
+        }
+    }
+
+    RESET_FAKE(noteHardReset);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteResponseError_test.cpp b/src/note-c/test/src/NoteResponseError_test.cpp
new file mode 100644
index 0000000..ef1c6f5
--- /dev/null
+++ b/src/note-c/test/src/NoteResponseError_test.cpp
@@ -0,0 +1,53 @@
+/*!
+ * @file NoteTransaction_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2024 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+//#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+
+// DEFINE_FFF_GLOBALS
+// FAKE_VALUE_FUNC(bool, NoteReset)
+// FAKE_VALUE_FUNC(const char *, noteJSONTransaction, const char *, size_t, char **, uint32_t)
+// FAKE_VALUE_FUNC(bool, noteTransactionStart, uint32_t)
+// FAKE_VALUE_FUNC(J *, NoteUserAgent)
+// FAKE_VALUE_FUNC(bool, crcError, char *, uint16_t)
+
+
+SCENARIO("NoteResponseError")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    // // NoteReset's mock should succeed unless the test explicitly instructs
+    // // it to fail.
+    // NoteReset_fake.return_val = true;
+    // noteTransactionStart_fake.return_val = true;
+    // crcError_fake.return_val = false;
+
+    SECTION("No err field, returns false") {
+        J* rsp = JParse("{\"test\":\"me\"}");
+        //CHECK(rsp == NULL);
+        CHECK(!(NoteResponseError(rsp)));
+        JDelete(rsp);
+    }
+
+    SECTION("Supplying a response with err returns True") {
+        J* rsp = JParse("{\"err\":\"DFU mode is not yet fully active: starting communications {wait-module} {connecting} {dfu-not-ready}\"}\n");
+        bool hasError = NoteResponseError(rsp);
+        CHECK((hasError ==true && rsp != NULL));
+        JDelete(rsp);
+    }
+
+}
+
diff --git a/src/note-c/test/src/NoteSendToRoute_test.cpp b/src/note-c/test/src/NoteSendToRoute_test.cpp
new file mode 100644
index 0000000..e1d194e
--- /dev/null
+++ b/src/note-c/test/src/NoteSendToRoute_test.cpp
@@ -0,0 +1,106 @@
+/*!
+ * @file NoteSendToRoute_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSendToRoute")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char method[] = "post";
+    const char routeAlias[] = "alias";
+    char file[] = "data.qo";
+    J *body = JCreateObject();
+    REQUIRE(body != NULL);
+
+    SECTION("NoteNewRequest for note.event fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSendToRoute(method, routeAlias, file, body));
+    }
+
+    SECTION("NoteRequestResponse") {
+        J *firstReq = JCreateObject();
+        NoteNewRequest_fake.return_val = firstReq;
+
+        SECTION("Fails") {
+            NoteRequestResponse_fake.return_val = NULL;
+
+            CHECK(!NoteSendToRoute(method, routeAlias, file, body));
+        }
+
+        SECTION("Succeeds") {
+            J *rsp = JCreateObject();
+            NoteRequestResponse_fake.return_val = rsp;
+
+            SECTION("Response has error") {
+                JAddStringToObject(rsp, "err", "an error");
+
+                CHECK(!NoteSendToRoute(method, routeAlias, file, body));
+            }
+
+            SECTION("NoteNewRequest for web.post fails") {
+                J *noteNewRequestRetVals[] = {firstReq, NULL};
+                SET_RETURN_SEQ(NoteNewRequest, noteNewRequestRetVals, 2);
+
+                CHECK(!NoteSendToRoute(method, routeAlias, file, body));
+            }
+
+            SECTION("NoteNewRequest for web.post succeeds") {
+                J *secondReq = JCreateObject();
+                REQUIRE(secondReq != NULL);
+                J *noteNewRequestRetVals[] = {firstReq, secondReq};
+                SET_RETURN_SEQ(NoteNewRequest, noteNewRequestRetVals, 2);
+
+                SECTION("NoteRequest for web.post fails") {
+                    NoteRequest_fake.return_val = false;
+
+                    CHECK(!NoteSendToRoute(method, routeAlias, file, body));
+                }
+
+                SECTION("NoteRequest for web.post succeeds") {
+                    NoteRequest_fake.return_val = true;
+
+                    CHECK(NoteSendToRoute(method, routeAlias, file, body));
+                }
+
+                CHECK(strcmp(JGetString(secondReq, "route"), routeAlias) == 0);
+
+                JDelete(secondReq);
+            }
+        }
+
+        JDelete(firstReq);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSerialHooks_test.cpp b/src/note-c/test/src/NoteSerialHooks_test.cpp
new file mode 100644
index 0000000..d6e8f95
--- /dev/null
+++ b/src/note-c/test/src/NoteSerialHooks_test.cpp
@@ -0,0 +1,63 @@
+/*!
+ * @file NoteSerialHooks_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+bool txnStartCalled = false;
+bool txnStopCalled = false;
+
+bool MyTxnStart(uint32_t)
+{
+    txnStartCalled = true;
+    return true;
+}
+
+void MyTxnStop()
+{
+    txnStopCalled = true;
+    return;
+}
+
+SCENARIO("NoteSerialHooks")
+{
+    SECTION("Hooks not set") {
+        noteTransactionStart(0);
+        noteTransactionStop();
+
+        CHECK(!txnStartCalled);
+        CHECK(!txnStopCalled);
+    }
+
+    SECTION("Hooks set") {
+        NoteSetFnTransaction(MyTxnStart, MyTxnStop);
+        noteTransactionStart(0);
+        noteTransactionStop();
+
+        CHECK(txnStartCalled);
+        CHECK(txnStopCalled);
+    }
+
+    txnStartCalled = false;
+    txnStopCalled = false;
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetContact_test.cpp b/src/note-c/test/src/NoteSetContact_test.cpp
new file mode 100644
index 0000000..fff913a
--- /dev/null
+++ b/src/note-c/test/src/NoteSetContact_test.cpp
@@ -0,0 +1,75 @@
+/*!
+ * @file NoteSetContact_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetContact")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char nameBuf[] = "John Doe";
+    char orgBuf[] = "Blues";
+    char roleBuf[] = "Engineer";
+    char emailBuf[] = "jdoe@blues.com";
+
+    J *req = JCreateObject();
+    REQUIRE(req != NULL);
+
+    SECTION("Errors") {
+        SECTION("NoteNewRequest fails") {
+            NoteNewRequest_fake.return_val = NULL;
+        }
+
+        SECTION("NoteRequest fails") {
+            NoteNewRequest_fake.return_val = req;
+            NoteRequest_fake.return_val = false;
+        }
+
+        CHECK(!NoteSetContact(nameBuf, orgBuf, roleBuf, emailBuf));
+    }
+
+
+    SECTION("Success") {
+        NoteNewRequest_fake.return_val = req;
+        NoteRequest_fake.return_val = true;
+
+        SECTION("NULL buffers") {
+            CHECK(NoteSetContact(NULL, NULL, NULL, NULL));
+        }
+
+        SECTION("Valid buffers") {
+            CHECK(NoteSetContact(nameBuf, orgBuf, roleBuf, emailBuf));
+        }
+    }
+
+    JDelete(req);
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetEnvDefaultNumber_test.cpp b/src/note-c/test/src/NoteSetEnvDefaultNumber_test.cpp
new file mode 100644
index 0000000..32d4e42
--- /dev/null
+++ b/src/note-c/test/src/NoteSetEnvDefaultNumber_test.cpp
@@ -0,0 +1,58 @@
+/*!
+ * @file NoteSetEnvDefaultInt_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NoteSetEnvDefault, const char *, char *)
+
+namespace
+{
+
+char valBuf[32] = {0};
+
+bool NoteSetEnvDefaultSaveBuffer(const char *, char *buf)
+{
+    strcpy(valBuf, buf);
+
+    return true;
+}
+
+SCENARIO("NoteSetEnvDefaultNumber, NoteSetEnvDefaultInt")
+{
+    // Arrange
+    NoteSetEnvDefault_fake.custom_fake = NoteSetEnvDefaultSaveBuffer;
+    const char var[] = "var";
+    long int val = -123456;
+
+    // Act, Assert
+    //TODO: Organize
+    CHECK(NoteSetEnvDefaultNumber(var, val));
+    CHECK(strcmp("-123456", valBuf) == 0);
+
+    memset(valBuf, 0, sizeof(valBuf));
+
+    CHECK(NoteSetEnvDefaultInt(var, val));
+    CHECK(strcmp("-123456", valBuf) == 0);
+
+    RESET_FAKE(NoteSetEnvDefault);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetEnvDefault_test.cpp b/src/note-c/test/src/NoteSetEnvDefault_test.cpp
new file mode 100644
index 0000000..48e7de3
--- /dev/null
+++ b/src/note-c/test/src/NoteSetEnvDefault_test.cpp
@@ -0,0 +1,67 @@
+/*!
+ * @file NoteSetEnvDefault_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetEnvDefault")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char var[] = "var";
+    char val[] = "val";
+
+    SECTION("NoteNewRequest returns NULL") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetEnvDefault(var, val));
+    }
+
+    SECTION("NoteNewRequest ok") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("NoteRequest fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetEnvDefault(var, val));
+        }
+
+        SECTION("NoteRequest succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetEnvDefault(var, val));
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetFnI2CMutex_test.cpp b/src/note-c/test/src/NoteSetFnI2CMutex_test.cpp
new file mode 100644
index 0000000..3d79727
--- /dev/null
+++ b/src/note-c/test/src/NoteSetFnI2CMutex_test.cpp
@@ -0,0 +1,58 @@
+/*!
+ * @file NoteSetFnI2CMutex_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+uint8_t lockI2CCalled = 0;
+uint8_t unlockI2CCalled = 0;
+
+void LockI2C()
+{
+    ++lockI2CCalled;
+}
+
+void UnlockI2C()
+{
+    ++unlockI2CCalled;
+}
+
+SCENARIO("NoteSetFnI2CMutex")
+{
+    NoteSetFnI2CMutex(LockI2C, UnlockI2C);
+
+    NoteLockI2C();
+    CHECK(lockI2CCalled == 1);
+
+    NoteUnlockI2C();
+    CHECK(unlockI2CCalled == 1);
+
+    // Unset the callbacks and ensure they aren't called again.
+    NoteSetFnI2CMutex(NULL, NULL);
+
+    NoteLockI2C();
+    CHECK(lockI2CCalled == 1);
+
+    NoteUnlockI2C();
+    CHECK(unlockI2CCalled == 1);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetFnI2C_test.cpp b/src/note-c/test/src/NoteSetFnI2C_test.cpp
new file mode 100644
index 0000000..d296024
--- /dev/null
+++ b/src/note-c/test/src/NoteSetFnI2C_test.cpp
@@ -0,0 +1,119 @@
+/*!
+ * @file NoteSetFnI2C_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, i2cNoteReset)
+FAKE_VALUE_FUNC(const char *, i2cNoteTransaction, const char *, size_t, char **, uint32_t)
+
+namespace
+{
+
+uint8_t i2cResetCalled = 0;
+uint8_t i2cTransmitCalled = 0;
+uint8_t i2cReceiveCalled = 0;
+
+bool I2CReset(uint16_t)
+{
+    ++i2cResetCalled;
+    return true;
+}
+
+const char *I2CTransmit(uint16_t, uint8_t*, uint16_t)
+{
+    ++i2cTransmitCalled;
+    return NULL;
+}
+
+const char *I2CReceive(uint16_t, uint8_t*, uint16_t, uint32_t*)
+{
+    ++i2cReceiveCalled;
+    return NULL;
+}
+
+
+SCENARIO("NoteSetFnI2C")
+{
+    char req[] = "{ \"req\": \"note.add\" }\n";
+    char *resp = NULL;
+    i2cNoteReset_fake.return_val = true;
+    i2cNoteTransaction_fake.return_val = NULL;
+    const uint16_t i2cAddr = 0xBEEF;
+    const uint32_t i2cMax = 16;
+
+    NoteSetFnI2C(i2cAddr, i2cMax, I2CReset, I2CTransmit, I2CReceive);
+
+    CHECK(noteI2CReset(i2cAddr));
+    CHECK(i2cResetCalled == 1);
+
+    CHECK(noteI2CTransmit(i2cAddr, (uint8_t *)req, strlen(req)) == NULL);
+    CHECK(i2cTransmitCalled == 1);
+
+    CHECK(noteI2CReceive(i2cAddr, NULL, 0, NULL) == NULL);
+    CHECK(i2cReceiveCalled == 1);
+
+    CHECK(strcmp(noteActiveInterface(), "i2c") == 0);
+
+    CHECK(noteHardReset());
+    CHECK(i2cNoteReset_fake.call_count == 1);
+
+    CHECK(noteJSONTransaction(req, strlen(req), &resp, CARD_INTER_TRANSACTION_TIMEOUT_SEC) == NULL);
+    CHECK(i2cNoteTransaction_fake.call_count == 1);
+
+    CHECK(NoteI2CAddress() == i2cAddr);
+    CHECK(NoteI2CMax() == i2cMax);
+
+    // Make sure we aren't able to set max higher than NOTE_I2C_MAX_MAX.
+    NoteSetFnI2C(i2cAddr, NOTE_I2C_MAX_MAX + 1, I2CReset, I2CTransmit,
+                 I2CReceive);
+    CHECK(NoteI2CMax() == NOTE_I2C_MAX_MAX);
+
+    // Unset the address, max, and callbacks.
+    NoteSetFnI2C(i2cAddr, 0, NULL, NULL, NULL);
+    // Make sure setting the address this way works, too.
+    NoteSetI2CAddress(0);
+    NoteSetFnDisabled();
+
+    CHECK(noteI2CReset(i2cAddr));
+    CHECK(i2cResetCalled == 1);
+
+    CHECK(noteI2CTransmit(i2cAddr, (uint8_t *)req, strlen(req)) != NULL);
+    CHECK(i2cTransmitCalled == 1);
+
+    CHECK(noteI2CReceive(i2cAddr, NULL, 0, NULL) != NULL);
+    CHECK(i2cReceiveCalled == 1);
+
+    CHECK(strcmp(noteActiveInterface(), "unknown") == 0);
+
+    CHECK(noteHardReset());
+    CHECK(i2cNoteReset_fake.call_count == 1);
+
+    CHECK(noteJSONTransaction(req, strlen(req), &resp, CARD_INTER_TRANSACTION_TIMEOUT_SEC) != NULL);
+    CHECK(i2cNoteTransaction_fake.call_count == 1);
+
+    CHECK(NoteI2CAddress() == NOTE_I2C_ADDR_DEFAULT);
+    CHECK(NoteI2CMax() == NOTE_I2C_MAX_DEFAULT);
+
+    RESET_FAKE(i2cNoteReset);
+    RESET_FAKE(i2cNoteTransaction);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetFnMutex_test.cpp b/src/note-c/test/src/NoteSetFnMutex_test.cpp
new file mode 100644
index 0000000..c8ed7ac
--- /dev/null
+++ b/src/note-c/test/src/NoteSetFnMutex_test.cpp
@@ -0,0 +1,82 @@
+/*!
+ * @file NoteSetFnMutex_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+uint8_t lockI2CCalled = 0;
+uint8_t unlockI2CCalled = 0;
+uint8_t lockNoteCalled = 0;
+uint8_t unlockNoteCalled = 0;
+
+void LockI2C()
+{
+    ++lockI2CCalled;
+}
+
+void UnlockI2C()
+{
+    ++unlockI2CCalled;
+}
+
+void LockNote()
+{
+    ++lockNoteCalled;
+}
+
+void UnlockNote()
+{
+    ++unlockNoteCalled;
+}
+
+SCENARIO("NoteSetFnMutex")
+{
+    NoteSetFnMutex(LockI2C, UnlockI2C, LockNote, UnlockNote);
+
+    NoteLockI2C();
+    CHECK(lockI2CCalled == 1);
+
+    NoteUnlockI2C();
+    CHECK(unlockI2CCalled == 1);
+
+    noteLockNote();
+    CHECK(lockNoteCalled == 1);
+
+    noteUnlockNote();
+    CHECK(unlockNoteCalled == 1);
+
+    // Unset the callbacks and ensure they aren't called again.
+    NoteSetFnMutex(NULL, NULL, NULL, NULL);
+
+    NoteLockI2C();
+    CHECK(lockI2CCalled == 1);
+
+    NoteUnlockI2C();
+    CHECK(unlockI2CCalled == 1);
+
+    noteLockNote();
+    CHECK(lockNoteCalled == 1);
+
+    noteUnlockNote();
+    CHECK(unlockNoteCalled == 1);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetFnNoteMutex_test.cpp b/src/note-c/test/src/NoteSetFnNoteMutex_test.cpp
new file mode 100644
index 0000000..c6f39bf
--- /dev/null
+++ b/src/note-c/test/src/NoteSetFnNoteMutex_test.cpp
@@ -0,0 +1,58 @@
+/*!
+ * @file NoteSetFnNoteMutex_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+uint8_t lockNoteCalled = 0;
+uint8_t unlockNoteCalled = 0;
+
+void LockNote()
+{
+    ++lockNoteCalled;
+}
+
+void UnlockNote()
+{
+    ++unlockNoteCalled;
+}
+
+SCENARIO("NoteSetFnNoteMutex")
+{
+    NoteSetFnNoteMutex(LockNote, UnlockNote);
+
+    noteLockNote();
+    CHECK(lockNoteCalled == 1);
+
+    noteUnlockNote();
+    CHECK(unlockNoteCalled == 1);
+
+    // Unset the callbacks and ensure they aren't called again.
+    NoteSetFnNoteMutex(NULL, NULL);
+
+    noteLockNote();
+    CHECK(lockNoteCalled == 1);
+
+    noteUnlockNote();
+    CHECK(unlockNoteCalled == 1);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetFnSerial_test.cpp b/src/note-c/test/src/NoteSetFnSerial_test.cpp
new file mode 100644
index 0000000..312deb1
--- /dev/null
+++ b/src/note-c/test/src/NoteSetFnSerial_test.cpp
@@ -0,0 +1,117 @@
+/*!
+ * @file NoteSetFnSerial_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, serialNoteReset)
+FAKE_VALUE_FUNC(const char *, serialNoteTransaction, const char *, size_t, char **, uint32_t)
+
+namespace
+{
+
+uint8_t serialResetCalled = 0;
+uint8_t serialTransmitCalled = 0;
+uint8_t serialAvailableCalled = 0;
+uint8_t serialReceiveCalled = 0;
+
+bool serialReset()
+{
+    ++serialResetCalled;
+    return true;
+}
+
+void serialTransmit(uint8_t *, size_t, bool)
+{
+    ++serialTransmitCalled;
+}
+
+bool serialAvailable()
+{
+    ++serialAvailableCalled;
+    return true;
+}
+
+char serialReceive()
+{
+    ++serialReceiveCalled;
+    return 'a';
+}
+
+
+SCENARIO("NoteSetFnSerial")
+{
+    char req[] = "{ \"req\": \"note.add\" }\n";
+    char *resp = NULL;
+    serialNoteReset_fake.return_val = true;
+    serialNoteTransaction_fake.return_val = NULL;
+
+    NoteSetFnSerial(serialReset, serialTransmit, serialAvailable,
+                    serialReceive);
+
+    CHECK(noteSerialReset());
+    CHECK(serialResetCalled == 1);
+
+    noteSerialTransmit((uint8_t *)req, strlen(req), false);
+    CHECK(serialTransmitCalled == 1);
+
+    CHECK(noteSerialAvailable());
+    CHECK(serialAvailableCalled == 1);
+
+    CHECK(noteSerialReceive() == 'a');
+    CHECK(serialReceiveCalled == 1);
+
+    CHECK(strcmp(noteActiveInterface(), "serial") == 0);
+
+    CHECK(noteHardReset());
+    CHECK(serialNoteReset_fake.call_count == 1);
+
+    CHECK(noteJSONTransaction(req, strlen(req), &resp, CARD_INTER_TRANSACTION_TIMEOUT_SEC) == NULL);
+    CHECK(serialNoteTransaction_fake.call_count == 1);
+
+    // Unset the callbacks and ensure they aren't called again.
+    NoteSetFnSerial(NULL, NULL, NULL, NULL);
+    NoteSetFnDisabled();
+
+    CHECK(noteSerialReset());
+    CHECK(serialResetCalled == 1);
+
+    noteSerialTransmit((uint8_t *)req, strlen(req), false);
+    CHECK(serialTransmitCalled == 1);
+
+    CHECK(!noteSerialAvailable());
+    CHECK(serialAvailableCalled == 1);
+
+    CHECK(noteSerialReceive() == 0);
+    CHECK(serialReceiveCalled == 1);
+
+    CHECK(strcmp(noteActiveInterface(), "unknown") == 0);
+
+    CHECK(noteHardReset());
+    CHECK(serialNoteReset_fake.call_count == 1);
+
+    CHECK(noteJSONTransaction(req, strlen(req), &resp, CARD_INTER_TRANSACTION_TIMEOUT_SEC) != NULL);
+    CHECK(serialNoteTransaction_fake.call_count == 1);
+
+    RESET_FAKE(serialNoteReset);
+    RESET_FAKE(serialNoteTransaction);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetFn_test.cpp b/src/note-c/test/src/NoteSetFn_test.cpp
new file mode 100644
index 0000000..a890a7e
--- /dev/null
+++ b/src/note-c/test/src/NoteSetFn_test.cpp
@@ -0,0 +1,93 @@
+/*!
+ * @file NoteSetFn_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+bool mallocCalled = false;
+bool freeCalled = false;
+bool delayMsCalled = false;
+bool getMsCalled = false;
+
+void* MyMalloc(size_t)
+{
+    mallocCalled = true;
+    return NULL;
+}
+
+void MyFree(void *)
+{
+    freeCalled = true;
+}
+
+void MyDelayMs(uint32_t)
+{
+    delayMsCalled = true;
+}
+
+uint32_t MyGetMs()
+{
+    getMsCalled = true;
+    return 0;
+}
+
+SCENARIO("NoteSetFn")
+{
+    NoteSetFnDefault(MyMalloc, MyFree, MyDelayMs, MyGetMs);
+
+    SECTION("NoteSetFnDefault: Hooks not overridden") {
+        // NoteSetFnDefault will only set the hooks if they're non-NULL, so
+        // trying to set them to NULL here should have no effect, since they
+        // were previously set to valid values.
+        NoteSetFnDefault(NULL, NULL, NULL, NULL);
+
+        void* buf = NoteMalloc(1);
+        NoteFree(buf);
+        NoteDelayMs(1);
+        NoteGetMs();
+
+        CHECK(mallocCalled);
+        CHECK(freeCalled);
+        CHECK(delayMsCalled);
+        CHECK(getMsCalled);
+    }
+
+    SECTION("NoteSetFn: Hooks overridden") {
+        NoteSetFn(NULL, NULL, NULL, NULL);
+
+        void* buf = NoteMalloc(1);
+        NoteFree(buf);
+        NoteDelayMs(1);
+        NoteGetMs();
+
+        CHECK(!mallocCalled);
+        CHECK(!freeCalled);
+        CHECK(!delayMsCalled);
+        CHECK(!getMsCalled);
+    }
+
+    mallocCalled = false;
+    freeCalled = false;
+    delayMsCalled = false;
+    getMsCalled = false;
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetLocationMode_test.cpp b/src/note-c/test/src/NoteSetLocationMode_test.cpp
new file mode 100644
index 0000000..c324d53
--- /dev/null
+++ b/src/note-c/test/src/NoteSetLocationMode_test.cpp
@@ -0,0 +1,78 @@
+/*!
+ * @file NoteSetLocationMode_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetLocationMode")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char mode[] = "periodic";
+    const uint32_t seconds = 3600;
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetLocationMode(mode, seconds));
+        CHECK(NoteRequest_fake.call_count == 0);
+    }
+
+    SECTION("NoteRequest") {
+        NoteNewRequest_fake.return_val = JCreateObject();
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetLocationMode(mode, seconds));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetLocationMode(mode, seconds));
+        }
+
+        SECTION("Mode empty string") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetLocationMode("", seconds));
+            // If the mode parameter is the empty string, the request should
+            // have mode: "-".
+            CHECK(!strcmp("-", JGetString(NoteRequest_fake.arg0_val,
+                                          "mode")));
+        }
+
+        CHECK(NoteRequest_fake.call_count > 0);
+
+        JDelete(NoteNewRequest_fake.return_val);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetLocation_test.cpp b/src/note-c/test/src/NoteSetLocation_test.cpp
new file mode 100644
index 0000000..f3eaa5b
--- /dev/null
+++ b/src/note-c/test/src/NoteSetLocation_test.cpp
@@ -0,0 +1,68 @@
+/*!
+ * @file NoteSetLocation_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetLocation")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    float lat = 1.0;
+    float lon = 2.0;
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetLocation(lat, lon));
+        CHECK(NoteRequest_fake.call_count == 0);
+    }
+
+    SECTION("NoteRequest") {
+        NoteNewRequest_fake.return_val = JCreateObject();
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetLocation(lat, lon));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetLocation(lat, lon));
+        }
+
+        CHECK(NoteRequest_fake.call_count > 0);
+
+        JDelete(NoteNewRequest_fake.return_val);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetProductID_test.cpp b/src/note-c/test/src/NoteSetProductID_test.cpp
new file mode 100644
index 0000000..f1f5e0f
--- /dev/null
+++ b/src/note-c/test/src/NoteSetProductID_test.cpp
@@ -0,0 +1,75 @@
+/*!
+ * @file NoteSetProductID_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetProductID")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char id[] = "myid";
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetProductID(id));
+    }
+
+    SECTION("NoteRequest") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetProductID(id));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetProductID(id));
+        }
+
+        SECTION("Empty string") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetProductID(""));
+            // If the id is the empty string, the request should have
+            // product: "-".
+            CHECK(!strcmp("-", JGetString(req, "product")));
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetSerialNumber_test.cpp b/src/note-c/test/src/NoteSetSerialNumber_test.cpp
new file mode 100644
index 0000000..f4ace94
--- /dev/null
+++ b/src/note-c/test/src/NoteSetSerialNumber_test.cpp
@@ -0,0 +1,75 @@
+/*!
+ * @file NoteSetSerialNumber_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetSerialNumber")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char sn[] = "mysn";
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetSerialNumber(sn));
+    }
+
+    SECTION("NoteRequest") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetSerialNumber(sn));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetSerialNumber(sn));
+        }
+
+        SECTION("Empty string") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteSetSerialNumber(""));
+            // If the id is the empty string, the request should have
+            // product: "-".
+            CHECK(!strcmp("-", JGetString(req, "sn")));
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetSyncMode_test.cpp b/src/note-c/test/src/NoteSetSyncMode_test.cpp
new file mode 100644
index 0000000..018aa4e
--- /dev/null
+++ b/src/note-c/test/src/NoteSetSyncMode_test.cpp
@@ -0,0 +1,98 @@
+/*!
+ * @file NoteSetSyncMode_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetSyncMode")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char mode[] = "periodic";
+    int uploadMins = 30;
+    int downloadMins = 45;
+    bool align = true;
+    bool sync = false;
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetSyncMode(mode, uploadMins, downloadMins, align, sync));
+    }
+
+    SECTION("NoteRequest") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetSyncMode(mode, uploadMins, downloadMins, align, sync));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            SECTION("Zero upload minutes") {
+                uploadMins = 0;
+                CHECK(NoteSetSyncMode(mode, uploadMins, downloadMins, align,
+                                      sync));
+                CHECK(JGetObjectItem(req, "outbound") == NULL);
+                CHECK(JGetObjectItem(req, "align") == NULL);
+            }
+
+            SECTION("Non-zero upload minutes") {
+                uploadMins = 30;
+                CHECK(NoteSetSyncMode(mode, uploadMins, downloadMins, align,
+                                      sync));
+                CHECK(JGetInt(req, "outbound") == uploadMins);
+                CHECK(JGetBool(req, "align"));
+            }
+
+            SECTION("Zero download minutes") {
+                downloadMins = 0;
+                CHECK(NoteSetSyncMode(mode, uploadMins, downloadMins, align,
+                                      sync));
+                CHECK(JGetObjectItem(req, "inbound") == NULL);
+            }
+
+            SECTION("Non-zero download minutes") {
+                downloadMins = 45;
+                CHECK(NoteSetSyncMode(mode, uploadMins, downloadMins, align,
+                                      sync));
+                CHECK(JGetInt(req, "inbound") == downloadMins);
+            }
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSetUploadMode_test.cpp b/src/note-c/test/src/NoteSetUploadMode_test.cpp
new file mode 100644
index 0000000..dec9233
--- /dev/null
+++ b/src/note-c/test/src/NoteSetUploadMode_test.cpp
@@ -0,0 +1,80 @@
+/*!
+ * @file NoteSetUploadMode_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSetUploadMode")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char mode[] = "periodic";
+    int mins = 30;
+    bool align = true;
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteSetUploadMode(mode, mins, align));
+    }
+
+    SECTION("NoteRequest") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSetUploadMode(mode, mins, align));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            SECTION("Zero minutes") {
+                mins = 0;
+                CHECK(NoteSetUploadMode(mode, mins, align));
+                CHECK(JGetObjectItem(req, "outbound") == NULL);
+                CHECK(JGetObjectItem(req, "align") == NULL);
+            }
+
+            SECTION("Non-zero minutes") {
+                mins = 30;
+                CHECK(NoteSetUploadMode(mode, mins, align));
+                CHECK(JGetInt(req, "outbound") == mins);
+                CHECK(JGetBool(req, "align"));
+            }
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteSleep_test.cpp b/src/note-c/test/src/NoteSleep_test.cpp
new file mode 100644
index 0000000..4187a50
--- /dev/null
+++ b/src/note-c/test/src/NoteSleep_test.cpp
@@ -0,0 +1,80 @@
+/*!
+ * @file NoteSleep_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewCommand, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteSleep")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char payload[] = "ewogICJpbnRlcnZhbHMiOiI2MCwxMiwxNCIKfQ==";
+    uint32_t seconds = 10;
+    const char modes[] = "modea,modeb";
+
+    SECTION("NoteNewCommand fails") {
+        NoteNewCommand_fake.return_val = NULL;
+
+        CHECK(!NoteSleep(payload, seconds, modes));
+        CHECK(NoteRequest_fake.call_count == 0);
+    }
+
+    SECTION("NoteNewCommand succeeds") {
+        J *cmd = JCreateObject();
+        REQUIRE(cmd != NULL);
+        NoteNewCommand_fake.return_val = cmd;
+
+        SECTION("NoteRequest fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteSleep(payload, seconds, NULL));
+            JDelete(cmd);
+        }
+
+        SECTION("NoteRequest succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            SECTION("Additional modes") {
+                CHECK(NoteSleep(payload, seconds, modes));
+                CHECK(!strcmp("sleep,modea,modeb",
+                              JGetString(NoteRequest_fake.arg0_val, "mode")));
+            }
+
+            SECTION("No additional modes") {
+                CHECK(NoteSleep(payload, seconds, NULL));
+                CHECK(NoteRequest_fake.call_count > 0);
+            }
+
+            CHECK(NoteRequest_fake.call_count > 0);
+            JDelete(cmd);
+        }
+    }
+
+    RESET_FAKE(NoteNewCommand);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteTemplate_test.cpp b/src/note-c/test/src/NoteTemplate_test.cpp
new file mode 100644
index 0000000..10b1898
--- /dev/null
+++ b/src/note-c/test/src/NoteTemplate_test.cpp
@@ -0,0 +1,68 @@
+/*!
+ * @file NoteTemplate_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(bool, NoteRequest, J *)
+
+namespace
+{
+
+SCENARIO("NoteTemplate")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    const char target[] = "notefile";
+    J *body = JCreateObject();
+    REQUIRE(body != NULL);
+
+    SECTION("NoteNewRequest fails") {
+        NoteNewRequest_fake.return_val = NULL;
+
+        CHECK(!NoteTemplate(target, body));
+    }
+
+    SECTION("NoteRequest") {
+        J *req = JCreateObject();
+        REQUIRE(req != NULL);
+        NoteNewRequest_fake.return_val = req;
+
+        SECTION("Fails") {
+            NoteRequest_fake.return_val = false;
+
+            CHECK(!NoteTemplate(target, body));
+        }
+
+        SECTION("Succeeds") {
+            NoteRequest_fake.return_val = true;
+
+            CHECK(NoteTemplate(target, body));
+        }
+
+        JDelete(req);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteTimeSet_test.cpp b/src/note-c/test/src/NoteTimeSet_test.cpp
new file mode 100644
index 0000000..f3eb6e1
--- /dev/null
+++ b/src/note-c/test/src/NoteTimeSet_test.cpp
@@ -0,0 +1,84 @@
+/*!
+ * @file NoteTimeSet_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "time_mocks.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+
+namespace
+{
+
+SCENARIO("NoteTimeSet")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    JTIME baseTime = 1679003056;
+    int offset = 5;
+    char zone[] = "PDT";
+    char country[] = "US";
+    char area[] = "CA";
+    int retOffset = 0;
+    char *retZone = NULL;
+    char *retCountry = NULL;
+    char *retArea = NULL;
+    NoteGetMs_fake.custom_fake = NoteGetMsIncrement;
+
+    SECTION("Set and unset") {
+        NoteTimeSet(baseTime, offset, zone, country, area);
+        JTIME currTime = NoteTime();
+        CHECK(currTime > baseTime);
+        CHECK(NoteRegion(&retCountry, &retArea, &retZone, &retOffset));
+        // Verify that setting the region information with NoteTimeSet worked.
+        CHECK(offset == retOffset);
+        CHECK(strcmp(zone, retZone) == 0);
+        CHECK(strcmp(country, retCountry) == 0);
+        CHECK(strcmp(area, retArea) == 0);
+
+        // Verify that passing a base time of 0 to NoteTimeSet causes us to go
+        // back to using the time from the Notecard.
+        NoteTimeSet(0, offset, zone, country, area);
+        currTime = NoteTime();
+        // Check that a card.time request was made.
+        CHECK(strcmp(NoteNewRequest_fake.arg0_val, "card.time") == 0);
+        // Setting the base time to 0 seconds also invalidates the region info.
+        CHECK(!NoteRegion(&retCountry, &retArea, &retZone, &retOffset));
+        CHECK(0 == retOffset);
+        CHECK(strcmp("UTC", retZone) == 0);
+        CHECK(strcmp("", retCountry) == 0);
+        CHECK(strcmp("", retArea) == 0);
+    }
+
+    SECTION("NULL region info") {
+        NoteTimeSet(baseTime, offset, NULL, NULL, NULL);
+        CHECK(NoteRegion(&retCountry, &retArea, &retZone, &retOffset));
+        CHECK(offset == retOffset);
+        CHECK(strcmp("UTC", retZone) == 0);
+        CHECK(strcmp("", retCountry) == 0);
+        CHECK(strcmp("", retArea) == 0);
+    }
+
+    RESET_FAKE(NoteGetMs);
+    RESET_FAKE(NoteNewRequest);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteTime_test.cpp b/src/note-c/test/src/NoteTime_test.cpp
new file mode 100644
index 0000000..2225552
--- /dev/null
+++ b/src/note-c/test/src/NoteTime_test.cpp
@@ -0,0 +1,105 @@
+/*!
+ * @file NoteTime_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "time_mocks.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, NoteNewRequest, const char *)
+FAKE_VALUE_FUNC(J *, NoteRequestResponse, J *)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+
+namespace
+{
+
+SCENARIO("NoteTime")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    SECTION("No response to card.time") {
+        NoteRequestResponse_fake.return_val = NULL;
+        NoteGetMs_fake.return_val = 1000;
+
+        // Unable to get time from Notecard, so we should get back the
+        // seconds since boot.
+        CHECK(NoteTime() == 1);
+    }
+
+    SECTION("card.time errors") {
+        J* resp = JCreateObject();
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+        NoteGetMs_fake.return_val = 1000;
+
+        SECTION("err field present") {
+            JAddStringToObject(resp, "err", "an error");
+        }
+
+        SECTION("No time field") {
+        }
+
+        CHECK(NoteTime() == 1);
+    }
+
+    SECTION("card.time valid") {
+        NoteGetMs_fake.custom_fake = NoteGetMsIncrement;
+        char respRaw[] =
+            "{ \
+          \"time\": 1599769214, \
+          \"area\": \"Beverly, MA\", \
+          \"zone\": \"CDT,America/New York\", \
+          \"minutes\": -300, \
+          \"lat\": 42.5776, \
+          \"lon\": -70.87134, \
+          \"country\": \"US\" \
+        }";
+        J *resp = JParse(respRaw);
+        REQUIRE(resp != NULL);
+        NoteRequestResponse_fake.return_val = resp;
+
+        JTIME time = NoteTime();
+        // The returned time should be less than what's in the JSON response
+        // from the Notecard because NoteTimeST subtracts the time it took to
+        // fetch the time.
+        CHECK((time > 0 && time < 1599769214));
+    }
+
+    SECTION("Millisecond rollover") {
+        JTIME baseTime = 1679335667;
+        uint32_t baseTimeSetAtMs = 1000;
+        uint32_t rolloverMs = 500;
+        uint32_t getMsRetVals[] = {baseTimeSetAtMs, rolloverMs};
+        SET_RETURN_SEQ(NoteGetMs, getMsRetVals, 2);
+
+        // Set the time manually so that the base time is non-zero.
+        NoteTimeSet(baseTime, 0, NULL, NULL, NULL);
+        // Compute the new base time, taking into account the millisecond
+        // rollover.
+        JTIME newBaseTime = baseTime + (0x100000000LL + rolloverMs -
+                                        baseTimeSetAtMs) / 1000;
+        CHECK(NoteTime() == newBaseTime);
+    }
+
+    RESET_FAKE(NoteNewRequest);
+    RESET_FAKE(NoteRequestResponse);
+    RESET_FAKE(NoteGetMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteTransactionHooks_test.cpp b/src/note-c/test/src/NoteTransactionHooks_test.cpp
new file mode 100644
index 0000000..13fb3a3
--- /dev/null
+++ b/src/note-c/test/src/NoteTransactionHooks_test.cpp
@@ -0,0 +1,63 @@
+/*!
+ * @file NoteTransactionHooks_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "n_lib.h"
+
+namespace
+{
+
+bool txnStartCalled = false;
+bool txnStopCalled = false;
+
+bool MyTxnStart(uint32_t)
+{
+    txnStartCalled = true;
+    return true;
+}
+
+void MyTxnStop()
+{
+    txnStopCalled = true;
+    return;
+}
+
+SCENARIO("NoteTransactionHooks")
+{
+    SECTION("Hooks not set") {
+        noteTransactionStart(0);
+        noteTransactionStop();
+
+        CHECK(!txnStartCalled);
+        CHECK(!txnStopCalled);
+    }
+
+    SECTION("Hooks set") {
+        NoteSetFnTransaction(MyTxnStart, MyTxnStop);
+        noteTransactionStart(0);
+        noteTransactionStop();
+
+        CHECK(txnStartCalled);
+        CHECK(txnStopCalled);
+    }
+
+    txnStartCalled = false;
+    txnStopCalled = false;
+}
+
+}
+
+
diff --git a/src/note-c/test/src/NoteTransaction_test.cpp b/src/note-c/test/src/NoteTransaction_test.cpp
new file mode 100644
index 0000000..9787c64
--- /dev/null
+++ b/src/note-c/test/src/NoteTransaction_test.cpp
@@ -0,0 +1,446 @@
+/*!
+ * @file NoteTransaction_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2024 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NoteReset)
+FAKE_VALUE_FUNC(const char *, noteJSONTransaction, const char *, size_t, char **, uint32_t)
+FAKE_VALUE_FUNC(bool, noteTransactionStart, uint32_t)
+FAKE_VALUE_FUNC(J *, NoteUserAgent)
+FAKE_VALUE_FUNC(bool, crcError, char *, uint16_t)
+
+namespace
+{
+
+const char *noteJSONTransactionValid(const char *, size_t, char **resp, uint32_t)
+{
+    static char respString[] = "{ \"total\": 1 }";
+
+    if (resp) {
+        char* respBuf = reinterpret_cast<char *>(malloc(sizeof(respString)));
+        memcpy(respBuf, respString, sizeof(respString));
+        *resp = respBuf;
+    }
+
+    return NULL;
+}
+
+const char *noteJSONTransactionBadJSON(const char *, size_t, char **resp, uint32_t)
+{
+    static char respString[] = "Bad JSON";
+
+    if (resp) {
+        char* respBuf = reinterpret_cast<char *>(malloc(sizeof(respString)));
+        memcpy(respBuf, respString, sizeof(respString));
+        *resp = respBuf;
+    }
+
+    return NULL;
+}
+
+const char *noteJSONTransactionIOError(const char *, size_t, char **resp, uint32_t)
+{
+    static char respString[] = "{\"err\": \"{io}\"}";
+
+    if (resp) {
+        char* respBuf = reinterpret_cast<char *>(malloc(sizeof(respString)));
+        memcpy(respBuf, respString, sizeof(respString));
+        *resp = respBuf;
+    }
+
+    return NULL;
+}
+
+const char *noteJSONTransactionNotSupportedError(const char *, size_t, char **resp, uint32_t)
+{
+    static char respString[] = "{\"err\": \"{not-supported}\"}";
+
+    if (resp) {
+        char* respBuf = reinterpret_cast<char *>(malloc(sizeof(respString)));
+        memcpy(respBuf, respString, sizeof(respString));
+        *resp = respBuf;
+    }
+
+    return NULL;
+}
+
+SCENARIO("NoteTransaction")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    // NoteReset's mock should succeed unless the test explicitly instructs
+    // it to fail.
+    NoteReset_fake.return_val = true;
+    noteTransactionStart_fake.return_val = true;
+    crcError_fake.return_val = false;
+
+    SECTION("Passing a NULL request returns NULL") {
+        CHECK(NoteTransaction(NULL) == NULL);
+    }
+
+    SECTION("noteTransactionStart fails") {
+        noteTransactionStart_fake.return_val = false;
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+
+        CHECK(NoteTransaction(req) == NULL);
+
+        JDelete(req);
+    }
+
+    SECTION("A response is expected and the response is valid") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = noteJSONTransactionValid;
+
+        J *resp = NoteTransaction(req);
+
+        CHECK(noteJSONTransaction_fake.call_count == 1);
+        CHECK(resp != NULL);
+        // Ensure there's no error in the response.
+        CHECK(!NoteResponseError(resp));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("A response is expected and the response has an error") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.return_val = "This is an error.";
+
+        J *resp = NoteTransaction(req);
+
+        // Ensure the mock is called at least once
+        // Here the error causes multiple invocations by retries
+        CHECK(noteJSONTransaction_fake.call_count >= 1);
+
+        // Ensure there's an error in the response.
+        CHECK(resp != NULL);
+        CHECK(NoteResponseError(resp));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    WHEN("The transaction is successful and the response has a {bad-bin} error") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = [](const char *, size_t, char **response, uint32_t) -> const char * {
+            const char rsp_str[] = "{\"err\":\"{bad-bin}\"}";
+            *response = (char *)malloc(sizeof(rsp_str));
+            strncpy(*response, rsp_str, sizeof(rsp_str));
+            return nullptr;
+        };
+
+        J *resp = NoteTransaction(req);
+
+        // Ensure the mock is called at least once
+        // Here the error causes multiple invocations by retries
+        REQUIRE(noteJSONTransaction_fake.call_count >= 1);
+
+        THEN("An error is returned") {
+            CHECK(resp != NULL);
+        }
+
+        THEN("The transaction is not retried") {
+            CHECK(noteJSONTransaction_fake.call_count == 1);
+        }
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    WHEN("The transaction is successful and the response contains invalid JSON") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = [](const char *, size_t, char **response, uint32_t) -> const char * {
+            const char rsp_str[] = "{Looks like JSON, but won't parse}";
+            *response = (char *)malloc(sizeof(rsp_str));
+            strncpy(*response, rsp_str, sizeof(rsp_str));
+            return nullptr;
+        };
+
+        J *resp = NoteTransaction(req);
+
+        // Ensure the mock is called at least once
+        // Here the error causes multiple invocations by retries
+        REQUIRE(noteJSONTransaction_fake.call_count >= 1);
+
+        THEN("An error is returned") {
+            CHECK(resp != NULL);
+        }
+
+        THEN("The transaction is retried") {
+            CHECK(noteJSONTransaction_fake.call_count == (1 + CARD_REQUEST_RETRIES_ALLOWED));
+        }
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+#ifndef NOTE_C_LOW_MEM
+    SECTION("Bad CRC") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = noteJSONTransactionValid;
+        crcError_fake.return_val = true;
+
+        J *resp = NoteTransaction(req);
+
+        CHECK(resp != NULL);
+        CHECK(NoteResponseError(resp));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+#endif // !NOTE_C_LOW_MEM
+
+    SECTION("I/O error") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = noteJSONTransactionIOError;
+
+        J *resp = NoteTransaction(req);
+
+        CHECK(resp != NULL);
+        CHECK(NoteResponseError(resp));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    GIVEN("A valid request") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+
+        AND_GIVEN("noteJSONTransaction returns a response with a \"not "
+                  "supported\" error") {
+            noteJSONTransaction_fake.custom_fake = noteJSONTransactionNotSupportedError;
+
+            WHEN("NoteTransaction is called") {
+                J *rsp = NoteTransaction(req);
+
+                THEN("The response contains the \"not supported\" error") {
+                    CHECK(JContainsString(rsp, c_err, c_unsupported));
+                }
+
+                THEN("noteJSONTransaction is only called once (no retries)") {
+                    CHECK(noteJSONTransaction_fake.call_count == 1);
+                }
+
+                JDelete(rsp);
+            }
+        }
+
+        JDelete(req);
+    }
+
+    SECTION("A reset is required and it fails") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        NoteResetRequired();
+        // Force NoteReset failure.
+        NoteReset_fake.return_val = false;
+
+        J *resp = NoteTransaction(req);
+
+        CHECK(NoteReset_fake.call_count == 1);
+        // The transaction shouldn't be attempted if reset failed.
+        CHECK(noteJSONTransaction_fake.call_count == 0);
+        // The response should be null if reset failed.
+        CHECK(resp == NULL);
+
+        JDelete(req);
+    }
+
+    SECTION("Serializing the JSON request fails") {
+        // Create an invalid J object.
+        J *req = reinterpret_cast<J *>(malloc(sizeof(J)));
+        REQUIRE(req != NULL);
+        memset(req, 0, sizeof(J));
+
+        J *resp = NoteTransaction(req);
+
+        // The transaction shouldn't be attempted if the request couldn't be
+        // serialized.
+        CHECK(noteJSONTransaction_fake.call_count == 0);
+        // Ensure there's an error in the response.
+        CHECK(resp != NULL);
+        CHECK(NoteResponseError(resp));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("No response is expected") {
+        J *req = NoteNewCommand("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = noteJSONTransactionValid;
+
+        J *resp = NoteTransaction(req);
+
+        CHECK(noteJSONTransaction_fake.call_count == 1);
+        CHECK(resp != NULL);
+        // Ensure there's no error in the response.
+        CHECK(!NoteResponseError(resp));
+        // Ensure a blank object was returned.
+        J *expectedResp = JCreateObject();
+        CHECK(JCompare(resp, expectedResp, true));
+
+        JDelete(req);
+        JDelete(resp);
+        JDelete(expectedResp);
+    }
+
+    SECTION("Parsing the JSON response fails") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        noteJSONTransaction_fake.custom_fake = noteJSONTransactionBadJSON;
+
+        J *resp = NoteTransaction(req);
+
+        CHECK(noteJSONTransaction_fake.call_count >= 1);
+        CHECK(resp != NULL);
+        // Ensure there's an error in the response.
+        CHECK(NoteResponseError(resp));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+#ifndef NOTE_DISABLE_USER_AGENT
+    SECTION("hub.set with product adds user agent information") {
+        J *req = NoteNewRequest("hub.set");
+        REQUIRE(req != NULL);
+        JAddStringToObject(req, "product", "a.b.c:d");
+        noteJSONTransaction_fake.custom_fake = noteJSONTransactionValid;
+        NoteUserAgent_fake.return_val = JCreateObject();
+
+        J *resp = NoteTransaction(req);
+        CHECK(resp != NULL);
+        CHECK(NoteUserAgent_fake.call_count > 0);
+
+        JDelete(req);
+        JDelete(resp);
+    }
+#endif // !NOTE_DISABLE_USER_AGENT
+
+    SECTION("Regular transactions have a timeout of CARD_INTER_TRANSACTION_TIMEOUT_SEC seconds") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == (CARD_INTER_TRANSACTION_TIMEOUT_SEC * 1000));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`note.add` with `milliseconds` updates timeout value with `milliseconds`") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        JAddIntToObject(req, "milliseconds", 9171979);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == 9171979);
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`note.add` with `seconds` updates timeout value with `seconds`") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        JAddIntToObject(req, "seconds", 917);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == (917 * 1000));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`note.add` with both `milliseconds` and `seconds` updates timeout value with `milliseconds`") {
+        J *req = NoteNewRequest("note.add");
+        REQUIRE(req != NULL);
+        JAddIntToObject(req, "seconds", 917);
+        JAddIntToObject(req, "milliseconds", 9171979);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == 9171979);
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`web.post` with `milliseconds` updates timeout value with `milliseconds`") {
+        J *req = NoteNewRequest("web.post");
+        REQUIRE(req != NULL);
+        JAddIntToObject(req, "milliseconds", 9171979);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == 9171979);
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`web.post` with `seconds` updates timeout value with `seconds`") {
+        J *req = NoteNewRequest("web.post");
+        REQUIRE(req != NULL);
+        JAddIntToObject(req, "seconds", 1979);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == (1979 * 1000));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`web.post` with both `milliseconds` and `seconds` updates timeout value with `milliseconds`") {
+        J *req = NoteNewRequest("web.post");
+        REQUIRE(req != NULL);
+        JAddIntToObject(req, "seconds", 917);
+        JAddIntToObject(req, "milliseconds", 9171979);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == 9171979);
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    SECTION("`web.post` without `milliseconds` or `seconds` updates timeout value with 90 seconds") {
+        J *req = NoteNewRequest("web.post");
+        REQUIRE(req != NULL);
+
+        J *resp = NoteTransaction(req);
+        CHECK(noteJSONTransaction_fake.arg3_val == (90 * 1000));
+
+        JDelete(req);
+        JDelete(resp);
+    }
+
+    RESET_FAKE(NoteReset);
+    RESET_FAKE(noteJSONTransaction);
+    RESET_FAKE(noteTransactionStart);
+    RESET_FAKE(crcError);
+}
+
+}
diff --git a/src/note-c/test/src/NoteUserAgent_test.cpp b/src/note-c/test/src/NoteUserAgent_test.cpp
new file mode 100644
index 0000000..e773e16
--- /dev/null
+++ b/src/note-c/test/src/NoteUserAgent_test.cpp
@@ -0,0 +1,100 @@
+/*!
+ * @file NoteUserAgent_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include "n_lib.h"
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+// This has to come after n_lib.h, which will define NOTE_DISABLE_USER_AGENT if
+// NOTE_C_LOW_MEM is defined.
+#ifndef NOTE_DISABLE_USER_AGENT
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(J *, JCreateObject)
+
+static bool calledNoteUserAgentUpdate = false;
+// NoteUserAgentUpdate is a weak function, so we should be able to override it
+// here.
+void NoteUserAgentUpdate(J *)
+{
+    calledNoteUserAgentUpdate = true;
+}
+
+namespace
+{
+
+SCENARIO("NoteUserAgent")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    calledNoteUserAgentUpdate = false;
+
+    SECTION("JCreateObject fails") {
+        JCreateObject_fake.return_val = NULL;
+
+        CHECK(NoteUserAgent() == NULL);
+    }
+
+    SECTION("Success") {
+        J* json = (J *)NoteMalloc(sizeof(J));
+        REQUIRE(json != NULL);
+        memset(json, 0, sizeof(J));
+        json->type = JObject;
+        JCreateObject_fake.return_val = json;
+
+        char agent[] = "agent";
+        NoteSetUserAgent(agent);
+
+        char os[] = "os";
+        char platform[] = "platform";
+        char family[] = "family";
+        char version[] = "version";
+        NoteSetUserAgentOS(os, platform, family, version);
+
+        const int mem = 1;
+        const int mhz = 2;
+        const int cores = 3;
+        char vendor[] = "vendor";
+        char cpu[] = "cpu";
+        NoteSetUserAgentCPU(mem, mhz, cores, vendor, cpu);
+
+        J *ua = NoteUserAgent();
+        REQUIRE(ua != NULL);
+        CHECK(strcmp(JGetString(ua, "agent"), agent) == 0);
+#if defined(__GNUC__)
+        CHECK(strstr(JGetString(ua, "compiler"), "gcc") != NULL);
+#endif
+        CHECK(strcmp(JGetString(ua, "req_interface"), "unknown") == 0);
+        CHECK(JGetInt(ua, "cpu_mem") == mem);
+        CHECK(JGetInt(ua, "cpu_mhz") == mhz);
+        CHECK(JGetInt(ua, "cpu_cores") == cores);
+        CHECK(strcmp(JGetString(ua, "cpu_vendor"), vendor) == 0);
+        CHECK(strcmp(JGetString(ua, "cpu_name"), cpu) == 0);
+        CHECK(strcmp(JGetString(ua, "os_name"), os) == 0);
+        CHECK(strcmp(JGetString(ua, "os_platform"), platform) == 0);
+        CHECK(strcmp(JGetString(ua, "os_family"), family) == 0);
+        CHECK(strcmp(JGetString(ua, "os_version"), version) == 0);
+
+        CHECK(calledNoteUserAgentUpdate);
+
+        JDelete(json);
+    }
+
+    RESET_FAKE(JCreateObject);
+}
+
+}
+
+#endif // !NOTE_DISABLE_USER_AGENT
diff --git a/src/note-c/test/src/NoteWake_test.cpp b/src/note-c/test/src/NoteWake_test.cpp
new file mode 100644
index 0000000..d890866
--- /dev/null
+++ b/src/note-c/test/src/NoteWake_test.cpp
@@ -0,0 +1,79 @@
+/*!
+ * @file NoteWake_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, NotePayloadRetrieveAfterSleep, NotePayloadDesc *)
+
+namespace
+{
+
+const uint8_t expectedState[] = {0xDE, 0xAD, 0xBE, 0xEF};
+const size_t stateLen = sizeof(expectedState);
+
+bool NotePayloadRetrieveAfterSleepWrongLen(NotePayloadDesc *desc)
+{
+    memset(desc, 0, sizeof(NotePayloadDesc));
+    desc->length = stateLen - 1;
+
+    return true;
+}
+
+bool NotePayloadRetrieveAfterSleepValid(NotePayloadDesc *desc)
+{
+    memset(desc, 0, sizeof(NotePayloadDesc));
+    desc->data = (uint8_t *)malloc(stateLen);
+    memcpy(desc->data, expectedState, stateLen);
+    desc->length = stateLen;
+
+    return true;
+}
+
+SCENARIO("NoteWake")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+    uint8_t actualState[sizeof(expectedState)] = {0};
+
+    SECTION("Errors") {
+        SECTION("NotePayloadRetrieveAfterSleep fails") {
+            NotePayloadRetrieveAfterSleep_fake.return_val = false;
+        }
+
+        SECTION("Wrong length") {
+            NotePayloadRetrieveAfterSleep_fake.custom_fake =
+                NotePayloadRetrieveAfterSleepWrongLen;
+        }
+
+        CHECK(!NoteWake(stateLen, actualState));
+    }
+
+    SECTION("Success") {
+        NotePayloadRetrieveAfterSleep_fake.custom_fake =
+            NotePayloadRetrieveAfterSleepValid;
+
+        CHECK(NoteWake(stateLen, actualState));
+        CHECK(memcmp(expectedState, actualState, stateLen) == 0);
+    }
+
+    RESET_FAKE(NotePayloadRetrieveAfterSleep);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/crcAdd_test.cpp b/src/note-c/test/src/crcAdd_test.cpp
new file mode 100644
index 0000000..272dbb8
--- /dev/null
+++ b/src/note-c/test/src/crcAdd_test.cpp
@@ -0,0 +1,71 @@
+/*!
+ * @file crcAdd_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#ifndef NOTE_C_LOW_MEM
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+
+namespace
+{
+
+SCENARIO("crcAdd")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    char validReq[] = "{\"req\": \"hub.sync\"}";
+    uint16_t seqNo = 1;
+
+    SECTION("NoteMalloc fails") {
+        NoteMalloc_fake.return_val = NULL;
+
+        CHECK(crcAdd(validReq, seqNo) == NULL);
+    }
+
+    SECTION("NoteMalloc succeeds") {
+        NoteMalloc_fake.custom_fake = malloc;
+
+        char emptyStringReq[] = "";
+        char invalidJsonReq[] = "{\"req\":";
+
+        SECTION("Empty string") {
+            CHECK(crcAdd(emptyStringReq, seqNo) == NULL);
+        }
+
+        SECTION("Invalid JSON") {
+            CHECK(crcAdd(invalidJsonReq, seqNo) == NULL);
+        }
+
+        SECTION("Valid JSON") {
+            const char expectedNewJson[] = "{\"req\": \"hub.sync\",\"crc\":\"0001:DF2B9115\"}";
+            char *newJson = crcAdd(validReq, seqNo);
+
+            REQUIRE(newJson != NULL);
+            CHECK(strcmp(expectedNewJson, newJson) == 0);
+
+            NoteFree(newJson);
+        }
+    }
+
+    RESET_FAKE(NoteMalloc);
+}
+
+}
+
+#endif // !NOTE_C_LOW_MEM
diff --git a/src/note-c/test/src/crcError_test.cpp b/src/note-c/test/src/crcError_test.cpp
new file mode 100644
index 0000000..26115b9
--- /dev/null
+++ b/src/note-c/test/src/crcError_test.cpp
@@ -0,0 +1,88 @@
+/*!
+ * @file crcError_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+#ifndef NOTE_C_LOW_MEM
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "test_static.h"
+
+namespace
+{
+
+SCENARIO("crcError")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    uint16_t seqNo = 1;
+
+    SECTION("Empty string") {
+        char json[] = "";
+
+        CHECK(!crcError(json, seqNo));
+    }
+
+    SECTION("Invalid JSON") {
+        char json[] = "{\"req\":";
+
+        CHECK(!crcError(json, seqNo));
+    }
+
+    SECTION("No CRC field") {
+        char json[] = "{\"req\": \"hub.sync\"}";
+
+        CHECK(!crcError(json, seqNo));
+    }
+
+    SECTION("CRC field at unexpected position") {
+        char json[] = "{\"crc\":\"0009:10BAC79A\",\"req\": \"hub.sync\"}";
+
+        CHECK(!crcError(json, seqNo));
+    }
+
+    SECTION("Valid JSON and CRC field present") {
+
+        SECTION("CRC doesn't match") {
+            char json[] = "{\"req\":\"hub.sync\",\"crc\":\"0001:DEADBEEF\"}";
+
+            CHECK(crcError(json, seqNo));
+        }
+
+        SECTION("Sequence number doesn't match") {
+            char json[] = "{\"req\":\"hub.sync\",\"crc\":\"0009:10BAC79A\"}";
+
+            CHECK(crcError(json, seqNo));
+        }
+
+        SECTION("Everything matches") {
+            char json[] = "{\"req\":\"hub.sync\"}";
+            char *jsonWithCrc = crcAdd(json, seqNo);
+            REQUIRE(jsonWithCrc != NULL);
+
+            CHECK(!crcError(jsonWithCrc, seqNo));
+
+            NoteFree(jsonWithCrc);
+        }
+
+        SECTION("Trailing CRLF") {
+            char json[] = "{\"req\":\"hub.sync\",\"crc\":\"0001:10BAC79A\"}\r\n";
+
+            // Trailing \r\n should be ignored.
+            CHECK(!crcError(json, seqNo));
+        }
+    }
+}
+
+}
+
+#endif // !NOTE_C_LOW_MEM
diff --git a/src/note-c/test/src/i2cChunkedReceive_test.cpp b/src/note-c/test/src/i2cChunkedReceive_test.cpp
new file mode 100644
index 0000000..99346d0
--- /dev/null
+++ b/src/note-c/test/src/i2cChunkedReceive_test.cpp
@@ -0,0 +1,418 @@
+/*!
+ * @file i2cChunkedReceive_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+#include "time_mocks.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(const char *, noteI2CReceive, uint16_t, uint8_t *, uint16_t,
+                uint32_t *)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+FAKE_VOID_FUNC(NoteDelayMs, uint32_t)
+
+namespace
+{
+
+const char *noteI2CReceiveInfinite(uint16_t, uint8_t *buf, uint16_t size,
+                                   uint32_t *available)
+{
+    memset(buf, 'a', size);
+    *available = NOTE_I2C_MAX_DEFAULT;
+
+    return NULL;
+}
+
+SCENARIO("i2cChunkedReceive")
+{
+    NoteGetMs_fake.custom_fake = NoteGetMsIncrement;
+
+    uint32_t available = 0;
+    uint32_t timeoutMs = 5000;
+
+    GIVEN("0 is specified for the output buffer length") {
+        uint8_t buf[] = {0xAB};
+        uint32_t zeroSize = 0;
+
+        AND_GIVEN("noteI2CReceive reports that here are bytes available from "
+                  "the Notecard") {
+            noteI2CReceive_fake.custom_fake = noteI2CReceiveInfinite;
+
+            WHEN("i2cChunkedReceive is called") {
+                uint32_t originalAvailable = available;
+                const char *err = i2cChunkedReceive(buf, &zeroSize, true,
+                                                    timeoutMs, &available);
+
+                THEN("No error is returned") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("Size is 0") {
+                    CHECK(zeroSize == 0);
+                }
+
+                THEN("available is exactly the number of bytes reported "
+                     "available by noteI2CReceive") {
+                    CHECK(available == NOTE_I2C_MAX_DEFAULT);
+                }
+            }
+        }
+    }
+
+    GIVEN("noteI2CReceive returns an error") {
+        uint8_t buf[] = {0xAB};
+        uint32_t size = sizeof(buf);
+        noteI2CReceive_fake.return_val = "some error";
+
+        WHEN("i2cChunkedReceive is called") {
+            const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                &available);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The output buffer is too small") {
+        uint8_t buf[NOTE_I2C_MAX_DEFAULT] = {0};
+        uint32_t size = sizeof(buf);
+        noteI2CReceive_fake.custom_fake = noteI2CReceiveInfinite;
+
+        WHEN("i2cChunkedReceive is called") {
+            const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The output size is exactly the number of bytes returned by "
+                 "noteI2CReceive") {
+                CHECK(size == NOTE_I2C_MAX_DEFAULT);
+            }
+
+            THEN("available is exactly the number of bytes reported available "
+                 "by noteI2CReceive") {
+                CHECK(available == NOTE_I2C_MAX_DEFAULT);
+            }
+
+            THEN("The output buffer contains exactly the bytes returned by "
+                 "noteI2CReceive") {
+                uint8_t expectedBuf[sizeof(buf)];
+                memset(expectedBuf, 'a', sizeof(expectedBuf));
+
+                CHECK(memcmp(buf, expectedBuf, sizeof(expectedBuf)) == 0);
+            }
+        }
+    }
+
+    GIVEN("The output buffer is sufficiently large") {
+        uint8_t buf[NOTE_I2C_MAX_DEFAULT * 3] = {0};
+        uint32_t size = sizeof(buf);
+
+        noteI2CReceive_fake.custom_fake = [](uint16_t, uint8_t *buf,
+        uint16_t size, uint32_t *available) -> const char* {
+            // If noteI2CReceive is called with size 0, the caller is querying
+            // the Notecard for how many bytes are available. Here, we report
+            // back that there are NOTE_I2C_MAX_DEFAULT * 2 bytes available.
+            if (size == 0)
+            {
+                *available = NOTE_I2C_MAX_DEFAULT * 2;
+            }
+            // If the user has requested all the available bytes, return a
+            // sequence of a's with a newline at the end.
+            else if (*available == size)
+            {
+                memset(buf, 'a', size - 1);
+                buf[size - 1] = '\n';
+                *available = 0;
+            }
+            // If the user has requested less than the available bytes, just
+            // return as many a's as they requested, and deduct that amount
+            // from what's available.
+            else
+            {
+                memset(buf, 'a', size);
+                *available -= size;
+            }
+
+            return NULL;
+        };
+
+        // TODO: See if this and the AND_GIVEN below can be refactored to reduce
+        // repetition.
+        AND_GIVEN("available is non-zero to start") {
+            size_t numBytesExpected = 10;
+            available = 10;
+
+            WHEN("i2cChunkedReceive is called") {
+                const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                    &available);
+
+                THEN("No error is returned") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("The output size is exactly the number of bytes returned"
+                     "by noteI2CReceive") {
+                    CHECK(size == numBytesExpected);
+                }
+
+                THEN("available is 0") {
+                    CHECK(available == 0);
+                }
+
+                THEN("The output buffer contains exactly the bytes returned by "
+                     "noteI2CReceive") {
+                    uint8_t expectedBuf[10];
+                    memset(expectedBuf, 'a', sizeof(expectedBuf) - 1);
+                    expectedBuf[sizeof(expectedBuf) - 1] = '\n';
+
+                    CHECK(memcmp(buf, expectedBuf, sizeof(expectedBuf)) == 0);
+                }
+            }
+        }
+
+        AND_GIVEN("available is zero to start") {
+            size_t numBytesExpected = NOTE_I2C_MAX_DEFAULT * 2;
+            available = 0;
+
+            WHEN("i2cChunkedReceive is called") {
+                const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                    &available);
+
+                THEN("No error is returned") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("The output size is exactly the number of bytes returned"
+                     "by noteI2CReceive") {
+                    CHECK(size == numBytesExpected);
+                }
+
+                THEN("available is 0") {
+                    CHECK(available == 0);
+                }
+
+                THEN("The output buffer contains exactly the bytes returned by "
+                     "noteI2CReceive") {
+                    uint8_t expectedBuf[NOTE_I2C_MAX_DEFAULT * 2];
+                    memset(expectedBuf, 'a', sizeof(expectedBuf) - 1);
+                    expectedBuf[sizeof(expectedBuf) - 1] = '\n';
+
+                    CHECK(memcmp(buf, expectedBuf, sizeof(expectedBuf)) == 0);
+                }
+            }
+        }
+    }
+
+    GIVEN("End-of-packet (\\n) is received, but noteI2CReceive indicates more "
+          "is still available to read") {
+        uint8_t buf[NOTE_I2C_MAX_DEFAULT * 3] = {0};
+        uint32_t size = sizeof(buf);
+        size_t numBytesExpected = NOTE_I2C_MAX_DEFAULT * 2;
+
+        // On the first call, noteI2CReceive reports back that
+        // NOTE_I2C_MAX_DEFAULT are available to read.
+        auto bytesAvailable = [](uint16_t, uint8_t *buf, uint16_t size,
+        uint32_t *available) -> const char* {
+            *available = NOTE_I2C_MAX_DEFAULT;
+
+            return NULL;
+        };
+        // On the next call, NOTE_I2C_MAX_DEFAULT-1 a's are written to the
+        // output buffer followed by a newline. We report back that
+        // NOTE_I2C_MAX_DEFAULT bytes are still available to read.
+        auto fullPacketButMoreAvailable = [](uint16_t, uint8_t *buf,
+        uint16_t size, uint32_t *available) -> const char* {
+            *available = NOTE_I2C_MAX_DEFAULT;
+            memset(buf, 'a', size - 1);
+            buf[size - 1] = '\n';
+
+            return NULL;
+        };
+        // On the final call, NOTE_I2C_MAX_DEFAULT a's are written to the
+        // output buffer, and we report back that 0 bytes are available to read.
+        auto excessData = [](uint16_t, uint8_t *buf, uint16_t size,
+        uint32_t *available) -> const char* {
+            memset(buf, 'a', size);
+            *available -= size;
+
+            return NULL;
+        };
+        const char *(*recvFakeSequence[])(uint16_t, uint8_t *, uint16_t,
+                                          uint32_t *) = {
+            bytesAvailable,
+            fullPacketButMoreAvailable,
+            excessData
+        };
+        SET_CUSTOM_FAKE_SEQ(noteI2CReceive, recvFakeSequence, 3);
+
+        WHEN("i2cChunkedReceive is called") {
+            const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The output size is exactly the number of bytes returned by "
+                 "noteI2CReceive") {
+                CHECK(size == numBytesExpected);
+            }
+
+            THEN("available is 0") {
+                CHECK(available == 0);
+            }
+
+            THEN("The output buffer contains exactly the bytes returned by "
+                 "noteI2CReceive") {
+                uint8_t expectedBuf[NOTE_I2C_MAX_DEFAULT * 2];
+                memset(expectedBuf, 'a', NOTE_I2C_MAX_DEFAULT - 1);
+                expectedBuf[NOTE_I2C_MAX_DEFAULT - 1] = '\n';
+                memset(expectedBuf + NOTE_I2C_MAX_DEFAULT, 'a',
+                       NOTE_I2C_MAX_DEFAULT);
+
+                CHECK(memcmp(buf, expectedBuf, sizeof(expectedBuf)) == 0);
+            }
+        }
+    }
+
+    GIVEN("There's nothing to read from the Notecard") {
+        noteI2CReceive_fake.custom_fake = [](uint16_t, uint8_t *buf,
+        uint16_t size, uint32_t *available) -> const char* {
+            *available = 0;
+
+            return NULL;
+        };
+        uint8_t buf[NOTE_I2C_MAX_DEFAULT] = {0};
+        uint32_t size = sizeof(buf);
+
+        WHEN("i2cChunkedReceive is called") {
+            const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                &available);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+
+                AND_THEN("That error contains the substring {io}") {
+                    CHECK(strstr(err, "{io}") != NULL);
+                }
+            }
+
+            THEN("Size is 0") {
+                CHECK(size == 0);
+            }
+
+            THEN("Available is 0") {
+                CHECK(available == 0);
+            }
+        }
+
+        AND_GIVEN("The delay parameter is false") {
+            WHEN("i2cChunkedReceive is called") {
+                i2cChunkedReceive(buf, &size, false, timeoutMs, &available);
+
+                THEN("NoteDelayMs is never called") {
+                    CHECK(NoteDelayMs_fake.call_count == 0);
+                }
+            }
+        }
+
+        AND_GIVEN("The delay parameter is true") {
+            WHEN("i2cChunkedReceive is called") {
+                i2cChunkedReceive(buf, &size, true, timeoutMs, &available);
+
+                THEN("NoteDelayMs is called") {
+                    CHECK(NoteDelayMs_fake.call_count > 0);
+                }
+            }
+        }
+    }
+
+    GIVEN("There's initially data to read from the Notecard, but then there's "
+          "nothing available and we never receive the \\n") {
+        // First, noteI2CReceive will report that NOTE_I2C_MAX_DEFAULT bytes are
+        // available to read.
+        auto bytesAvailable = [](uint16_t, uint8_t *buf, uint16_t size,
+        uint32_t *available) -> const char* {
+            *available = NOTE_I2C_MAX_DEFAULT;
+
+            return NULL;
+        };
+        // On the next call, those bytes will be written (without a trailing
+        // newline), and available will be set to 0 to indicate there's nothing
+        // left to read.
+        auto partialPacket = [](uint16_t, uint8_t *buf, uint16_t size,
+        uint32_t *available) -> const char* {
+            memset(buf, 'a', size);
+            *available = 0;
+
+            return NULL;
+        };
+        // Finally, any subsequent calls will just set available to 0 and do
+        // nothing else. This will eventually lead to a timeout in
+        // i2cChunkedReceive because it's still waiting for the newline.
+        auto nothingAvailable = [](uint16_t, uint8_t *buf, uint16_t size,
+        uint32_t *available) -> const char* {
+            *available = 0;
+
+            return NULL;
+        };
+        const char *(*recvFakeSequence[])(uint16_t, uint8_t *, uint16_t,
+                                          uint32_t *) = {
+            bytesAvailable,
+            partialPacket,
+            nothingAvailable
+        };
+        SET_CUSTOM_FAKE_SEQ(noteI2CReceive, recvFakeSequence, 3);
+
+        uint8_t buf[NOTE_I2C_MAX_DEFAULT] = {0};
+        uint32_t size = sizeof(buf);
+
+        WHEN("i2cChunkedReceive is called") {
+            const char *err = i2cChunkedReceive(buf, &size, true, timeoutMs,
+                                                &available);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+
+                AND_THEN("That error contains the substring {io}") {
+                    CHECK(strstr(err, "{io}") != NULL);
+                }
+            }
+
+            THEN("Size is the size of the incomplete packet") {
+                CHECK(size == NOTE_I2C_MAX_DEFAULT);
+            }
+
+            THEN("Available is 0") {
+                CHECK(available == 0);
+            }
+        }
+    }
+
+    RESET_FAKE(noteI2CReceive);
+    RESET_FAKE(NoteGetMs);
+    RESET_FAKE(NoteDelayMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/i2cChunkedTransmit_test.cpp b/src/note-c/test/src/i2cChunkedTransmit_test.cpp
new file mode 100644
index 0000000..e349b8d
--- /dev/null
+++ b/src/note-c/test/src/i2cChunkedTransmit_test.cpp
@@ -0,0 +1,145 @@
+/*!
+ * @file i2cChunkedTransmit_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(const char *, noteI2CTransmit, uint16_t, uint8_t *, uint16_t)
+FAKE_VALUE_FUNC(bool, noteI2CReset, uint16_t)
+FAKE_VOID_FUNC(NoteDelayMs, uint32_t)
+
+namespace
+{
+
+uint8_t transmitBuf[CARD_REQUEST_I2C_SEGMENT_MAX_LEN * 2];
+size_t transmitBufIdx = 0;
+
+const char *noteI2CTransmitCapture(uint16_t, uint8_t *buf, uint16_t size)
+{
+    memcpy(transmitBuf + transmitBufIdx, buf, size);
+
+    return NULL;
+}
+
+SCENARIO("i2cChunkedTransmit")
+{
+    bool delay = true;
+    transmitBufIdx = 0;
+
+    GIVEN("0 is specified for the input buffer length") {
+        uint8_t buf[] = {0xAB};
+        size_t size = 0;
+
+        WHEN("i2cChunkedTransmit is called") {
+            const char *err = i2cChunkedTransmit(buf, size, delay);
+
+            THEN("Nothing is transmitted") {
+                CHECK(noteI2CTransmit_fake.call_count == 0);
+            }
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+        }
+    }
+
+    GIVEN("noteI2CTransmit returns an error") {
+        uint8_t buf[] = {0xAB};
+        size_t size = sizeof(buf);
+        noteI2CTransmit_fake.return_val = "some error";
+
+        WHEN("i2cChunkedTransmit is called") {
+            const char *err = i2cChunkedTransmit(buf, size, delay);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+
+            THEN("noteI2CReset is called") {
+                CHECK(noteI2CReset_fake.call_count > 0);
+            }
+        }
+    }
+
+    GIVEN("A valid, non-zero length buffer to transmit") {
+        uint8_t *buf = NULL;
+        size_t size = 0;
+        const char *err = NULL;
+        noteI2CTransmit_fake.custom_fake = noteI2CTransmitCapture;
+
+        AND_GIVEN("The input buffer can be sent in one chunk") {
+            uint8_t oneChunkBuf[NOTE_I2C_MAX_DEFAULT];
+            buf = oneChunkBuf;
+            size = sizeof(oneChunkBuf);
+            memset(oneChunkBuf, 1, size);
+
+            WHEN("i2cChunkedTransmit is called") {
+                err = i2cChunkedTransmit(buf, size, delay);
+
+                THEN("The data is sent in 1 call to noteI2CTransmit") {
+                    CHECK(noteI2CTransmit_fake.call_count == 1);
+                }
+            }
+        }
+
+        AND_GIVEN("The input buffer doesn't fit into a single chunk") {
+            uint8_t multiChunkBuf[NOTE_I2C_MAX_DEFAULT * 2];
+            buf = multiChunkBuf;
+            size = sizeof(multiChunkBuf);
+            memset(multiChunkBuf, 2, size);
+
+            WHEN("i2cChunkedTransmit is called") {
+                err = i2cChunkedTransmit(buf, size, delay);
+
+                THEN("The data is sent in > 1 call to noteI2CTransmit") {
+                    CHECK(noteI2CTransmit_fake.call_count > 1);
+                }
+            }
+        }
+
+        AND_GIVEN("The input buffer is larger than the maximum I2C segment "
+                  "length") {
+            uint8_t greaterThanSegmentBuf[CARD_REQUEST_I2C_SEGMENT_MAX_LEN + 1];
+            buf = greaterThanSegmentBuf;
+            size = sizeof(greaterThanSegmentBuf);
+            memset(greaterThanSegmentBuf, 3, size);
+
+            WHEN("i2cChunkedTransmit is called") {
+                err = i2cChunkedTransmit(buf, size, delay);
+            }
+        }
+
+        THEN("No error is returned") {
+            CHECK(err == NULL);
+        }
+
+        THEN("The data passed to noteI2CTransmit is exactly the same as "
+             "what was passed to i2cChunkedTransmit") {
+            memcmp(buf, transmitBuf, sizeof(buf) == 0);
+        }
+    }
+
+    RESET_FAKE(noteI2CTransmit);
+    RESET_FAKE(noteI2CReset);
+    RESET_FAKE(NoteDelayMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/i2cNoteQueryLength_test.cpp b/src/note-c/test/src/i2cNoteQueryLength_test.cpp
new file mode 100644
index 0000000..1384bdd
--- /dev/null
+++ b/src/note-c/test/src/i2cNoteQueryLength_test.cpp
@@ -0,0 +1,152 @@
+/*!
+ * @file i2cNoteQueryLength_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+#include "time_mocks.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(const char *, noteI2CReceive, uint16_t, uint8_t *, uint16_t,
+                uint32_t *)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+
+namespace
+{
+
+// Something's immediately available.
+// Nothing available at the start, then something becomes available.
+
+const char * noteI2CReceiveNotAvailable(uint16_t, uint8_t *, uint16_t,
+                                        uint32_t *available)
+{
+    *available = 0;
+
+    return NULL;
+}
+
+enum {
+    NUM_BYTES_AVAILABLE = 3
+};
+
+const char * noteI2CReceiveAvailable(uint16_t, uint8_t *, uint16_t,
+                                     uint32_t *available)
+{
+    *available = NUM_BYTES_AVAILABLE;
+
+    return NULL;
+}
+
+SCENARIO("i2cNoteQueryLength")
+{
+    NoteGetMs_fake.custom_fake = NoteGetMsIncrement;
+    uint32_t available = 0;
+    uint32_t timeoutMs = 5000;
+
+    GIVEN("noteI2CReceive returns an error") {
+        noteI2CReceive_fake.return_val = "some error";
+
+        WHEN("i2cNoteQueryLength is called") {
+            const char *err = i2cNoteQueryLength(&available, timeoutMs);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("Bytes are never available to read") {
+        noteI2CReceive_fake.custom_fake = noteI2CReceiveNotAvailable;
+
+        WHEN("i2cNoteQueryLength is called") {
+            const char *err = i2cNoteQueryLength(&available, timeoutMs);
+
+            THEN("An error is returned") {
+                REQUIRE(err != NULL);
+
+                AND_THEN("That error contains the substring {io}") {
+                    CHECK(strstr(err, "{io}") != NULL);
+                }
+            }
+        }
+    }
+
+    GIVEN("Bytes are immediately available to read") {
+        noteI2CReceive_fake.custom_fake = noteI2CReceiveAvailable;
+
+        WHEN("i2cNoteQueryLength is called") {
+            const char *err = i2cNoteQueryLength(&available, timeoutMs);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The available out parameter reports the same number of "
+                 "available bytes as noteI2CReceive reported") {
+                CHECK(available == NUM_BYTES_AVAILABLE);
+            }
+        }
+    }
+
+    GIVEN("Bytes are immediately available to read") {
+        noteI2CReceive_fake.custom_fake = noteI2CReceiveAvailable;
+
+        WHEN("i2cNoteQueryLength is called") {
+            const char *err = i2cNoteQueryLength(&available, timeoutMs);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The available out parameter reports the same number of "
+                 "available bytes as noteI2CReceive reported") {
+                CHECK(available == NUM_BYTES_AVAILABLE);
+            }
+        }
+    }
+
+    GIVEN("Bytes aren't available to read at first, but then become "
+          "available") {
+        const char * (*customI2CReciveFakes[])
+        (uint16_t, uint8_t *, uint16_t, uint32_t *available) = {
+            noteI2CReceiveNotAvailable,
+            noteI2CReceiveNotAvailable,
+            noteI2CReceiveAvailable
+        };
+        SET_CUSTOM_FAKE_SEQ(noteI2CReceive, customI2CReciveFakes, 3);
+
+        WHEN("i2cNoteQueryLength is called") {
+            const char *err = i2cNoteQueryLength(&available, timeoutMs);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The available out parameter reports the same number of "
+                 "available bytes as noteI2CReceive reported") {
+                CHECK(available == NUM_BYTES_AVAILABLE);
+            }
+        }
+    }
+
+    RESET_FAKE(noteI2CReceive);
+    RESET_FAKE(NoteGetMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/i2cNoteReset_test.cpp b/src/note-c/test/src/i2cNoteReset_test.cpp
new file mode 100644
index 0000000..3da3b65
--- /dev/null
+++ b/src/note-c/test/src/i2cNoteReset_test.cpp
@@ -0,0 +1,509 @@
+/*!
+ * @file i2cNoteReset_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VOID_FUNC(delayIO)
+FAKE_VOID_FUNC(NoteDelayMs, uint32_t)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+FAKE_VALUE_FUNC(bool, noteI2CReset, uint16_t)
+FAKE_VALUE_FUNC(const char *, noteI2CTransmit, uint16_t, uint8_t *, uint16_t)
+FAKE_VALUE_FUNC(const char *, noteI2CReceive, uint16_t, uint8_t *, uint16_t,
+                uint32_t *)
+FAKE_VOID_FUNC(NoteLockI2C)
+FAKE_VOID_FUNC(NoteUnlockI2C)
+
+namespace
+{
+
+static uint32_t rtc_ms = 0;
+
+void NoteDelayMs_mock(uint32_t delayMs)
+{
+    rtc_ms += delayMs;
+}
+
+uint32_t NoteGetMs_mock(void)
+{
+    return rtc_ms++;
+}
+
+const char * noteI2CReceive_CleanResetSeq0(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 2;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_CleanResetSeq1(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 0;
+    }
+    if (buffer) {
+        buffer[0] = '\r';
+        buffer[1] = '\n';
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_AvailGTBufferMessageSeq0(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = (ALLOC_CHUNK + 1);
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_AvailGTBufferMessageSeq1(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 0;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_AvailGTFFFFMessageSeq0(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 19790917;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_AvailGTFFFFMessageSeq1(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 0;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_AvailGTMaxMessageSeq0(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = NoteI2CMax();
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_AvailGTMaxMessageSeq1(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 0;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_ClearMessageSeq0(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 4;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_ClearMessageSeq1(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 0;
+    }
+    if (buffer) {
+        buffer[0] = '{';
+        buffer[1] = '}';
+        buffer[2] = '\r';
+        buffer[3] = '\n';
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_ClearMessageSeq2(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 2;
+    }
+    return nullptr;
+}
+
+const char * noteI2CReceive_ClearMessageSeq3(uint16_t, uint8_t *buffer, uint16_t, uint32_t *available)
+{
+    if (available) {
+        *available = 0;
+    }
+    if (buffer) {
+        buffer[0] = '\r';
+        buffer[1] = '\n';
+    }
+    return nullptr;
+}
+
+SCENARIO("i2cNoteReset")
+{
+    //TODO: Refactor GIVEN/WHEN/THEN block grouping and names
+    WHEN("Invoked") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+        i2cNoteReset();
+
+        THEN("Delay for `CARD_REQUEST_I2C_SEGMENT_DELAY_MS`") {
+            CHECK(NoteDelayMs_fake.call_count > 0);
+            CHECK(NoteDelayMs_fake.arg0_history[0] == CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+        }
+
+        THEN("The I2C mutex will be taken") {
+            CHECK(NoteLockI2C_fake.call_count > 0);
+        }
+
+        THEN("`noteI2CReset()` is called") {
+            CHECK(noteI2CReset_fake.call_count > 0);
+        }
+        AND_THEN("The first parameter is the Notecard address") {
+            CHECK(noteI2CReset_fake.arg0_history[0] == NoteI2CAddress());
+        }
+    }
+
+    GIVEN("`noteI2CReset()` is called") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+
+        WHEN("`noteI2CReset()` fails") {
+            noteI2CReset_fake.return_val = false;
+            const bool success = i2cNoteReset();
+
+            THEN("The I2C mutex will be released") {
+                CHECK(NoteUnlockI2C_fake.call_count == NoteLockI2C_fake.call_count);
+            }
+            AND_THEN("`i2cNoteReset()` fails") {
+                CHECK(success == false);
+            }
+
+            THEN("Exit immediately without retrying") {
+                CHECK(noteI2CReset_fake.call_count == 1);
+            }
+        }
+
+        WHEN("`noteI2CReset()` succeeds") {
+            noteI2CReset_fake.return_val = true;
+            i2cNoteReset();
+
+            THEN("Then the I/O delay is respected") {
+                CHECK(delayIO_fake.call_count > 0);
+            }
+        }
+    }
+
+    GIVEN("`noteI2CReset()` succeeds") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+        noteI2CReset_fake.return_val = true;
+        const bool success = i2cNoteReset();
+
+        THEN("`noteI2CTransmit()` is called") {
+            CHECK(noteI2CTransmit_fake.call_count > 0);
+        }
+        THEN("The first parameter is the Notecard address") {
+            CHECK(noteI2CTransmit_fake.arg0_history[0] == NoteI2CAddress());
+        }
+        THEN("The second parameter is a string containing a single newline") {
+            CHECK(noteI2CTransmit_fake.arg1_history[0][0] == '\n');
+        }
+        THEN("The third parameter is the string length of 1") {
+            CHECK(noteI2CTransmit_fake.arg2_history[0] == sizeof(char));
+        }
+    }
+
+    GIVEN("`noteI2CTransmit()` is called") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+        noteI2CReset_fake.return_val = true;
+
+        WHEN("`noteI2CTransmit()` fails") {
+            noteI2CTransmit_fake.return_val = "most likely a NACK has occurred";
+            const bool success = i2cNoteReset();
+
+            THEN("Delay for `CARD_REQUEST_I2C_NACK_WAIT_MS` milliseconds") {
+                CHECK(NoteDelayMs_fake.call_count > 1);
+                CHECK(NoteDelayMs_fake.arg0_history[1] == CARD_REQUEST_I2C_NACK_WAIT_MS);
+            }
+
+            THEN("`noteI2CReceive()` is not called") {
+                CHECK(noteI2CReceive_fake.call_count == 0);
+            }
+
+            THEN("`noteI2CTransmit()` will retry `CARD_RESET_SYNC_RETRIES` times") {
+                CHECK(noteI2CTransmit_fake.call_count == CARD_RESET_SYNC_RETRIES);
+            }
+
+            THEN("The I2C mutex will be released") {
+                CHECK(NoteUnlockI2C_fake.call_count == NoteLockI2C_fake.call_count);
+            }
+            AND_THEN("`i2cNoteReset()` fails") {
+                CHECK(success == false);
+            }
+        }
+
+        WHEN("`noteI2CTransmit()` succeeds") {
+            noteI2CTransmit_fake.return_val = nullptr;
+            const bool success = i2cNoteReset();
+
+            THEN("Delay for `CARD_REQUEST_I2C_SEGMENT_DELAY_MS`") {
+                CHECK(NoteDelayMs_fake.call_count > 1);
+                CHECK(NoteDelayMs_fake.arg0_history[1] == CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+            }
+
+            THEN("`noteI2CReceive()` is called to query the response") {
+                CHECK(noteI2CReceive_fake.call_count > 0);
+            }
+            AND_THEN("The first parameter is the Notecard address") {
+                CHECK(noteI2CReceive_fake.arg0_history[0] == NoteI2CAddress());
+            }
+            AND_THEN("The second parameter is a non-NULL static buffer used to drain bytes") {
+                CHECK(noteI2CReceive_fake.arg1_history[0] != nullptr);
+            }
+            AND_THEN("The third parameter is zero to indicate a query request") {
+                CHECK(noteI2CReceive_fake.arg2_history[0] == 0);
+            }
+            AND_THEN("The fourth parameter is a non-NULL unsigned integer pointer used for the query response") {
+                CHECK(noteI2CReceive_fake.arg3_history[0] != nullptr);
+            }
+        }
+    }
+
+    GIVEN("`noteI2CReceive()` is called") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+        noteI2CReset_fake.return_val = true;
+        noteI2CTransmit_fake.return_val = nullptr;
+
+        WHEN("`noteI2CReceive()` fails") {
+            noteI2CReceive_fake.return_val = "the Notecard ESP commonly generates protocol errors";
+            const bool success = i2cNoteReset();
+
+            THEN("Delay for `CARD_REQUEST_I2C_SEGMENT_DELAY_MS`") {
+                CHECK(NoteDelayMs_fake.call_count > 2);
+                CHECK(NoteDelayMs_fake.arg0_history[2] == CARD_REQUEST_I2C_SEGMENT_DELAY_MS);
+            }
+            AND_THEN("Will retry `noteI2CReceive()`") {
+                CHECK(noteI2CReceive_fake.call_count > CARD_RESET_SYNC_RETRIES);
+            }
+
+            THEN("The I2C mutex will be released") {
+                CHECK(NoteUnlockI2C_fake.call_count == NoteLockI2C_fake.call_count);
+            }
+            AND_THEN("`i2cNoteReset()` fails") {
+                CHECK(success == false);
+            }
+        }
+        WHEN("`noteI2CReceive()` succeeds") {
+            const char * (*ClearMessageSeq[])(uint16_t, uint8_t *, uint16_t, uint32_t *) = {
+                noteI2CReceive_ClearMessageSeq0,
+                noteI2CReceive_ClearMessageSeq1,
+                noteI2CReceive_ClearMessageSeq2,
+                noteI2CReceive_ClearMessageSeq3,
+            };
+            SET_CUSTOM_FAKE_SEQ(noteI2CReceive, ClearMessageSeq, 4);
+            const bool success = i2cNoteReset();
+
+            THEN("Delay for `CARD_REQUEST_I2C_CHUNK_DELAY_MS`") {
+                CHECK(NoteDelayMs_fake.call_count > 2);
+                CHECK(NoteDelayMs_fake.arg0_history[2] == CARD_REQUEST_I2C_CHUNK_DELAY_MS);
+            }
+
+            THEN("`noteI2CReceive()` is called to receive the response") {
+                CHECK(noteI2CReceive_fake.call_count > 1);
+            }
+            AND_THEN("The first parameter is the Notecard address") {
+                CHECK(noteI2CReceive_fake.arg0_val == NoteI2CAddress());
+            }
+            AND_THEN("The second parameter is a non-NULL static buffer used to drain bytes") {
+                CHECK(noteI2CReceive_fake.arg1_val != nullptr);
+            }
+            AND_THEN("The third parameter is populated with the available value from the previous query") {
+                REQUIRE(noteI2CReceive_fake.call_count >= 4);
+                CHECK(noteI2CReceive_fake.arg2_history[0] == 0);
+                CHECK(noteI2CReceive_fake.arg2_history[1] == 4);
+                CHECK(noteI2CReceive_fake.arg2_history[2] == 0);
+                CHECK(noteI2CReceive_fake.arg2_history[3] == 2);
+            }
+            AND_THEN("The fourth parameter is a non-NULL unsigned integer pointer used for the query response") {
+                CHECK(noteI2CReceive_fake.arg3_val != nullptr);
+            }
+        }
+    }
+
+    GIVEN("`noteI2CReceive()` succeeds") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+        noteI2CReset_fake.return_val = true;
+        noteI2CTransmit_fake.return_val = nullptr;
+
+        WHEN("`noteI2CReceive()` available returns a value greater than that which can be contained by uint16_t") {
+            const char * (*AvailGTFFFFMessageSeq[])(uint16_t, uint8_t *, uint16_t, uint32_t *) = {
+                noteI2CReceive_AvailGTFFFFMessageSeq0,
+                noteI2CReceive_AvailGTFFFFMessageSeq1,
+            };
+            SET_CUSTOM_FAKE_SEQ(noteI2CReceive, AvailGTFFFFMessageSeq, 2);
+            const bool success = i2cNoteReset();
+
+            THEN("The third parameter is populated with the available value from the previous query") {
+                REQUIRE(noteI2CReceive_fake.call_count >= 2);
+                CHECK(noteI2CReceive_fake.arg2_history[0] == 0);
+                CHECK(noteI2CReceive_fake.arg2_history[1] == NoteI2CMax());
+            }
+        }
+
+        WHEN("`noteI2CReceive()` available returns a value greater than the buffer size") {
+            const char * (*AvailGTBufferMessageSeq[])(uint16_t, uint8_t *, uint16_t, uint32_t *) = {
+                noteI2CReceive_AvailGTBufferMessageSeq0,
+                noteI2CReceive_AvailGTBufferMessageSeq1,
+            };
+            SET_CUSTOM_FAKE_SEQ(noteI2CReceive, AvailGTBufferMessageSeq, 2);
+            const bool success = i2cNoteReset();
+
+            THEN("The third parameter is populated with a value capped at the buffer size") {
+                REQUIRE(noteI2CReceive_fake.call_count >= 2);
+                CHECK(noteI2CReceive_fake.arg2_val <= ALLOC_CHUNK);
+            }
+        }
+
+        WHEN("`noteI2CReceive()` available returns a value greater than the maximum size allowed by the Serial-over-I2C protocol") {
+            const char * (*AvailGTMaxMessageSeq[])(uint16_t, uint8_t *, uint16_t, uint32_t *) = {
+                noteI2CReceive_AvailGTMaxMessageSeq0,
+                noteI2CReceive_AvailGTMaxMessageSeq1,
+            };
+            SET_CUSTOM_FAKE_SEQ(noteI2CReceive, AvailGTMaxMessageSeq, 2);
+            const bool success = i2cNoteReset();
+
+            THEN("The third parameter is populated with a value capped at NoteI2CMax()") {
+                REQUIRE(noteI2CReceive_fake.call_count >= 2);
+                CHECK(noteI2CReceive_fake.arg2_val <= NoteI2CMax());
+            }
+        }
+    }
+
+    GIVEN("`noteI2CReceive()` will drain the Notecard I2C interface for `CARD_RESET_DRAIN_MS`") {
+        NoteDelayMs_fake.custom_fake = NoteDelayMs_mock;
+        NoteGetMs_fake.custom_fake = NoteGetMs_mock;
+        noteI2CReset_fake.return_val = true;
+        noteI2CTransmit_fake.return_val = nullptr;
+
+        WHEN("`noteI2CReceive()` does not fail") {
+            rtc_ms = 0;
+            noteI2CReceive_fake.return_val = nullptr;
+            const bool success = i2cNoteReset();
+
+            THEN("`noteI2CReceive()` will be called for `CARD_RESET_DRAIN_MS`") {
+                // Must account for both the priming delay and the post transmit delay
+                CHECK(rtc_ms >= CARD_RESET_DRAIN_MS + (CARD_REQUEST_I2C_SEGMENT_DELAY_MS * 2));
+            }
+        }
+
+        WHEN("`noteI2CReceive()` receives any char that is neither \\r nor \\n") {
+            const char * (*ClearMessageSeq[])(uint16_t, uint8_t *, uint16_t, uint32_t *) = {
+                noteI2CReceive_ClearMessageSeq0,
+                noteI2CReceive_ClearMessageSeq1,
+                noteI2CReceive_ClearMessageSeq2,
+                noteI2CReceive_ClearMessageSeq3,
+            };
+            SET_CUSTOM_FAKE_SEQ(noteI2CReceive, ClearMessageSeq, 4);
+            const bool success = i2cNoteReset();
+
+            THEN("`i2cNoteReset` fails") {
+                CHECK(success == false);
+            }
+        }
+
+        WHEN("`noteI2CReceive()` receives nothing") {
+            noteI2CReceive_fake.return_val = nullptr;
+            const bool success = i2cNoteReset();
+
+            THEN("`i2cNoteReset` fails") {
+                CHECK(success == false);
+            }
+            THEN("`noteI2CReset()` is called") {
+                CHECK(noteI2CReset_fake.call_count > 1);
+            }
+        }
+
+        AND_GIVEN("`noteI2CReceive()` receives nothing") {
+            noteI2CReceive_fake.return_val = nullptr;
+
+            WHEN("`noteI2CReset()` fails") {
+                bool retSeq[] = { true, false };
+                SET_RETURN_SEQ(noteI2CReset, retSeq, 2);
+                const bool success = i2cNoteReset();
+                THEN("The I2C mutex will be released") {
+                    CHECK(NoteUnlockI2C_fake.call_count == NoteLockI2C_fake.call_count);
+                }
+                THEN("Exit immediately without retrying") {
+                    CHECK(noteI2CReset_fake.call_count == 2);
+                }
+            }
+
+            WHEN("`noteI2CReset()` succeeds") {
+                i2cNoteReset();
+
+                THEN("Then the I/O delay is respected") {
+                    // 1 + pre loop
+                    // 10 retries (simple noteI2CReceive_fake returns zero --> nothing was found 10x)
+                    CHECK(delayIO_fake.call_count > 10);
+                }
+            }
+        }
+
+        WHEN("`noteI2CReceive()` receives only `\\r` and/or `\\n`") {
+            const char * (*CleanResetSeq[])(uint16_t, uint8_t *, uint16_t, uint32_t *) = {
+                noteI2CReceive_CleanResetSeq0,
+                noteI2CReceive_CleanResetSeq1,
+            };
+            SET_CUSTOM_FAKE_SEQ(noteI2CReceive, CleanResetSeq, 2);
+            const bool success = i2cNoteReset();
+
+            THEN("Exit retry loop immediately") {
+                CHECK(noteI2CTransmit_fake.call_count == 1);
+            }
+
+            THEN("`i2cNoteReset` succeeds") {
+                CHECK(success);
+            }
+            AND_THEN("The I2C mutex will be released") {
+                CHECK(NoteUnlockI2C_fake.call_count == NoteLockI2C_fake.call_count);
+            }
+        }
+    }
+
+    // Sanity check against stray return paths
+    CHECK(NoteLockI2C_fake.call_count == 1);
+    CHECK(NoteUnlockI2C_fake.call_count == 1);
+
+    RESET_FAKE(delayIO);
+    RESET_FAKE(NoteDelayMs);
+    RESET_FAKE(NoteGetMs);
+    RESET_FAKE(noteI2CReset);
+    RESET_FAKE(noteI2CTransmit);
+    RESET_FAKE(noteI2CReceive);
+    RESET_FAKE(NoteLockI2C);
+    RESET_FAKE(NoteUnlockI2C);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/i2cNoteTransaction_test.cpp b/src/note-c/test/src/i2cNoteTransaction_test.cpp
new file mode 100644
index 0000000..b86b8ba
--- /dev/null
+++ b/src/note-c/test/src/i2cNoteTransaction_test.cpp
@@ -0,0 +1,263 @@
+/*!
+ * @file i2cNoteTransaction_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+#include "test_static.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+FAKE_VOID_FUNC(NoteLockI2C)
+FAKE_VOID_FUNC(NoteUnlockI2C)
+FAKE_VALUE_FUNC(const char *, i2cChunkedTransmit, uint8_t *, uint32_t, bool)
+FAKE_VALUE_FUNC(const char *, i2cNoteQueryLength, uint32_t *, uint32_t)
+FAKE_VALUE_FUNC(const char *, i2cChunkedReceive, uint8_t *, uint32_t *, bool,
+                uint32_t, uint32_t *)
+
+namespace
+{
+
+SCENARIO("i2cNoteTransaction")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+
+    char req[] = "{\"req\": \"note.add\"}\n";
+    char originalReq[sizeof(req)];
+    strlcpy(originalReq, req, sizeof(req));
+    char *rsp = NULL;
+    const char *err = NULL;
+    NoteMalloc_fake.custom_fake = malloc;
+    uint32_t timeoutMs = CARD_INTER_TRANSACTION_TIMEOUT_SEC;
+
+    GIVEN("i2cChunkedTransmit returns an error") {
+        i2cChunkedTransmit_fake.return_val = "some error";
+
+        WHEN("i2cNoteTransaction is called") {
+            err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+            THEN("An error is returned") {
+                REQUIRE(i2cChunkedTransmit_fake.call_count > 0);
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("The response parameter is NULL so no Notecard response is "
+          "expected") {
+        WHEN("i2cNoteTransaction is called") {
+            err = i2cNoteTransaction(req, strlen(req), NULL, timeoutMs);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+        }
+    }
+
+    GIVEN("i2cNoteQueryLength returns an error") {
+        i2cNoteQueryLength_fake.return_val = "some error";
+
+        WHEN("i2cNoteTransaction is called") {
+            err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+            THEN("An error is returned") {
+                REQUIRE(i2cNoteQueryLength_fake.call_count > 0);
+                CHECK(err != NULL);
+            }
+        }
+    }
+
+    GIVEN("i2cNoteQueryLength reports bytes are available to read from the"
+          " Notecard") {
+        i2cNoteQueryLength_fake.custom_fake = [](uint32_t * available,
+        uint32_t) -> const char* {
+            *available = ALLOC_CHUNK;
+
+            return NULL;
+        };
+
+        AND_GIVEN("Allocating a buffer for the Notecard response fails") {
+            NoteMalloc_fake.custom_fake = NULL;
+            NoteMalloc_fake.return_val = NULL;
+
+            WHEN("i2cNoteTransaction is called") {
+                err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("An error is returned") {
+                    REQUIRE(NoteMalloc_fake.call_count > 0);
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("i2cChunkedReceive returns an error") {
+            i2cChunkedReceive_fake.return_val = "some error";
+
+            WHEN("i2cNoteTransaction is called") {
+                err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("An error is returned") {
+                    REQUIRE(i2cChunkedReceive_fake.call_count > 0);
+                    CHECK(err != NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("A single chunk is required to read the full response from "
+                  "the Notecard") {
+            // Write out the number of bytes reported available on the prior
+            // call to i2cNoteQueryLength and report no more bytes available.
+            i2cChunkedReceive_fake.custom_fake = [](uint8_t *buf, uint32_t *size, bool, uint32_t,
+            uint32_t *available) -> const char* {
+                memset(buf, 'a', *available - 1);
+                buf[*available - 1] = '\n';
+                *size = *available;
+                *available = 0;
+
+                return NULL;
+            };
+
+            WHEN("i2cNoteTransaction is called") {
+                err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                // If i2cChunkedReceive is called more than once, the response
+                // took more than one chunk, and this test is no longer testing
+                // what it intends to.
+                REQUIRE(i2cChunkedReceive_fake.call_count == 1);
+
+                THEN("No error is returned") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("The response buffer contains exactly what was returned by"
+                     " i2cChunkedReceive") {
+                    char expectedRsp[ALLOC_CHUNK + 1];
+                    size_t expectedSize = sizeof(expectedRsp);
+                    memset(expectedRsp, 'a', expectedSize - 2);
+                    expectedRsp[expectedSize - 2] = '\n';
+                    expectedRsp[expectedSize - 1] = '\0';
+
+                    CHECK(strcmp(rsp, expectedRsp) == 0);
+                }
+
+                free(rsp);
+            }
+        }
+
+        AND_GIVEN("Multiple chunks are required to read the full response from "
+                  "the Notecard") {
+            // On the first call to i2cChunkedReceive, a string of a's is
+            // written to the output buffer, and the Notecard reports that there
+            // are still ALLOC_CHUNK bytes to read.
+            auto firstChunk = [](uint8_t *buf, uint32_t *size, bool, uint32_t,
+            uint32_t *available) -> const char* {
+                memset(buf, 'a', *available);
+                *size = *available;
+                *available = ALLOC_CHUNK;
+
+                return NULL;
+            };
+            // On the second call, the remaining ALLOC_CHUNK bytes are written
+            // out, which is a string of a's terminated with a newline.
+            // available is set to 0, indicating there's nothing left to read.
+            auto secondChunk = [](uint8_t *buf, uint32_t *size, bool, uint32_t,
+            uint32_t *available) -> const char* {
+                memset(buf, 'a', *available - 1);
+                buf[*available - 1] = '\n';
+                *size = *available;
+                *available = 0;
+
+                return NULL;
+            };
+            const char *(*recvFakeSequence[])(uint8_t *, uint32_t *, bool,
+                                              uint32_t, uint32_t *) = {
+                firstChunk,
+                secondChunk
+            };
+            SET_CUSTOM_FAKE_SEQ(i2cChunkedReceive, recvFakeSequence, 2);
+
+            WHEN("i2cNoteTransaction is called") {
+                err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                // Ensure that i2cChunkedReceive was actually called more than
+                // once. If it isn't, then something has gone awry and this test
+                // is no longer testing what it intends to, or there's been a
+                // regression/bug.
+                REQUIRE(i2cChunkedReceive_fake.call_count > 1);
+
+                THEN("No error is returned") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("The response buffer contains exactly what was returned by"
+                     " i2cChunkedReceive") {
+                    char expectedRsp[ALLOC_CHUNK * 2 + 1];
+                    size_t expectedSize = sizeof(expectedRsp);
+                    memset(expectedRsp, 'a', expectedSize - 2);
+                    expectedRsp[expectedSize - 2] = '\n';
+                    expectedRsp[expectedSize - 1] = '\0';
+
+                    CHECK(strcmp(rsp, expectedRsp) == 0);
+                }
+
+                free(rsp);
+            }
+
+            AND_GIVEN("Allocating a larger response buffer fails") {
+                NoteMalloc_fake.custom_fake = NULL;
+                // The first allocation that sets up the initial response buffer
+                // is ok.
+                auto normalMalloc = [](size_t size) -> void * {
+                    return malloc(size);
+                };
+                // The second one used to grow the response buffer fails.
+                auto failMalloc = [](size_t size) -> void * {
+                    return NULL;
+                };
+                void *(*mallocFakeSequence[])(size_t) = {
+                    normalMalloc,
+                    failMalloc
+                };
+                SET_CUSTOM_FAKE_SEQ(NoteMalloc, mallocFakeSequence, 2);
+
+                WHEN("i2cNoteTransaction is called") {
+                    err = i2cNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                    THEN("An error is returned") {
+                        CHECK(err != NULL);
+                    }
+                }
+            }
+        }
+    }
+
+    THEN("The request parameter is unchanged") {
+        CHECK(strcmp(originalReq, req) == 0);
+    }
+
+    CHECK(NoteLockI2C_fake.call_count == NoteUnlockI2C_fake.call_count);
+
+    RESET_FAKE(NoteMalloc);
+    RESET_FAKE(NoteLockI2C);
+    RESET_FAKE(NoteUnlockI2C);
+    RESET_FAKE(i2cChunkedTransmit);
+    RESET_FAKE(i2cNoteQueryLength);
+    RESET_FAKE(i2cChunkedReceive);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/serialChunkedReceive_test.cpp b/src/note-c/test/src/serialChunkedReceive_test.cpp
new file mode 100644
index 0000000..5b92b9f
--- /dev/null
+++ b/src/note-c/test/src/serialChunkedReceive_test.cpp
@@ -0,0 +1,302 @@
+/*!
+ * @file serialChunkedReceive_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+#include "time_mocks.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, noteSerialAvailable)
+FAKE_VALUE_FUNC(char, noteSerialReceive)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+FAKE_VOID_FUNC(NoteDelayMs, uint32_t)
+
+namespace
+{
+
+// Fill the serial receive buffer with size - 1 a's, then a newline.
+char *populateRecvBuf(size_t size)
+{
+    char *buf = (char *)malloc(size);
+    memset(buf, 'a', size - 1);
+    buf[size - 1] = '\n';
+    SET_RETURN_SEQ(noteSerialReceive, buf, size);
+
+    return buf;
+}
+
+SCENARIO("serialChunkedReceive")
+{
+    NoteSetFnDefault(malloc, free, NULL, NULL);
+
+    NoteGetMs_fake.custom_fake = []() -> uint32_t {
+        static uint32_t count = 0;
+
+        // increment by 1 second
+        count += 750;
+        // return count pre-increment
+        return count - 750;
+    };
+    uint8_t buf[] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00};
+    uint32_t size = sizeof(buf);
+    bool delay = false;
+    const uint32_t timeoutMs = 3000;
+    // 37 is not significant. serialChunkedReceive will return either a 1 or 0
+    // in the "available" parameter. 37 is simply "not 1 or 0" -- that means we
+    // can validate that available is changed to the correct value where
+    // appropriate.
+    uint32_t available = 37;
+
+    GIVEN("noteSerialAvailable indicates nothing is available to read") {
+        noteSerialAvailable_fake.return_val = false;
+
+        WHEN("serialChunkedReceive is called") {
+            const char *err = serialChunkedReceive(buf, &size, delay, timeoutMs,
+                                                   &available);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+
+                AND_THEN("That error contains the substring {io}") {
+                    CHECK(strstr(err, "{io}") != NULL);
+                }
+            }
+
+            THEN("The output buffer size is 0") {
+                CHECK(size == 0);
+            }
+        }
+    }
+
+    GIVEN("The Notecard has 1 fewer bytes than the size of the output buffer") {
+        noteSerialAvailable_fake.return_val = true;
+        char *recvBuf = populateRecvBuf(sizeof(buf) - 1);
+
+        WHEN("serialChunkedReceive is called") {
+            const char *err = serialChunkedReceive(buf, &size, delay, timeoutMs,
+                                                   &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The returned size is exactly the number of bytes received "
+                 "with noteSerialReceive") {
+                CHECK(size == sizeof(buf) - 1);
+            }
+
+            THEN("The output buffer has exactly the bytes returned by "
+                 "noteSerialReceive") {
+                CHECK(memcmp(buf, recvBuf, size) == 0);
+            }
+
+            THEN("The returned available bytes is zero") {
+                CHECK(available == 0);
+            }
+        }
+
+        free(recvBuf);
+    }
+
+    GIVEN("The Notecard has exactly the same number of bytes as the output "
+          "buffer") {
+        noteSerialAvailable_fake.return_val = true;
+        char *recvBuf = populateRecvBuf(sizeof(buf));
+
+        WHEN("serialChunkedReceive is called") {
+            const char *err = serialChunkedReceive(buf, &size, delay, timeoutMs,
+                                                   &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The returned size is exactly the number of bytes received "
+                 "with noteSerialReceive") {
+                CHECK(size == sizeof(buf));
+            }
+
+            THEN("The output buffer has exactly the bytes returned by "
+                 "noteSerialReceive") {
+                CHECK(memcmp(buf, recvBuf, size) == 0);
+            }
+
+            THEN("The returned available bytes is zero") {
+                CHECK(available == 0);
+            }
+        }
+
+        free(recvBuf);
+    }
+
+    GIVEN("The Notecard has 3 more bytes than the size of the output buffer") {
+        noteSerialAvailable_fake.return_val = true;
+        char *recvBuf = populateRecvBuf(sizeof(buf) + 3);
+
+        WHEN("serialChunkedReceive is called") {
+            const char *err = serialChunkedReceive(buf, &size, delay, timeoutMs,
+                                                   &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The returned size is exactly the number of bytes received "
+                 "with noteSerialReceive") {
+                CHECK(size == sizeof(buf));
+            }
+
+            THEN("The output buffer has exactly the bytes returned by "
+                 "noteSerialReceive") {
+                CHECK(memcmp(buf, recvBuf, size) == 0);
+            }
+
+            THEN("The returned \"available\" bytes is 1") {
+                CHECK(available == 1);
+            }
+        }
+
+        free(recvBuf);
+    }
+
+    GIVEN("A 0-length output buffer is provided") {
+        WHEN("serialChunkedReceive is called") {
+            uint32_t originalAvailable = available;
+            uint32_t zeroSize = 0;
+            const char *err = serialChunkedReceive(buf, &zeroSize, delay,
+                                                   timeoutMs, &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("Size is 0") {
+                CHECK(zeroSize == 0);
+            }
+
+            THEN("Available is unchanged") {
+                CHECK(available == originalAvailable);
+            }
+        }
+    }
+
+    GIVEN("No \\n indicating end of packet is received and a timeout occurs") {
+        bool serialAvailableReturnVals[4] = {0};
+        size_t numAvailableBytes = 3;
+        memset(serialAvailableReturnVals, true, numAvailableBytes);
+        size_t numAvailRetVals = sizeof(serialAvailableReturnVals) /
+                                 sizeof(*serialAvailableReturnVals);
+        SET_RETURN_SEQ(noteSerialAvailable, serialAvailableReturnVals,
+                       numAvailRetVals);
+        char *recvBuf = populateRecvBuf(sizeof(buf));
+
+        WHEN("serialChunkedReceive is called") {
+            const char *err = serialChunkedReceive(buf, &size, delay, timeoutMs,
+                                                   &available);
+
+            THEN("An error is returned") {
+                CHECK(err != NULL);
+
+                AND_THEN("That error contains the substring {io}") {
+                    CHECK(strstr(err, "{io}") != NULL);
+                }
+            }
+
+            THEN("The returned size is the size of the partial packet") {
+                CHECK(size == numAvailableBytes);
+
+                AND_THEN("The output buffer contains the bytes comprising the "
+                         "partial packet") {
+                    CHECK(memcmp(buf, recvBuf, size) == 0);
+                }
+            }
+        }
+
+        free(recvBuf);
+    }
+
+    GIVEN("Bytes are intermittently unavailable to read but the full packet "
+          "eventually comes in") {
+        bool serialAvailableReturnVals[] = {false, false, false, true, true, false, true, true};
+        size_t numAvailRetVals = sizeof(serialAvailableReturnVals) /
+                                 sizeof(*serialAvailableReturnVals);
+        size_t numAvailableBytes = 4;
+        SET_RETURN_SEQ(noteSerialAvailable, serialAvailableReturnVals,
+                       numAvailRetVals);
+        char *recvBuf = populateRecvBuf(numAvailableBytes);
+
+        WHEN("serialChunkedReceive is called") {
+            const char *err = serialChunkedReceive(buf, &size, delay, timeoutMs,
+                                                   &available);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The returned size is exactly the number of bytes received "
+                 "with noteSerialReceive") {
+                CHECK(size == numAvailableBytes);
+            }
+
+            THEN("The output buffer has exactly the bytes returned by "
+                 "noteSerialReceive") {
+                CHECK(memcmp(buf, recvBuf, size) == 0);
+            }
+
+            THEN("The returned available bytes is 0") {
+                CHECK(available == 0);
+            }
+        }
+
+        free(recvBuf);
+    }
+
+    GIVEN("The delay parameter is false") {
+        noteSerialAvailable_fake.return_val = false;
+
+        WHEN("serialChunkedReceive is called") {
+            serialChunkedReceive(buf, &size, false, timeoutMs, &available);
+
+            THEN("NoteDelayMs is never called while waiting for bytes to become"
+                 " available to read") {
+                CHECK(NoteDelayMs_fake.call_count == 0);
+            }
+        }
+    }
+
+    GIVEN("The delay parameter is true") {
+        noteSerialAvailable_fake.return_val = false;
+
+        WHEN("serialChunkedReceive is called") {
+            serialChunkedReceive(buf, &size, true, timeoutMs, &available);
+
+            THEN("NoteDelayMs is called while waiting for bytes to become"
+                 " available to read") {
+                CHECK(NoteDelayMs_fake.call_count > 0);
+            }
+        }
+    }
+
+    RESET_FAKE(noteSerialAvailable);
+    RESET_FAKE(noteSerialReceive);
+    RESET_FAKE(NoteGetMs);
+    RESET_FAKE(NoteDelayMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/serialChunkedTransmit_test.cpp b/src/note-c/test/src/serialChunkedTransmit_test.cpp
new file mode 100644
index 0000000..b0855be
--- /dev/null
+++ b/src/note-c/test/src/serialChunkedTransmit_test.cpp
@@ -0,0 +1,156 @@
+/*!
+ * @file serialChunkedTransmit_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+#include "time_mocks.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VOID_FUNC(noteSerialTransmit, uint8_t *, size_t, bool)
+FAKE_VOID_FUNC(NoteDelayMs, uint32_t)
+
+namespace
+{
+
+// This buffer will hold the bytes passed to noteSerialTransmit. We can then
+// check that the bytes passed to serialChunkedTransmit are passed to
+// noteSerialTransmit without alteration.
+uint8_t accumulatedBuf[CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN * 2];
+size_t accumulatedIdx = 0;
+
+void noteSerialTransmitAccumulate(uint8_t *buf, size_t size, bool)
+{
+    memcpy(accumulatedBuf + accumulatedIdx, buf, size);
+    accumulatedIdx += size;
+}
+
+SCENARIO("serialChunkedTransmit")
+{
+    memset(accumulatedBuf, 0, sizeof(accumulatedBuf));
+    accumulatedIdx = 0;
+
+    GIVEN("A 0-length transmit buffer") {
+        WHEN("serialChunkedTransmit is called") {
+            uint8_t buf[] = {0x01};
+            const char *err = serialChunkedTransmit(buf, 0, true);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+        }
+    }
+
+    GIVEN("A buffer with size less than the maximum serial segment length") {
+        noteSerialTransmit_fake.custom_fake = noteSerialTransmitAccumulate;
+        uint8_t buf[CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN - 1];
+        size_t size = sizeof(buf);
+        memset(buf, 1, size);
+
+        WHEN("serialChunkedTransmit is called") {
+            const char *err = serialChunkedTransmit(buf, size, true);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The buffer is passed verbatim to noteSerialTransmit") {
+                CHECK(memcmp(buf, accumulatedBuf, size) == 0);
+            }
+
+            THEN("noteSerialTransmit is only called once, since the buffer fits"
+                 " in a single segment") {
+                CHECK(noteSerialTransmit_fake.call_count == 1);
+            }
+        }
+    }
+
+    // TODO: Come up with a way to reduce duplication here.
+    GIVEN("A buffer with size equal to the maximum serial segment length") {
+        noteSerialTransmit_fake.custom_fake = noteSerialTransmitAccumulate;
+        uint8_t buf[CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN];
+        size_t size = sizeof(buf);
+        memset(buf, 1, size);
+
+        WHEN("serialChunkedTransmit is called") {
+            const char *err = serialChunkedTransmit(buf, size, true);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The buffer is passed verbatim to noteSerialTransmit") {
+                CHECK(memcmp(buf, accumulatedBuf, size) == 0);
+            }
+
+            THEN("noteSerialTransmit is only called once, since the buffer fits"
+                 " in a single segment") {
+                CHECK(noteSerialTransmit_fake.call_count == 1);
+            }
+        }
+    }
+
+    GIVEN("A buffer with size greater than the maximum serial segment length") {
+        noteSerialTransmit_fake.custom_fake = noteSerialTransmitAccumulate;
+        uint8_t buf[CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN + 10];
+        size_t size = sizeof(buf);
+        memset(buf, 1, size);
+
+        WHEN("serialChunkedTransmit is called") {
+            const char *err = serialChunkedTransmit(buf, size, true);
+
+            THEN("No error is returned") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The buffer is passed verbatim to noteSerialTransmit") {
+                CHECK(memcmp(buf, accumulatedBuf, size) == 0);
+            }
+
+            THEN("noteSerialTransmit is called more than once, since the buffer"
+                 " doesn't fit in a single segment") {
+                CHECK(noteSerialTransmit_fake.call_count > 1);
+            }
+        }
+
+        AND_GIVEN("The delay parameter is false") {
+            WHEN("serialChunkedTransmit is called") {
+                const char *err = serialChunkedTransmit(buf, size, false);
+
+                THEN("NoteDelayMs is never called") {
+                    CHECK(NoteDelayMs_fake.call_count == 0);
+                }
+            }
+        }
+
+        AND_GIVEN("The delay parameter is true") {
+            WHEN("serialChunkedTransmit is called") {
+                const char *err = serialChunkedTransmit(buf, size, true);
+
+                THEN("NoteDelayMs is called") {
+                    CHECK(NoteDelayMs_fake.call_count > 0);
+                }
+            }
+        }
+    }
+
+    RESET_FAKE(noteSerialTransmit);
+    RESET_FAKE(NoteDelayMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/serialNoteReset_test.cpp b/src/note-c/test/src/serialNoteReset_test.cpp
new file mode 100644
index 0000000..e0b8119
--- /dev/null
+++ b/src/note-c/test/src/serialNoteReset_test.cpp
@@ -0,0 +1,135 @@
+/*!
+ * @file serialNoteReset_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(bool, noteSerialReset)
+FAKE_VOID_FUNC(noteSerialTransmit, uint8_t *, size_t, bool)
+FAKE_VALUE_FUNC(bool, noteSerialAvailable)
+FAKE_VALUE_FUNC(char, noteSerialReceive)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+
+namespace
+{
+
+uint32_t NoteGetMsMock()
+{
+    static uint32_t ret = 500;
+
+    // Cycle through returning 0, 1, and 500. 500 ms is the timeout of the
+    // receive loop in serialNoteReset.
+    switch (ret) {
+    case 0:
+        ret = 1;
+        break;
+    case 1:
+        ret = 500;
+        break;
+    case 500:
+        ret = 0;
+        break;
+    }
+
+    return ret;
+}
+
+SCENARIO("serialNoteReset")
+{
+    SECTION("noteSerialReset fails") {
+        noteSerialReset_fake.return_val = false;
+
+        CHECK(!serialNoteReset());
+        CHECK(noteSerialReset_fake.call_count == 1);
+        CHECK(noteSerialTransmit_fake.call_count == 0);
+    }
+
+    SECTION("Serial never available") {
+        noteSerialReset_fake.return_val = true;
+        noteSerialAvailable_fake.return_val = false;
+        NoteGetMs_fake.custom_fake = NoteGetMsMock;
+
+        CHECK(!serialNoteReset());
+        // serialNoteReset has retry logic, so we expect retries.
+        CHECK(noteSerialTransmit_fake.call_count > 1);
+        CHECK(noteSerialReceive_fake.call_count == 0);
+    }
+
+    SECTION("Character received") {
+        NoteGetMs_fake.custom_fake = NoteGetMsMock;
+        bool serialAvailRetVals[] = {true, false};
+        SET_RETURN_SEQ(noteSerialAvailable, serialAvailRetVals, 2);
+
+        SECTION("Non-control character received") {
+            noteSerialReceive_fake.return_val = 'a';
+
+            SECTION("Retry") {
+                noteSerialReset_fake.return_val = true;
+
+                CHECK(!serialNoteReset());
+                // Expect retries.
+                CHECK(noteSerialTransmit_fake.call_count > 1);
+            }
+
+            SECTION("noteSerialReset fails before retry possible") {
+                bool noteSerialResetRetVals[] = {true, false};
+                SET_RETURN_SEQ(noteSerialReset, noteSerialResetRetVals, 2);
+
+                CHECK(!serialNoteReset());
+                // No retries.
+                CHECK(noteSerialTransmit_fake.call_count == 1);
+            }
+        }
+
+        SECTION("Only control character received") {
+            noteSerialReset_fake.return_val = true;
+            noteSerialReceive_fake.return_val = '\n';
+
+            CHECK(serialNoteReset());
+            // There should be no retrying.
+            CHECK(noteSerialTransmit_fake.call_count == 1);
+        }
+
+        CHECK(noteSerialReceive_fake.call_count > 0);
+    }
+
+    SECTION("NoteGetMs overflow") {
+        noteSerialReset_fake.return_val = true;
+        noteSerialReceive_fake.return_val = '\n';
+        bool serialAvailRetVals[] = {true, false};
+        SET_RETURN_SEQ(noteSerialAvailable, serialAvailRetVals, 2);
+        uint32_t getMsReturnVals[] = {
+            UINT32_MAX - 500,
+            UINT32_MAX - 400,
+            0
+        };
+        SET_RETURN_SEQ(NoteGetMs, getMsReturnVals, 3);
+
+        CHECK(serialNoteReset());
+    }
+
+    RESET_FAKE(noteSerialReset);
+    RESET_FAKE(noteSerialTransmit);
+    RESET_FAKE(noteSerialAvailable);
+    RESET_FAKE(noteSerialReceive);
+    RESET_FAKE(NoteGetMs);
+}
+
+}
+
+
diff --git a/src/note-c/test/src/serialNoteTransaction_test.cpp b/src/note-c/test/src/serialNoteTransaction_test.cpp
new file mode 100644
index 0000000..3a06063
--- /dev/null
+++ b/src/note-c/test/src/serialNoteTransaction_test.cpp
@@ -0,0 +1,356 @@
+/*!
+ * @file serialNoteTransaction_test.cpp
+ *
+ * Written by the Blues Inc. team.
+ *
+ * Copyright (c) 2023 Blues Inc. MIT License. Use of this source code is
+ * governed by licenses granted by the copyright holder including that found in
+ * the
+ * <a href="https://github.com/blues/note-c/blob/master/LICENSE">LICENSE</a>
+ * file.
+ *
+ */
+
+
+
+#include <catch2/catch_test_macros.hpp>
+#include "fff.h"
+
+#include "n_lib.h"
+
+DEFINE_FFF_GLOBALS
+FAKE_VALUE_FUNC(void *, NoteMalloc, size_t)
+FAKE_VALUE_FUNC(bool, noteSerialAvailable)
+FAKE_VALUE_FUNC(char, noteSerialReceive)
+FAKE_VALUE_FUNC(uint32_t, NoteGetMs)
+FAKE_VOID_FUNC(noteSerialTransmit, uint8_t *, size_t, bool)
+FAKE_VALUE_FUNC(const char *, serialChunkedTransmit, uint8_t *, uint32_t, bool);
+FAKE_VALUE_FUNC(const char *, serialChunkedReceive, uint8_t *, uint32_t *, bool, uint32_t, uint32_t *)
+
+namespace
+{
+
+char transmitBuf[CARD_REQUEST_SERIAL_SEGMENT_MAX_LEN * 2];
+size_t transmitBufLen = 0;
+bool resetTransmitBufLen = false;
+
+void noteSerialTransmitAppend(uint8_t *buf, size_t len, bool)
+{
+    if (resetTransmitBufLen) {
+        transmitBufLen = 0;
+        resetTransmitBufLen = false;
+    }
+
+    if (buf[len - 1] == '\n') {
+        resetTransmitBufLen = true;
+    }
+
+    if (transmitBufLen + len > sizeof(transmitBuf)) {
+        return;
+    }
+
+    memcpy(transmitBuf + transmitBufLen, buf, len);
+    transmitBufLen += len;
+}
+
+const char *serialChunkedTransmitAppend(uint8_t *buf, uint32_t len, bool)
+{
+    noteSerialTransmitAppend(buf, len, true);
+
+    return NULL;
+}
+
+const char *serialChunkedReceiveNothing(uint8_t *, uint32_t *size, bool,
+                                        uint32_t, uint32_t *available)
+{
+    *size = 0;
+    *available = 0;
+
+    return NULL;
+}
+
+const char *serialChunkedReceiveOneAndDone(uint8_t *buf, uint32_t *size, bool,
+        uint32_t, uint32_t *available)
+{
+    *buf = '\n';
+    *size = 1;
+    *available = 0;
+
+    return NULL;
+}
+
+#define SERIAL_CHUNKED_RECEIVE_MULTIPLE_SIZE (2 * ALLOC_CHUNK)
+
+size_t serialChunkedReceiveMultipleLeft = SERIAL_CHUNKED_RECEIVE_MULTIPLE_SIZE;
+
+const char *serialChunkedReceiveMultiple(uint8_t *buf, uint32_t *size, bool,
+        uint32_t, uint32_t *available)
+{
+    memset(buf, 1, *size);
+    serialChunkedReceiveMultipleLeft -= *size;
+    *available = serialChunkedReceiveMultipleLeft;
+
+    return NULL;
+}
+
+void *MallocNull(size_t)
+{
+    return NULL;
+}
+
+SCENARIO("serialNoteTransaction")
+{
+    NoteSetFnDefault(NULL, free, NULL, NULL);
+
+    char req[] = "{\"req\": \"note.add\"}\n";
+    const uint32_t timeoutMs = CARD_INTER_TRANSACTION_TIMEOUT_SEC;
+
+    GIVEN("A valid JSON request C-string and a NULL response pointer") {
+        noteSerialTransmit_fake.custom_fake = noteSerialTransmitAppend;
+        serialChunkedTransmit_fake.custom_fake = serialChunkedTransmitAppend;
+
+        WHEN("serialNoteTransaction is called") {
+            const char *err = serialNoteTransaction(req, strlen(req), NULL, timeoutMs);
+
+            THEN("serialNoteTransaction returns NULL (no error)") {
+                CHECK(err == NULL);
+            }
+
+            THEN("The request is given to the transmission function followed by"
+                 " \\r\\n") {
+                size_t rawReqLen = (strlen(req) - 1);
+                CHECK(!memcmp(transmitBuf, req, rawReqLen));
+                CHECK(!memcmp(transmitBuf + rawReqLen, c_newline, c_newline_len));
+            }
+
+            THEN("noteSerialReceive is not called") {
+                CHECK(noteSerialReceive_fake.call_count == 0);
+            }
+        }
+
+        AND_GIVEN("serialChunkedTransmit returns an error") {
+            serialChunkedTransmit_fake.custom_fake = NULL;
+            serialChunkedTransmit_fake.return_val = "some error";
+
+            WHEN("serialNoteTransaction is called") {
+                const char *err = serialNoteTransaction(req, strlen(req), NULL, timeoutMs);
+
+                THEN("serialNoteTransaction returns an error") {
+                    CHECK(err != NULL);
+                }
+            }
+        }
+    }
+
+    GIVEN("A valid JSON request C-string and a valid response pointer") {
+        char* rsp = NULL;
+
+        AND_GIVEN("Allocating a buffer to hold the response fails") {
+            NoteMalloc_fake.return_val = NULL;
+            noteSerialAvailable_fake.return_val = true;
+
+            WHEN("serialNoteTransaction is called") {
+                const char *err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("NoteMalloc is called") {
+                    REQUIRE(NoteMalloc_fake.call_count > 0);
+                }
+
+                THEN("serialNoteTransaction returns an error") {
+                    CHECK(err != NULL);
+                }
+
+                THEN("noteSerialReceive is not called (no bytes received from "
+                     "the Notecard)") {
+                    CHECK(noteSerialReceive_fake.call_count == 0);
+                }
+
+                THEN("The response pointer is unchanged") {
+                    CHECK(rsp == NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("noteSerialAvailable never indicates bytes are available from"
+                  " the Notecard") {
+            noteSerialAvailable_fake.return_val = false;
+            NoteMalloc_fake.custom_fake = malloc;
+            uint32_t getMsReturnVals[3];
+
+            AND_GIVEN("There's a timeout after waiting for "
+                      "CARD_INTER_TRANSACTION_TIMEOUT_SEC seconds") {
+                getMsReturnVals[0] = UINT32_MAX -
+                                     CARD_INTER_TRANSACTION_TIMEOUT_SEC * 1000;
+                getMsReturnVals[1] = UINT32_MAX -
+                                     (CARD_INTER_TRANSACTION_TIMEOUT_SEC - 1) *
+                                     1000;
+                // Force the millisecond counter, which is used to determine if
+                // we've timed out, to roll over to cover that edge case.
+                getMsReturnVals[2] = 0;
+
+                SET_RETURN_SEQ(NoteGetMs, getMsReturnVals, 3);
+
+                WHEN("serialNoteTransaction is called") {
+                    const char* err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                    THEN("noteSerialReceive is not called (no bytes received "
+                         "from the Notecard)") {
+                        CHECK(noteSerialReceive_fake.call_count == 0);
+                    }
+
+                    THEN("serialNoteTransaction returns an error") {
+                        REQUIRE(err != NULL);
+                    }
+
+                    THEN("The error message indicates there was a timeout") {
+                        CHECK(strstr(err, "timeout") != NULL);
+                    }
+
+                    THEN("The response pointer is unchanged") {
+                        CHECK(rsp == NULL);
+                    }
+                }
+            }
+        }
+
+        AND_GIVEN("serialChunkedReceive returns an error") {
+            noteSerialAvailable_fake.return_val = true;
+            NoteMalloc_fake.custom_fake = malloc;
+            serialChunkedReceive_fake.return_val = "some error";
+
+            WHEN("serialNoteTransaction is called") {
+                const char *err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("serialNoteTransaction returns an error") {
+                    CHECK(err != NULL);
+                }
+
+                THEN("The response pointer is unchanged") {
+                    CHECK(rsp == NULL);
+                }
+            }
+        }
+
+        AND_GIVEN("serialChunkedReceive indicates there's nothing to receive") {
+            noteSerialAvailable_fake.return_val = true;
+            NoteMalloc_fake.custom_fake = malloc;
+            serialChunkedReceive_fake.custom_fake = serialChunkedReceiveNothing;
+
+            WHEN("serialNoteTransaction is called") {
+                const char *err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("serialNoteTransaction returns NULL (no error)") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("The response pointer is not NULL") {
+                    CHECK(rsp != NULL);
+
+                    AND_THEN("The response is an empty string") {
+                        CHECK(strlen(rsp) == 0);
+                    }
+                }
+            }
+
+            free(rsp);
+        }
+
+        AND_GIVEN("The response is small enough for one call to "
+                  "serialChunkedReceive") {
+            noteSerialAvailable_fake.return_val = true;
+            NoteMalloc_fake.custom_fake = malloc;
+            serialChunkedReceive_fake.custom_fake =
+                serialChunkedReceiveOneAndDone;
+
+            WHEN("serialNoteTransaction is called") {
+                const char *err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("serialNoteTransaction returns NULL (no error)") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("serialChunkedReceive is called exactly once") {
+                    CHECK(serialChunkedReceive_fake.call_count == 1);
+                }
+
+                THEN("The response pointer is not NULL") {
+                    CHECK(rsp != NULL);
+
+                    AND_THEN("The response is exactly what was received by "
+                             "serialChunkedReceive") {
+                        CHECK(strcmp(rsp, "\n") == 0);
+                    }
+                }
+            }
+
+            free(rsp);
+        }
+
+        AND_GIVEN("The response is too big for one call to "
+                  "serialChunkedReceive") {
+            noteSerialAvailable_fake.return_val = true;
+            NoteMalloc_fake.custom_fake = malloc;
+            serialChunkedReceive_fake.custom_fake =
+                serialChunkedReceiveMultiple;
+            // TODO: Explain what we're doing here.
+            serialChunkedReceiveMultipleLeft =
+                SERIAL_CHUNKED_RECEIVE_MULTIPLE_SIZE;
+
+            WHEN("serialNoteTransaction is called") {
+                const char *err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                THEN("serialNoteTransaction returns NULL (no error)") {
+                    CHECK(err == NULL);
+                }
+
+                THEN("serialChunkedReceive is called more than once") {
+                    CHECK(serialChunkedReceive_fake.call_count > 1);
+                }
+
+                THEN("The response pointer is not NULL") {
+                    CHECK(rsp != NULL);
+
+                    char expectedRsp[SERIAL_CHUNKED_RECEIVE_MULTIPLE_SIZE + 1];
+                    memset(expectedRsp, 1,
+                           SERIAL_CHUNKED_RECEIVE_MULTIPLE_SIZE);
+                    expectedRsp[SERIAL_CHUNKED_RECEIVE_MULTIPLE_SIZE] = '\0';
+                    AND_THEN("The response is exactly what was received by "
+                             "serialChunkedReceive") {
+                        CHECK(strcmp(rsp, expectedRsp) == 0);
+                    }
+                }
+
+                free(rsp);
+            }
+
+            AND_GIVEN("Growing the response buffer fails") {
+                void *(*mallocFns[])(size_t) = {malloc, MallocNull};
+                SET_CUSTOM_FAKE_SEQ(NoteMalloc, mallocFns, 2);
+
+                WHEN("serialNoteTransaction is called") {
+                    const char *err = serialNoteTransaction(req, strlen(req), &rsp, timeoutMs);
+
+                    THEN("serialNoteTransaction returns an error") {
+                        CHECK(err != NULL);
+                    }
+
+                    THEN("The response pointer is unchanged") {
+                        CHECK(rsp == NULL);
+                    }
+                }
+            }
+        }
+    }
+
+    RESET_FAKE(NoteMalloc);
+    RESET_FAKE(noteSerialAvailable);
+    RESET_FAKE(noteSerialTransmit);
+    RESET_FAKE(noteSerialReceive);
+    RESET_FAKE(NoteGetMs);
+    RESET_FAKE(serialChunkedTransmit);
+    RESET_FAKE(serialChunkedReceive);
+}
+
+}
+
+