pax_global_header00006660000000000000000000000064151751475270014530gustar00rootroot0000000000000052 comment=6e39144aaf5a6bc01b9f795010b0914431067183 aristocratos-btop-d43a485/000077500000000000000000000000001517514752700155455ustar00rootroot00000000000000aristocratos-btop-d43a485/.editorconfig000066400000000000000000000002211517514752700202150ustar00rootroot00000000000000[*.{cpp,h,hpp,sh,md,cfg,sample}] indent_style = tab indent_size = 4 brace_style = same_line [*.{yml,yaml}] indent_style = space indent_size = 2 aristocratos-btop-d43a485/.github/000077500000000000000000000000001517514752700171055ustar00rootroot00000000000000aristocratos-btop-d43a485/.github/FUNDING.yml000066400000000000000000000011031517514752700207150ustar00rootroot00000000000000# These are supported funding model platforms github: aristocratos patreon: # Replace with a single Patreon username open_collective: # Replace with a single Open Collective username ko_fi: aristocratos tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry liberapay: # Replace with a single Liberapay username issuehunt: # Replace with a single IssueHunt username otechie: # Replace with a single Otechie username custom: https://paypal.me/aristocratos aristocratos-btop-d43a485/.github/ISSUE_TEMPLATE/000077500000000000000000000000001517514752700212705ustar00rootroot00000000000000aristocratos-btop-d43a485/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000032661517514752700237710ustar00rootroot00000000000000--- name: Bug report about: Create a report to help us improve labels: bug --- **Read the README.md and search for similar issues before posting a bug report!** **Describe the bug** **To Reproduce** **Screenshots** **Info (please complete the following information):** - btop++ version: `btop --version` - If using snap: `snap info btop` - Binary: [self compiled or static binary from release] - Architecture: [x86_64, aarch64, etc.] `uname -m` - Platform: [Linux, FreeBSD, OsX] - (Linux) Kernel: `uname -r` - (OSX/FreeBSD) Os release version: - Terminal used: - Font used: **Additional context** **GDB Backtrace** aristocratos-btop-d43a485/.github/ISSUE_TEMPLATE/feature_request.md000066400000000000000000000011501517514752700250120ustar00rootroot00000000000000--- name: Feature request about: Suggest an idea for this project labels: feature --- **Is your feature request related to a problem? Please describe.** **Describe the solution you'd like** **Describe alternatives you've considered** **Additional context** aristocratos-btop-d43a485/.github/renovate.json5000066400000000000000000000001531517514752700217070ustar00rootroot00000000000000{ $schema: "https://docs.renovatebot.com/renovate-schema.json", extends: ["config:recommended"], } aristocratos-btop-d43a485/.github/workflows/000077500000000000000000000000001517514752700211425ustar00rootroot00000000000000aristocratos-btop-d43a485/.github/workflows/cmake-freebsd.yml000066400000000000000000000026661517514752700243670ustar00rootroot00000000000000name: FreeBSD CMake permissions: {} on: workflow_dispatch: push: branches: main tags-ignore: '*.*' paths: - '.github/workflows/cmake-freebsd.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/freebsd/*pp' - 'tests/**' pull_request: branches: main paths: - '.github/workflows/cmake-freebsd.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/freebsd/*pp' - 'tests/**' jobs: build: name: freebsd-${{ matrix.version}}-${{ matrix.arch}} runs-on: ubuntu-24.04 concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.arch }}-${{ matrix.version }} cancel-in-progress: true strategy: matrix: arch: ['aarch64', 'x86_64'] version: ['14.3', '15.0'] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Compile uses: vmactions/freebsd-vm@d1e65811565151536c0c894fff74f06351ed26e6 # v1.4.5 with: arch: ${{ matrix.arch }} release: ${{ matrix.version }} usesh: true prepare: pkg install -y cmake git ninja run: | cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug cmake --build build --verbose ctest --test-dir build aristocratos-btop-d43a485/.github/workflows/cmake-linux.yml000066400000000000000000000040501517514752700241010ustar00rootroot00000000000000name: Linux CMake permissions: {} on: workflow_dispatch: push: branches: main tags-ignore: '*.*' paths: - '.github/workflows/cmake-linux.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/linux/*pp' - 'tests/**' pull_request: branches: main paths: - '.github/workflows/cmake-linux.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/linux/*pp' - 'tests/**' jobs: build: name: ${{ matrix.compiler }}-${{ matrix.version }} runs-on: ubuntu-24.04 concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.compiler }}-${{ matrix.version }} cancel-in-progress: true strategy: matrix: include: - compiler: clang version: 19 - compiler: clang version: 20 - compiler: clang version: 21 - compiler: clang version: 22 - compiler: gcc version: 14 env: COMPILER: "${{ matrix.compiler }}" VERSION: "${{ matrix.version }}" steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Install clang ${{ matrix.version }} if: ${{ matrix.compiler == 'clang' }} run: wget -qO - https://apt.llvm.org/llvm.sh | sudo bash -s -- ${VERSION} all - name: Configure run: | if [[ "${COMPILER}" == "clang" ]]; then export CC=clang-${VERSION} export CXX=clang++-${VERSION} export CXXFLAGS="-stdlib=libc++" export LDFLAGS="-fuse-ld=lld -rtlib=compiler-rt -unwindlib=libunwind" else export CC=gcc-${VERSION} export CXX=g++-${VERSION} fi cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug - name: Compile run: cmake --build build --verbose - name: Test run: ctest --test-dir build aristocratos-btop-d43a485/.github/workflows/cmake-macos.yml000066400000000000000000000030641517514752700240500ustar00rootroot00000000000000name: macOS CMake permissions: {} on: workflow_dispatch: push: branches: main tags-ignore: '*.*' paths: - '.github/workflows/cmake-macos.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/osx/*pp' - 'tests/**' pull_request: branches: main paths: - '.github/workflows/cmake-macos.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/osx/*pp' - 'tests/**' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true jobs: cmake_build_on_macos: runs-on: macos-15 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Install build tools run: | export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew update --quiet brew install --force --overwrite cmake llvm lld ninja - name: Configure run: | export LLVM_PREFIX="$(brew --prefix llvm)" export LLD_PREFIX="$(brew --prefix lld)" export CXX="$LLVM_PREFIX/bin/clang++" export CPPFLAGS="-I$LLVM_PREFIX/include" export LDFLAGS="-L$LLVM_PREFIX/lib -L$LLVM_PREFIX/lib/c++ -Wl,-rpath,$LLVM_PREFIX/lib/c++ -fuse-ld=$LLD_PREFIX/bin/ld64.lld" cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug - name: Compile run: cmake --build build --verbose - name: Test run: ctest --test-dir build aristocratos-btop-d43a485/.github/workflows/cmake-netbsd.yml000066400000000000000000000033211517514752700242210ustar00rootroot00000000000000name: NetBSD CMake permissions: {} on: workflow_dispatch: push: branches: main tags-ignore: '*.*' paths: - '.github/workflows/cmake-netbsd.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/netbsd/*pp' - 'tests/**' pull_request: branches: main paths: - '.github/workflows/cmake-netbsd.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/netbsd/*pp' - 'tests/**' jobs: build: name: netbsd-${{ matrix.version }}-${{ matrix.arch }} runs-on: ubuntu-24.04 concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.arch }}-${{ matrix.version }} cancel-in-progress: true strategy: matrix: arch: ['aarch64', 'amd64'] version: ['10.1'] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Compile uses: vmactions/netbsd-vm@eb3ba840926911ccf17dc9de235335cb27a02ba0 # v1.3.8 with: arch: ${{ matrix.arch }} release: ${{ matrix.version }} usesh: true prepare: | export PATH="/usr/pkg/sbin:/usr/pkg/bin:$PATH" export PKG_PATH="https://ftp.netbsd.org/pub/pkgsrc/packages/NetBSD/${{ matrix.arch }}/${{ matrix.version }}/All/" /usr/sbin/pkg_add pkgin pkgin -y install cmake gcc14 git ninja-build run: | export CXX="/usr/pkg/gcc14/bin/g++" cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug cmake --build build --verbose ctest --test-dir build aristocratos-btop-d43a485/.github/workflows/cmake-openbsd.yml000066400000000000000000000026461517514752700244050ustar00rootroot00000000000000name: OpenBSD CMake permissions: {} on: workflow_dispatch: push: branches: main tags-ignore: '*.*' paths: - '.github/workflows/cmake-openbsd.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/openbsd/*pp' - 'tests/**' pull_request: branches: main paths: - '.github/workflows/cmake-openbsd.yml' - 'CMakeLists.txt' - 'cmake/**' - 'include/**' - 'src/*pp' - 'src/openbsd/*pp' - 'tests/**' jobs: build: name: openbsd-${{ matrix.version}}-${{ matrix.arch}} runs-on: ubuntu-24.04 concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.arch }}-${{ matrix.version }} cancel-in-progress: true strategy: matrix: arch: ['aarch64', 'x86_64'] version: ['7.8'] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Compile uses: vmactions/openbsd-vm@d7d892b7b9ba97ed2747b0fc201be65037d64c3e # v1.4.0 with: arch: ${{ matrix.arch }} release: ${{ matrix.version }} usesh: true prepare: pkg_add cmake git ninja run: | cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug cmake --build build --verbose ctest --test-dir build aristocratos-btop-d43a485/.github/workflows/continuous-build-freebsd.yml000066400000000000000000000037461517514752700266120ustar00rootroot00000000000000name: Continuous Build FreeBSD permissions: {} on: workflow_dispatch: push: branches: - main tags-ignore: - '*.*' paths: - 'src/**' - '!src/linux/**' - '!src/osx/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-freebsd.yml' pull_request: branches: - main paths: - 'src/**' - '!src/linux/**' - '!src/osx/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-freebsd.yml' jobs: build-freebsd: runs-on: ubuntu-24.04 timeout-minutes: 20 concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.compiler }} cancel-in-progress: true strategy: matrix: compiler: ["clang++", "g++"] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Compile uses: vmactions/freebsd-vm@d1e65811565151536c0c894fff74f06351ed26e6 # v1.4.5 with: release: '15.0' usesh: true prepare: | pkg install -y gmake gcc15 coreutils git lowdown git config --global --add safe.directory /home/runner/work/btop/btop run: | if [ "${{ matrix.compiler }}" == "g++" ]; then CXX=g++15 COMPILER=gcc else CXX=clang++ COMPILER=llvm fi gmake STATIC=true STRIP=true GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") mv bin/btop bin/btop-"$COMPILER"-"$GIT_HASH" ls -alh bin - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: btop-x86_64-freebsd-15-${{ matrix.compiler }} path: 'bin/*' if-no-files-found: error aristocratos-btop-d43a485/.github/workflows/continuous-build-gpu.yml000066400000000000000000000021611517514752700257610ustar00rootroot00000000000000name: Continuous Build Gpu permissions: {} on: workflow_dispatch: push: branches: - main tags-ignore: - '*.*' paths: - 'src/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-gpu.yml' pull_request: branches: - main paths: - 'src/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-gpu.yml' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true jobs: gpu_build_linux: runs-on: ubuntu-24.04 container: alpine:edge steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Install build tools run: apk add --no-cache --update gcc g++ make linux-headers - name: Compile run: make CXX=g++ GPU_SUPPORT=true aristocratos-btop-d43a485/.github/workflows/continuous-build-linux.yml000066400000000000000000000057531517514752700263370ustar00rootroot00000000000000name: Continuous Build Linux permissions: {} on: workflow_dispatch: push: branches: main tags-ignore: '*.*' paths: - 'src/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-linux.yml' pull_request: branches: main paths: - 'src/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-linux.yml' jobs: build: runs-on: ubuntu-24.04 concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.toolchain }} cancel-in-progress: true continue-on-error: true strategy: matrix: toolchain: - aarch64-unknown-linux-musl - arm-unknown-linux-musleabi - arm-unknown-linux-musleabihf - armv7-unknown-linux-musleabi - armv7-unknown-linux-musleabihf - i586-unknown-linux-musl - i686-unknown-linux-musl - m68k-unknown-linux-musl - mips-unknown-linux-musl - mips-unknown-linux-muslsf - mips64-unknown-linux-musl - mips64el-unknown-linux-musl - mipsel-unknown-linux-musl - mipsel-unknown-linux-muslsf - powerpc-unknown-linux-musl - powerpc64-unknown-linux-musl - powerpc64le-unknown-linux-musl - powerpcle-unknown-linux-musl - riscv32-unknown-linux-musl - riscv64-unknown-linux-musl - s390x-ibm-linux-musl - x86_64-unknown-linux-musl env: TOOLCHAIN: "${{ matrix.toolchain }}" steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Install cross toolchain run: | wget -q -P /tmp https://github.com/cross-tools/musl-cross/releases/download/20260430/${TOOLCHAIN}.tar.xz wget -q -P /tmp https://github.com/cross-tools/musl-cross/releases/download/20260430/${TOOLCHAIN}.tar.xz.sha256 echo "$(cat /tmp/${{ matrix.toolchain }}.tar.xz.sha256) /tmp/${{ matrix.toolchain }}.tar.xz" | sha256sum --check --status mkdir -p /opt/x-tools/ tar -xf /tmp/${TOOLCHAIN}.tar.xz -C /opt/x-tools - name: Compile run: CXX=/opt/x-tools/${TOOLCHAIN}/bin/${TOOLCHAIN}-g++ make STATIC=true STRIP=true - name: Create binary artifacts env: GITHUB_SHA: "${{ github.sha }}" run: | GIT_HASH=$(git rev-parse --short "${GITHUB_SHA}") FILENAME=btop-${TOOLCHAIN/linux-musl/}-$GIT_HASH mv bin/btop bin/$FILENAME - name: Upload artifacts uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: btop-${{ matrix.toolchain }} path: '${{ github.workspace }}/bin/*' aristocratos-btop-d43a485/.github/workflows/continuous-build-macos.yml000066400000000000000000000040071517514752700262710ustar00rootroot00000000000000name: Continuous Build MacOS permissions: {} on: workflow_dispatch: push: branches: - main tags-ignore: - '*.*' paths: - 'src/**' - '!src/linux/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-macos.yml' pull_request: branches: - main paths: - 'src/**' - '!src/linux/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-macos.yml' jobs: build-macos: concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ matrix.os.runner }} cancel-in-progress: true continue-on-error: true strategy: matrix: os: - runner: macos-14 version: Sonoma - runner: macos-15 version: Sequoia runs-on: ${{ matrix.os.runner }} steps: - uses: maxim-lobanov/setup-xcode@ed7a3b1fda3918c0306d1b724322adc0b8cc0a90 # v1.7.0 with: xcode-version: latest-stable - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Install build tools run: | export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew update --quiet brew install --force --overwrite gcc@15 lowdown - name: Compile env: RUNNER: "${{ matrix.os.runner }}" VERSION: "${{ matrix.os.version }}" run: | make CXX=$(brew --prefix)/bin/g++-15 GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") mv bin/btop bin/btop-arm64-${RUNNER}-${VERSION}-$GIT_HASH ls -alh bin - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: btop-arm64-${{ matrix.os.runner }}-${{ matrix.os.version }} path: 'bin/*' aristocratos-btop-d43a485/.github/workflows/continuous-build-netbsd.yml000066400000000000000000000037271517514752700264560ustar00rootroot00000000000000name: Continuous Build NetBSD permissions: {} on: workflow_dispatch: push: branches: - main tags-ignore: - '*.*' paths: - 'src/**' - '!src/linux/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-netbsd.yml' pull_request: branches: - main paths: - 'src/**' - '!src/linux/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-netbsd.yml' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true jobs: build-netbsd: runs-on: ubuntu-24.04 timeout-minutes: 20 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Compile uses: vmactions/netbsd-vm@eb3ba840926911ccf17dc9de235335cb27a02ba0 # v1.3.8 with: release: '10.1' usesh: true prepare: | PATH="/usr/pkg/sbin:/usr/pkg/bin:$PATH" PKG_PATH="https://ftp.netbsd.org/pub/pkgsrc/packages/NetBSD/amd64/10.1/All/" export PATH PKG_PATH /usr/sbin/pkg_add pkgin pkgin -y install gmake gcc14 coreutils git git config --global --add safe.directory /home/runner/work/btop/btop run: | gmake CXX=/usr/pkg/gcc14/bin/g++ CXXFLAGS='-DNDEBUG -I/usr/pkg/gcc14/include -I/usr/include -I/usr/pkg/include' STATIC=true STRIP=true GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") mv bin/btop bin/btop-GCC10-"$GIT_HASH" ls -alh bin - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: btop-x86_64-netbsd-10.1 path: 'bin/*' if-no-files-found: error aristocratos-btop-d43a485/.github/workflows/continuous-build-openbsd.yml000066400000000000000000000031671517514752700266270ustar00rootroot00000000000000name: Continuous Build OpenBSD permissions: {} on: workflow_dispatch: push: branches: - main tags-ignore: - '*.*' paths: - 'src/**' - '!src/linux/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-openbsd.yml' pull_request: branches: - main paths: - 'src/**' - '!src/linux/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/continuous-build-openbsd.yml' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true jobs: build-openbsd: runs-on: ubuntu-24.04 timeout-minutes: 20 steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Compile uses: vmactions/openbsd-vm@d7d892b7b9ba97ed2747b0fc201be65037d64c3e # v1.4.0 with: release: '7.8' usesh: true prepare: | pkg_add gmake coreutils git lowdown git config --global --add safe.directory /home/runner/work/btop/btop run: | gmake STATIC=true STRIP=true GIT_HASH=$(git rev-parse --short "$GITHUB_SHA") mv bin/btop bin/btop-"$GIT_HASH" - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: btop-x86_64-openbsd-7.8 path: 'bin/*' if-no-files-found: error aristocratos-btop-d43a485/.github/workflows/test-snap-can-build.yml000066400000000000000000000025051517514752700254410ustar00rootroot00000000000000name: ๐Ÿงช Test snap can be built on x86_64 permissions: {} on: workflow_dispatch: push: branches: [main] tags-ignore: - '*.*' paths: - 'src/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/test-snap-can-build.yml' - 'snap/snapcraft.yaml' pull_request: branches: [main] paths: - 'src/**' - '!src/osx/**' - '!src/freebsd/**' - '!src/netbsd/**' - '!src/openbsd/**' - 'include/**' - 'Makefile' - '.github/workflows/test-snap-can-build.yml' - 'snap/snapcraft.yaml' concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true jobs: build: runs-on: ubuntu-24.04 strategy: matrix: node-version: [20.x] steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - uses: snapcore/action-build@3bdaa03e1ba6bf59a65f84a751d943d549a54e79 # v1.3.0 id: build - uses: diddlesnaps/snapcraft-review-action@40554b42331cf84dab19ef98c382620427f13482 # v1.3.1 with: snap: ${{ steps.build.outputs.snap }} isClassic: 'false' aristocratos-btop-d43a485/.github/workflows/zizmor.yml000066400000000000000000000013521517514752700232200ustar00rootroot00000000000000name: GitHub Actions Security Analysis with zizmor ๐ŸŒˆ permissions: {} on: push: branches: - main pull_request: {} concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true jobs: zizmor: name: Run zizmor ๐ŸŒˆ runs-on: ubuntu-24.04 permissions: security-events: write # Required for upload-sarif (used by zizmor-action) to upload SARIF files. steps: - name: Checkout repository uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: persist-credentials: false - name: Run zizmor ๐ŸŒˆ uses: zizmorcore/zizmor-action@b1d7e1fb5de872772f31590499237e7cce841e8e # v0.5.3 aristocratos-btop-d43a485/.gitignore000066400000000000000000000021471517514752700175410ustar00rootroot00000000000000# gitginore template for creating Snap packages # website: https://snapcraft.io/ parts/ prime/ stage/ *.snap # Snapcraft global state tracking data(automatically generated) # https://forum.snapcraft.io/t/location-to-save-global-state/768 /snap/.snapcraft/ # Source archive packed by `snapcraft cleanbuild` before pushing to the LXD container /*_source.tar.bz2 # Prerequisites *.d # Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod *.smod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app # Compiled man page btop.1 build bin btop /obj/ config.h .*/ # Optional libraries lib/rocm_smi_lib # Don't ignore .github directory !.github/ # Ignore files created by Qt Creator *.config *.creator *.creator.user *.creator.user.* *.cflags *.cxxflags *.files *.includes # CMake CMakeLists.txt.user CMakeCache.txt CMakeFiles CMakeScripts Testing Makefile cmake_install.cmake install_manifest.txt compile_commands.json CTestTestfile.cmake _deps CMakeUserPresets.json # CLion cmake-build-* aristocratos-btop-d43a485/CHANGELOG.md000066400000000000000000000614521517514752700173660ustar00rootroot00000000000000## v1.4.7 References | Description | Author(s) --- | --- | --- #1326 | Feat: Process following and following mode improvements | @vandabbin #1541 | feat: Add Apple Silicon GPU support via IOReport API | @gneitzke #1602 | feat: add Kanagawa Dragon theme | @Marcus441 #1443 | Add twilight theme | @hastinbe #1433 | Add Swap upload/download speed graph option, Fix network graphs overlap | @TheSovietPancakes #1522 | Add Flexoki dark and light themes | @nsyout #1493 | Menu option to disable presets | @vandabbin #1492 | Create orange.theme | @neocerambyx #1564 | Add E hotkey to collapse/expand all processes in tree mode | @sardonyx001 #1601 | fix: restore Apple Silicon temp reporting on M2 Pro | @RockBacon9922 #1427 | fix regression from a switch to kIOMainPortDefault | @barracuda156 #1429 | Fix hide and info buttons | @vandabbin #1452 | Fix mouse mapping for process kill buttons with vim keys enabled | @vandabbin #1454 | Fix kill buttons | @vandabbin #1456 | following mode fixes | @vandabbin #1458 | Fixes and Improvements for Pause and Follow modes | @vandabbin #1409 | fix: remove unused asprintf implementation function | @deckstose #1445 | fix: remove busy waiting when checking runner thread state | @deckstose #1491 | Update clock with preset change or show/hide box | @vandabbin #1521 | Tweaked RX/TX collection and drawing, Fix -Wparentheses warning | @TheSovietPancakes #1518 | fix: mem bottom border when net is not shown | @vandabbin #1515 | fix: force_tty menu option sets TTY mode on start | @vandabbin #1539 | fix: accumulate pwr_usage into pwr_total instead of mem_total in Gpu::collect() | @alephpiece #1622 | fix: read GPU/VRAM clocks when ROCm SMI reports version 1.x | @theRealWardo #1598 | fix: render a non-ascii chars in proc list | @deniskhud #1619 | fix CPU mib queries for OpenBSD, only display online CPUs in output | @busterb #1583 | fix: correctly map amd zen cpu core temps | @sola-contrib #1628 | fix: restore Intel Mac CPU temperature fallback | @seanniu93 #1560 | fix: Use SVG features compatible with Qt SVG Tiny 1.1 | @ratijas ea977a0 | Update widechar detection and fix replace_ascii_control() removing wide characters | @aristocratos 7657384 | Fix cpu watt overflow in cpu box + division by zero fix for cpu.temp_max | @aristocratos b36357b | Fixed missing CPU package temperature color (numeric value) | @aristocratos ## v1.4.6 References | Description | Author(s) --- | --- | --- #1272 | Skip 'H' and 'HX' suffix in AMD cpu name trimming | @ramdomPTM #1268 | feature: add process renice functionality | @goddamnparticle #1285 | Revert "Use /sys/dev/block/MAJOR:MINOR instead of /sys/block/NAME for disk I/O" #1270 | @deckstose #1277 | feat: Introduce cpu frequency display modes | @emiliopedrollo #1282 | Fix CPU frequency detection for LoongArch CPUs | @Twopic2 #1275 | fix arrow keys that send 'O' instead of '[' | @vandabbin #1251 | OpenBSD: battery: add support for watthour and watts sensors | @shtrophic #1208 | Add Gotham theme | @jrebs #1291 | Fix macOS deadlocks and race conditions in collector threads #1292 | @kuzmeech #1296 | fix: btop crash on arm cpu | @emiliopedrollo @zenofile #984 | Added ability to set which gpu vendors to enable | @thedustinmiller #1274 | added tree toggle of expand/collapse for children of process | @irabrine #1300 | Use right key codes to match f1 and f2 keys | @vandabbin #1305 | Handle missing SMC gracefully on macOS | @achille #1309 | Fix redraw in proc list when changing sort order | @vandabbin #1304 | Fix load average and GPU watts leaking past box border | @vandabbin #1220 | feat: respect effective cpus from cgroup | @deckstose #1218 | feat: display container engine | @deckstose #1315 | feat: raise cpp standard to c++23 | @deckstose d0cbaf7 | Add configuration toggle for terminal synchronization | @aristocratos #1306 | Implement feat Process list pausing | @vandabbin #1322 | flip name, command, and user sorting | @vandabbin #1334 | fix tty theme for pause banner | @vandabbin #1325 | test: add test harness with ctest | @deckstose #1339 | fix: skip first argument of argv | @AlvaroParker #1357 | feat: add --themes-dir flag | @adeci #1359 | fix: don't over-/underflow when parsing --update argument | @yinghao-w #1362 | fix segfault on musl systems | @v1cont #1363 | Pass only static duration strings to Config::set in Config::apply_preset | @yinghao-w #1366 | fix: cpu per-thread totals not reaching 100% | @Tom94 #1367 | Fix: Align boxes when Cpu bottom and Gpu on | @yinghao-w #1372 | Minor fixes and improvements for NetBSD | @fraggerfox #1377 | Fixed GPU rendering | @TheSovietPancakes #1379 | Fix: Always collect GPU data when cpu_graph_lower = "Auto" | @yinghao-w #1393 | Fix: humanized units shortening | @yinghao-w #1401 | Feat: add mouse dragging of scrollbar | @yinghao-w #1399 | feat: add cli option to dump default config | @deckstose e969f43 | Added "save_config_on_exit" option to configuration | @aristocratos ## v1.4.5 References | Description | Author(s) --- | --- | --- #1254 | Bump bundled fmt to 12.0.0 | @deckstose #1242 | Enable vim movement in help menu | @botantony #948 | Remove reduntant symbols in tree view | @Denizantip #1249 | Use /sys/dev/block/MAJOR:MINOR instead of /sys/block/NAME for disk I/O | @CountBleck #1227 | feat: display CPU power draw & fix GPU+load avg overwriting core info | @Tom94 and @YuriiShkrobut 4f5abbb | Fix locale issues | @aristocratos #1165 | Add encode and decode meters on Nvidia GPUs | @sam-kirby #1197 | linux: Battery Time-to-full | @RadsammyT #1203 | Convert ascii escape codes in mountpoint names before reading statvfs | @deckstose #1198 | Fix presets erroring with gpu* usage | @entropylost #1191 | Fix --tty/--no-tty flag having no effect | @deckstose ## v1.4.4 References | Description | Author(s) --- | --- | --- #1185 | Fix auto-detection of CPU temp on Ampere boards | @bexcran 589c133 | Fixed floating_humanizer() to work correctly when numeric delimiter isn't a dot. | @aristocratos #1157 | Add command line option to set an inital filter | @imwints #1172 | Make 100ms the minimal refresh rate. Exit gracefully if integer conversion in CLI parser fails. | @imwints #1031 | Lock/unlock config to avoid infinite recursion | @Jacajack #1156 | Fix incorrect positioning and start symbol of second title introduced in 2538d89 | @xDMPx ffcd064 | Fix dangling reference warnings for GCC 13 and later | aristocratos ## v1.4.3 References | Description | Author(s) --- | --- | --- c3b225f | Revert e266ccd which broke str_to_upper() and str_to_lower() | @aristocratos #1137 | Enable additional checks in libc++ with the new hardening mode | @imwints #1135 | Remove redundant optimization flag | @imwints #1139 | Ignore incomplete filter regex, issue #1133 | @imwints ## v1.4.2 References | Description | Author(s) --- | --- | --- f1482fe | Fix process arguments appearing outside proc box by replacing ASCII control codes with blankspace, issue #1080 | @aristocratos #1130 | Fix problems shown by clang-tidy's performance checks | @imwints #1120 | Fix wrong error message and documentation of renamed option --utf-force | @t-webber @imwints #1128 | Flatten cmake module path | @imwints #1129 | CMake: Remove option to use mold | @imwints #1047 | Update Terminus font link, fix typo, spelling, and grammar | @QinCai-rui #929 | Please clang with sanitizers | @bad-co-de #1126 | Fix MacOS tree-mode + aggregate memory/thread scaling issue | @xaskii #993 | Fix typo: Mhz -> MHz | @NyCodeGHG ## v1.4.1 References | Description | Author(s) --- | --- | --- #1111 #1112 | Various code fixes | @imwints #930 #931 | Various code fixes | @bad-co-de #1061 | Fixed typo | @polluks #1110 | Move the config parser in it's own module | @imwints #1101 | Adding a menu option to show bitrates in base 10 separate from the setting to show bytes/bits in base 10 | @georgev93 #1079 | Allow MidnightBSD to build btop using the existing freebsd support. | @laffer1 #1098 | Use XDG_STATE_HOME to save logs | @imwints #1092 | Bump CMake version to 3.25 required for LINUX variable | @imwints #1058 | Replace brackets with arrows in net and proc box | @taha-yassine #1091 | Bump bundled fmt to 11.1.4 | @imwints #725 | cmake: link to CMAKE_DL_LIBS | @alalazo #990 | Fix phoenix-night.theme marked as executable | @sertonix #1034 | Add Kanagawa-lotus and Kanagawa-wave themes | @philikarus #973 | Bump NetBSD version to 10.1 and FreeBSD version to 14.2. | @fraggerfox #1072 | Add dark version of adwaita theme: adwaita-dark | @k0tran #1036 | Resetting last selection on page navigation in optionsMenu to avoid unordered_map error | @seth-wood #1029 | Share the CPU name trimming code between platforms | @yarrick #1033 | Update Ryzen name trimming | @yarrick #1030 | Drop macos 12 build, add v14 and v15 | @yarrick #1028 | Fix cmake-macos workflow | @yarrick #1027 | Bump version of deprecated upload-artifact step | @yarrick #1025 | Update obsolete egrep call | @tywkeene b52069c | Fix menu crash when GPU_SUPPORT=false, issue #989 | @aristocratos #961 | Add 'Everforest Ligth Medium' theme | @mstuttgart #960 | Support intel GPUs before Gen-6 (patch from upstream) | @w8jcik #958 | intel_name_lookup_shim.c (get_intel_device_name): Fix SEGFAULT | @artyom-poptsov 2e7208d | Fix rsmi_measure_pcie_speeds not saving, issue #934 | @aristocratos f3446ed | Show GPU Watt fractions when below 100W | @aristocratos | + more from @imwints @aristocratos Big thanks to @imwints for helping out with project maintenance, PR reviews and merging! ## v1.4.0 References | Description | Author(s) --- | --- | --- #703 | NetBSD Support | @fraggerfox #903 | Intel GPU support | @bjia56 161e8f4 | Added warnings when toggling boxes and terminal size is to small | @aristocratos 4210f5f | Fix missing core percentages, issue #792 | @aristocratos 35857f8 | Various fixes for drawing GPU related information | @aristocratos #879 | fix divide 0 error when caculating disk usage percentage (#791) | @flylai #884 | fix io_graph_speeds parsing | @feihtthief #863 | V1 of Phoenix Night theme | @Firehawke 3f384c0 | Fixed missing CPU core temps when too small to show core temp graphs, issues #792 #867 | @aristocratos 97d2fb5 | Fixed missing IO graphs in IO mode, issue #867 | @aristocratos #840 | fix zero temp (#467) | @joske #850 | Fix comments (parsing) in theme files | @acidghost #806 | Add regex filtering | @imwints #836 | Fix typo in file existences check for voltage_now | @vsey #835 | Show time in days when remaining battery exceeds an estimation of 24h | @imwints #819 | (AMD Gpu) fix pwr_usage not being defined correctly during rsmi collection | @kalkafox #831 | macOS: fix crash if there exists a uid not associated with any user | @thecoder-001 #796 | Fix rsmi device name buffer size | @davc0n #807 | Add gruvbox_light theme | @kk9uk #724 | Create man page for btop in Markdown | @ottok #734 | Include metadata in binary version output `btop --version` | @imwints #771 | collect: Fix reading of battery power draw on Linux | @Derppening ## v1.3.2 Description | Author(s) | References --- | --- | --- fix: Can't detect librocm 6.0.x | @imwints, @aristocratos | #761 ## v1.3.1 Description | Author(s) | References --- | --- | --- GPU: Added support for dynamic loading of ROCm v6 libraries | @aristocratos, @fxzjshm | 5511131, #737 Increase max network interface name to 15 | @tessus | #714 Fix OpenBSD UTF-8 locale detection | @lcheylus, @imwints | #753, #717 Add hot-reloading of config file with CTRL+R or SIGUSR2 signal | @MartinPit | #722 Add battery power draw for linux and freebsd | @vsey | #689 Fix crash caused by string exception when cpu clock is exactly between 999.5 and 999.9 Mhz | @rkmcode | #735 Write newline at end of config file | @planet36 | #743 Add theme based on Everforest Dark Medium palette | @M-Sviridov | #746 fix: don't mangle memory for zombie processes | @joske | #747 Share common code from collect | @imwints | #756 Fixed incorrect used and available memory for OSX | | 4461a43 ## v1.3.0 * Added Gpu Support Linux | @romner-set | PR #529 * Added platform support for OpenBSD | @joske | PR #607 * Enable macos clang | @muneebmahmed | PR #666 * Fix Apple Silicon CPUs misprinted | @masiboss | PR #679 * Cmake support for MacOS | @imwints | PR #675 * Elementarish theme: color update according to Elementary palette | @stradicat | PR #660 * Add alternative key codes for Delete, Insert, Home, End | @ivanp7 | PR #659 * Fix scrollbar not clearing sometimes. | @DecklynKern | PR #643 * Add keybind for toggling memory display mode in PROC box | @rahulaggarwal965 | PR #623 * Minor string initialization improvement | @imwints | PR #636 * Made disks statvfs logic asynchronous. | @crestfallnatwork | PR #633 * Fix signal list on non-linux/weird linux platforms | @lvxnull | PR #630 * Add option to accumulate a child's resources in parent in tree-view | @imwints | PR #618 * Add CMake support for Linux | @imwints | PR #589 * Horizon theme | @SidVeld | PR #610 * Fix short conversion of 1000-1023 *iB | @scorpion-26 | #609 * Fix integer overflows in btop_collect.cpp | @dorrellmw | #546 * Support compiling with LLVM | @imwints | #510 * Fix getting zfs pool name with '.' char in freebsd | @jfouquart | #602 * [macos/freebsd] support gcc13 | @joske | #600 * FreeBSD swap info | @rrveex | #560 * Create adwaita.theme | @flipflop133 | #485 * Try get terminal size of "/dev/tty" if stdout fails | @imwints | PR #627 * Refresh rate program argument | @imwints | PR #640 * Improved error handling when determining the config directory | @imwints | #652 * Use native POSIX polling syscalls to read input | @lvxnull | #624 * Conditional compile on Big Sur and up | @joske | PR #690 + Various fixes by @imwints, @simplepad, @joske, @gwena, @cpalv, @iambeingtracked, @mattico, @NexAdn ## v1.2.13 * Makefile: VERBOSE=true flag for Makefile to display all compiler commands and fixed so already set CXXFLAGS and LDFLAGS are displayed. * Makefile: Added autodetection for gcc12 to make compiling on macos Ventura easier. * Changed: Reverted back to sysconf(_SC_NPROCESSORS_ONLN) for Cpu core count ant let the new dynamic update fix if cores are turned on later * Fixed: Ignore disks that fails in statvfs64() to avoid slowdowns and possible crashes. * Fixed: Moved up get_cpuHz() in the execution order to get better cpu clock reading. * Added: proc tree view: if there's more than 40 width left, try to print full cmd, by @Superty * Fixed: Show the first IP of the interface in NET box instead of the last, by @correabuscar * Changed: Replace getnameinfo with inet_ntop [on Linux], by @correabuscar * Fixed: Not picking up last username from /etc/passwd * Fixed: Process nice value underflowing, issue #461 * Changed: Replace getnameinfo with inet_ntop [on FreeBSD], by @correabuscar * Changed: Replace getnameinfo with inet_ntop [on macos], by @correabuscar ## v1.2.12 * Added: Dynamic updating of max number of CPU cores. ## v1.2.11 * Fixed: Number of cores wrongly detected for Ryzen in rare cases. ## v1.2.10 * Fixed: Process tree filtering not case insensitive * Added: Paper theme, by @s6muel * Fixed: Extra checks to avoid crash on trying to replace empty strings in tree mode * Fixed: Crashing when cores are offline * Fixed: Cpu::collect() core count counter... * Changed: Using sysconf(_SC_NPROCESSORS_CONF) for number of cores instead of sysconf(_SC_NPROCESSORS_ONLN) * Maintenance: Code cleanup, by @stefanos82 ## v1.2.9 * Fixed: Memory values not clearing properly when not in graph mode in mem box * Changed: kyli0x theme color update, by @kyli0x * Added: Elementarish theme, by @dennismayr * Added: key "?" to see help, by @mohi001 * Added: solarized_light theme, by @Fingerzam * Changed: Made ZFS stats collection compatible with zfs_pools_only option, by @simplepad * Changed: Rewrite of process sorting and tree generation including fixes for tree sorting and mouse support * Added: Option to hide the small cpu graphs for processes * Changed: Small graphs now show colors for each character * Fixed: Getting selfpath on macos (fix for finding theme folder) ## v1.2.8 * Added: Support for ZFS pool io stats monitoring, by @simplepad * Added: Filtering of kernel processes, by @0xJoeMama * Added: New theme everforest-dark-hard, by @iambeingtracked * Added: New theme tomorrow-night, by @appuchias * Changed: Disable battery monitoring if it fails instead of exiting ## v1.2.7 * Fixed: Disk IO stats for individual partitions instead of whole disk (Linux) * Added: Case insensitive process filtering, by @abrasumente233 * Added: Include ZFS ARC in cached/available memory on Linux, by @mattico * Added: Desktop entry and icons, by @yonatan8070 * Fixed: Net sync scale bug * Added: tokyo-night & tokyo-storm themes, by @Schievel1 ## v1.2.6 * Fixed: Wrong memory unit when shorten and size is less than 10, by @mohi001 * Fixed: Use cpu cores average temp if missing cpu package temp for FreeBSD * Changed: Enter symbol to a more common variant ## v1.2.5 * Fixed: Fallback to less accurate UTF8 char count if conversion to wstring fails * Fixed: Small ui fixes for mem and disks * Added: New theme HotPurpleTrafficLight, by @pallebone * Fixed: title_left symbol between auto and zero in the net box is not displayed, by @mrdotx * Fixed: Mouse mappings for net box ## v1.2.4 * Optimization: Proc::draw() * Fixed: Ignore duplicate disks with same mountpoint * Changed: Restrict command line for processes to 1000 characters to fix utf8 conversion errors * Added: add "g" and "G" to vim keys, by @mohi001 ## v1.2.3 * Changed: floating_humanizer() now show fractions when shortened and value is < 10 * Fixed: Process tree not redrawing properly * Fixed: string to wstring conversion crash when string is too big ## v1.2.2 * Changed: Reverted uncolor() back to using regex to fix delay in opening menu when compiled with musl * Added: Toggle for showing free disk space for privileged or normal users * Added: Clarification on signal screen that number can be manually entered ## v1.2.1 * Added: Arrow only after use of "f" when filtering processes, by @NavigationHazard * Fixed: Fx::uncolor not removing all escapes * Fixed: Text alignment for popup boxes * Fixed: Terminal resize warning getting stuck * Removed: Unnecessary counter for atomic_lock * Added: Percentage progress to Makefile * Fixed: Alignment of columns in proc box when wide UTF8 characters are used * Fixed: Battery meter draw fix ## v1.2.0 * Added: Support for FreeBSD, by @joske and @aristocratos * Fixed (again): Account for system rolling over net speeds in Net::collect() * Added: Theme gruvbox_material_dark, by @marcoradocchia * Added: Option for base 10 bytes/bits ## v1.1.5 * Fixed: Account for system rolling over net speeds in Net::collect() ## v1.1.4 * Fixed: Create dependency files in build directory when compiling, by @stwnt * Fixed: fix CPU temp fallback on macOS, by @joske * Changed: From rng::sort() to rng::stable_sort() for more stability * Fixed: in_avail() can always be zero, by @pg83 ## v1.1.3 * Added: New theme ayu, by @AlphaNecron * Added: New theme gruvbox_dark_v2, by @pietryszak * Fixed: Macos cpu coretemp for Intel, by @joske * Added: New theme OneDark, by @vtmx * Fixed: Fixed network graph scale int rollover * Fixed: Suspected possibility of very rare stall in Input::clear() ## v1.1.2 * Fixed: SISEGV on macos Mojave, by @mgradowski * Fixed: Small optimizations and fixes to Mem::collect() and Input::get() * Fixed: Wrong unit for net_upload and net_download in config menu * Fixed: UTF-8 detection on macos * Fixed: coretemp iteration due to missing tempX_input, by @KFilipek * Fixed: coretemp ordering ## v1.1.1 * Added: Partial static build (libgcc, libstdc++) for macos * Changed: Continuous build macos switched to OSX 11.6 (Big Sur) and partial static build * Changed: Release binaries for macos switched to OSX 12 (Monterey) and partial static build ## v1.1.0 * Added: Support for OSX, by @joske and @aristocratos ## v1.0.24 * Changed: Collection ordering * Fixed: Restore all escape seq mouse modes on exit * Fixed: SIGINT not cleaning up on exit ## v1.0.23 * Fixed: Config parser missing first value when not including version header * Fixed: Vim keys menu lists selection * Fixed: Stall when clearing input queue on exit and queue is >1 * Fixed: Inconsistent behaviour of "q" key in the menus ## v1.0.22 * Fixed: Bad values for disks and network on 32-bit ## v1.0.21 * Fixed: Removed extra spaces in cpu name * Added: / as alternative bind for filter * Fixed: Security issue when running with SUID bit set ## v1.0.20 * Added: Improved cpu sensor detection for Ryzen Mobile, by @adnanpri * Changed: Updated makefile * Changed: Regex for Fx::uncolor() changed to string search and replace * Changed: Removed all use of regex with dedicated string functions ## v1.0.19 * Fixed: Makefile now tests compiler flag compatibility ## v1.0.18 * Fixed: Makefile g++ -dumpmachine failure to get platform on some distros ## v1.0.17 * Changed: Reverted mutexes back to custom atomic bool based locks * Added: Static binaries switched to building with musl + more platforms, by @jan-guenter * Fixed: Improved battery detection, by @jan-guenter * Added: Displayed battery selectable in options menu * Fixed: Battery error if non existent battery named is entered ## v1.0.16 * Fixed: atomic_wait() and atomic_lock{} use cpu pause instructions instead of thread sleep * Fixed: Swapped from atomic bool spinlocks to mutexes to fix rare deadlock * Added: Continuous Build workflow for OSX branch, by @ShrirajHegde * Changed: Reverted thread mutex lock to atomic bool with wait and timeout * Changed: Removed unnecessary async threads in Runner thread * Added: Try to restart secondary thread in case of stall and additional error checks for ifstream in Proc::collect() * Fixed: change [k]ill to [K]ill when enabling vim keys, by @jlopezcur ## v1.0.15 * Fixed: Extra "root" partition when running in snap * Changed: Limit atomic_wait() to 1000ms to fix rare stall * Fixed: Removed unneeded lock in Runner::run() * Added: Toggle in options for enabling directional vim keys "h,j,k,l" ## v1.0.14 * Changed: Total system memory is checked at every update instead of once at start * Added: Continuous Build workflow, by @ShrirajHegde * Fixed: Uid -> User fallback to getpwuid() if failure for non static builds * Fixed: snap root disk and changed to compiler flags instead of env variables for detection * Added: Development branch for OSX, by @joske ## v1.0.13 * Changed: Graph empty symbol is now regular whitespace ## v1.0.12 * Fixed: Exception handling for faulty net download/upload speed * Fixed: Cpu percent formatting if over 10'000 ## v1.0.11 * Changed: atomic_wait to use while loop instead of wait() because of rare stall when a signal handler is triggered while waiting * Fixed: Get real / mountpoint when running inside snap * Fixed: UTF8 set LANG and LC_ALL to empty before UTF8 search and fixed empty error msg on exit before signal handler init * Changed: Init will continue with a warning if UTF-8 locale are detected and it fails to set the locale ## v1.0.10 * Added: Wait for terminal size properties to be available at start * Changed: Stop second thread before updating terminal size variables * Changed: Moved check for valid terminal dimensions to before platform init * Added: Check for empty percentage deques * Changed: Cpu temp values check for existing values * Fixed: Cpu percent cutting off above 1000 percent and added scaling with "k" prefix above 10'000 * Fixed: Crash when rapidly resizing terminal at start ## v1.0.9 * Added: ifstream check and try-catch for stod() in Tools::system_uptime() * Fixed: Freeze on cin.ignore() ## v1.0.8 * Fixed: Additional NULL checks in UTF-8 detection * Changed: Makefile: Only look for g++-11 if CXX=g++ * Fixed: Missing NULL check for ttyname * Changed: Only log tty name if known ## v1.0.7 * Fixed: Crash when opening menu at too small size * Fixed: Cores not constrained to cpu box and core numbers above 100 cut off * Fixed: Scrollbar position incorrect in small lists and selection not working when filtering ## v1.0.6 * Fixed: Check that getenv("LANG") is not NULL in UTF-8 check * Fixed: Processes not completely hidden when collapsed in tree mode * Fixed: Changed wrong filename error.log to btop.log ## v1.0.5 * Fixed: Load AVG sizing when hiding temperatures * Fixed: Sizing constraints bug on start and boxes can be toggled from size error screen * Fixed: UTF-8 check crashing if LANG was set to non existent locale ## v1.0.4 * Fixed: Use /proc/pid/statm if RSS memory from /proc/pid/stat is faulty ## v1.0.3 * Fixed: stoi 0 literal pointer to nullptr and added more clamping for gradient array access ## v1.0.2 * Fixed: ARCH detection in Makefile * Fixed: Color gradient array out of bounds, added clamp 0-100 for cpu percent values * Fixed: Menu size and preset size issues and added warnings for small terminal size * Fixed: Options menu page selection alignment ## v1.0.1 * Fixed: UTF-8 check to include UTF8 * Fixed: Added thread started check before joining in clean_quit() * Fix documentation of --utf-force in README and --help. by @purinchu ## v1.0.0 * First release for Linux aristocratos-btop-d43a485/CMakeLists.txt000066400000000000000000000221611517514752700203070ustar00rootroot00000000000000# SPDX-License-Identifier: Apache-2.0 # # CMake configuration for btop # cmake_minimum_required(VERSION 3.25) # Disable in-source builds since they would override the Makefile if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}") message(FATAL_ERROR "In-source builds are not allowed") endif() project("btop" DESCRIPTION "A monitor of resources" HOMEPAGE_URL "https://github.com/aristocratos/btop" LANGUAGES CXX ) include(CheckIPOSupported) include(CMakeDependentOption) # Make our Find.cmake files available list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") set(CMAKE_CXX_STANDARD 23) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_COLOR_DIAGNOSTICS ON) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) option(BTOP_STATIC "Link btop statically" OFF) option(BTOP_GPU "Enable GPU support" ON) cmake_dependent_option(BTOP_RSMI_STATIC "Link statically to ROCm SMI" OFF "BTOP_GPU" OFF) # Enable LTO in release builds by default if(CMAKE_BUILD_TYPE MATCHES "Rel(ease|WithDebInfo)") option(BTOP_LTO "Enable LTO" ON) else() option(BTOP_LTO "Enable LTO" OFF) endif() if(BTOP_STATIC AND NOT APPLE) # Set this before calling find_package set(CMAKE_FIND_LIBRARY_SUFFIXES ".a") endif() add_executable(btop src/main.cpp) add_library(libbtop OBJECT src/btop.cpp src/btop_cli.cpp src/btop_config.cpp src/btop_draw.cpp src/btop_input.cpp src/btop_log.cpp src/btop_menu.cpp src/btop_shared.cpp src/btop_theme.cpp src/btop_tools.cpp ) target_link_libraries(btop libbtop) if(BTOP_LTO) check_ipo_supported() set_target_properties(btop PROPERTIES INTERPROCEDURAL_OPTIMIZATION ON) set_target_properties(libbtop PROPERTIES INTERPROCEDURAL_OPTIMIZATION ON) endif() if(APPLE) target_sources(libbtop PRIVATE src/osx/btop_collect.cpp src/osx/sensors.cpp src/osx/smc.cpp) elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "MidnightBSD") target_sources(libbtop PRIVATE src/freebsd/btop_collect.cpp) elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD") target_sources(libbtop PRIVATE src/openbsd/btop_collect.cpp src/openbsd/sysctlbyname.cpp) elseif(CMAKE_SYSTEM_NAME STREQUAL "NetBSD") target_sources(libbtop PRIVATE src/netbsd/btop_collect.cpp) elseif(LINUX) target_sources(libbtop PRIVATE src/linux/btop_collect.cpp) if(BTOP_GPU) add_subdirectory(src/linux/intel_gpu_top) endif() else() message(FATAL_ERROR "${CMAKE_SYSTEM_NAME} is not supported") endif() # Generate build info execute_process( COMMAND "git" "rev-parse" "--short" "HEAD" WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" OUTPUT_VARIABLE GIT_COMMIT OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) set(CONFIGURE_COMMAND "cmake -DBTOP_STATIC=${BTOP_STATIC} -DBTOP_GPU=${BTOP_GPU}" ) get_filename_component(CXX_COMPILER_BASENAME "${CMAKE_CXX_COMPILER}" NAME) set(COMPILER "${CXX_COMPILER_BASENAME}") set(COMPILER_VERSION "${CMAKE_CXX_COMPILER_VERSION}") configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h @ONLY IMMEDIATE) set(CMAKE_INCLUDE_CURRENT_DIR ON) include(CheckCXXSourceCompiles) include(CheckCXXSymbolExists) check_cxx_source_compiles( " #include #if __cpp_lib_optional < 202110L #error \"Missing __cpp_lib_optional < 202110L\" #endif int main() { return 0; } " HAS_CXX_OPTIONAL_MONADS ) if(NOT HAS_CXX_OPTIONAL_MONADS) message(FATAL_ERROR "The compiler doesn't support std::optional::and_then") endif() check_cxx_symbol_exists("__cpp_lib_expected" "version" HAS_CXX_EXPECTED) if(NOT HAS_CXX_EXPECTED) message(FATAL_ERROR "The compiler doesn't support std::expected") endif() check_cxx_symbol_exists("__cpp_lib_ranges" "version" HAS_CXX_RANGES) if(NOT HAS_CXX_RANGES) message(FATAL_ERROR "The compiler doesn't support std::ranges") endif() check_cxx_symbol_exists("__cpp_lib_ranges_to_container" "version" HAS_CXX_RANGES_TO_CONTAINER) if(NOT HAS_CXX_RANGES_TO_CONTAINER) message(FATAL_ERROR "The compiler doesn't support std::ranges::to") endif() check_cxx_symbol_exists("__cpp_lib_string_contains" "version" HAS_CXX_STRING_CONTAINS) if(NOT HAS_CXX_STRING_CONTAINS) message(FATAL_ERROR "The compiler doesn't support std::string::contains") endif() target_compile_options(libbtop PUBLIC -Wall -Wextra -Wpedantic) include(CheckCXXCompilerFlag) if(NOT APPLE) target_compile_options(libbtop PUBLIC -fstack-clash-protection) endif() check_cxx_compiler_flag(-fstack-protector HAS_FSTACK_PROTECTOR) if(HAS_FSTACK_PROTECTOR) target_compile_options(libbtop PUBLIC -fstack-protector) endif() check_cxx_compiler_flag(-fcf-protection HAS_FCF_PROTECTION) if(HAS_FCF_PROTECTION) target_compile_options(libbtop PUBLIC -fcf-protection) endif() target_compile_definitions(libbtop PUBLIC FMT_HEADER_ONLY _FILE_OFFSET_BITS=64 $<$:_GLIBCXX_ASSERTIONS _LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG> ) target_include_directories(libbtop SYSTEM PUBLIC include) # Enable pthreads set(THREADS_PREFER_PTHREAD_FLAG ON) find_package(Threads REQUIRED) target_link_libraries(libbtop Threads::Threads) # Enable GPU support if(LINUX AND BTOP_GPU) target_compile_definitions(libbtop PUBLIC GPU_SUPPORT) if(BTOP_RSMI_STATIC) # ROCm doesn't properly add it's folders to the module path if `CMAKE_MODULE_PATH` is already # set # We could also manually append ROCm's path here set(_CMAKE_MODULE_PATH CMAKE_MODULE_PATH) unset(CMAKE_MODULE_PATH) # NOTE: This might be problematic in the future if other sub projects depend on this or if # btop starts producing libraries # Build a static ROCm library set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE) add_subdirectory(lib/rocm_smi_lib EXCLUDE_FROM_ALL) add_library(ROCm INTERFACE) # Export ROCm's properties to a target target_compile_definitions(ROCm INTERFACE RSMI_STATIC) target_include_directories(ROCm INTERFACE lib/rocm_smi_lib/include) target_link_libraries(ROCm INTERFACE rocm_smi64) set(CMAKE_MODULE_PATH _CMAKE_MODULE_PATH) target_link_libraries(libbtop ROCm) endif() if(NOT BTOP_STATIC) target_link_libraries(libbtop ${CMAKE_DL_LIBS}) endif() endif() if(BTOP_STATIC) target_compile_definitions(libbtop PUBLIC STATIC_BUILD) target_link_options(libbtop PUBLIC -static LINKER:--fatal-warnings) endif() # Enable GPU support on Apple Silicon if(APPLE AND BTOP_GPU) target_compile_definitions(libbtop PUBLIC GPU_SUPPORT) endif() # Other platform dependent flags if(APPLE) target_link_libraries(libbtop $ $ ) if(BTOP_GPU) find_library(IOREPORT_LIB IOReport) if(IOREPORT_LIB) target_link_libraries(libbtop ${IOREPORT_LIB}) endif() endif() elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "MidnightBSD") # Avoid version mismatch for libstdc++ when a specific version of GCC is installed and not the # default one since all use the default ones RPATH if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") string(REGEX MATCH "^[0-9]+" GCC_VERSION_MAJOR "${CMAKE_CXX_COMPILER_VERSION}") set_target_properties(btop PROPERTIES INSTALL_RPATH "/usr/local/lib/gcc${GCC_VERSION_MAJOR}" BUILD_WITH_INSTALL_RPATH TRUE ) # The gcc compiler wrapper doesn't add '--eh-frame-hdr' on FreeBSD with static builds # https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=278551 if(BTOP_STATIC) target_link_options(libbtop PUBLIC LINKER:--eh-frame-hdr) endif() endif() find_package(devstat REQUIRED) find_package(kvm REQUIRED) target_link_libraries(libbtop devstat::devstat kvm::kvm) if(BTOP_STATIC) find_package(elf REQUIRED) target_link_libraries(libbtop elf::elf) endif() elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD") if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") target_compile_options(libbtop PUBLIC -static-libstdc++) endif() find_package(kvm REQUIRED) target_link_libraries(libbtop kvm::kvm) elseif(CMAKE_SYSTEM_NAME STREQUAL "NetBSD") if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") target_compile_options(libbtop PUBLIC -static-libstdc++) endif() find_package(kvm REQUIRED) find_package(proplib REQUIRED) target_link_libraries(libbtop kvm::kvm proplib::proplib) endif() # Check if lowdown is installed find_program(LOWDOWN_EXECUTABLE lowdown) if(LOWDOWN_EXECUTABLE) # Custom target to compile Markdown to man page using lowdown add_custom_command( OUTPUT btop.1 COMMAND lowdown -s -T man -o btop.1 ${CMAKE_CURRENT_SOURCE_DIR}/manpage.md DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/manpage.md VERBATIM ) add_custom_target(generate_manpage ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/btop.1) # Install the man page install(FILES "${CMAKE_CURRENT_BINARY_DIR}/btop.1" DESTINATION "share/man/man1") else() message(STATUS "Command 'lowdown' not found: skipping generating man page btop.1") endif() install(TARGETS btop RUNTIME) install(FILES "btop.desktop" DESTINATION "share/applications") install(FILES "Img/icon.png" DESTINATION "share/icons/hicolor/48x48/apps" RENAME "btop.png") install(FILES "Img/icon.svg" DESTINATION "share/icons/hicolor/scalable/apps" RENAME "btop.svg") install(DIRECTORY "themes" DESTINATION "share/btop") include(CTest) if(BUILD_TESTING) add_subdirectory(tests) endif() aristocratos-btop-d43a485/CODE_OF_CONDUCT.md000066400000000000000000000210721517514752700203460ustar00rootroot00000000000000 # Contributor Covenant 3.0 ## Our Pledge We pledge to make our community welcoming, safe, and equitable for all. We are committed to fostering an environment that respects and promotes the dignity, rights, and contributions of all individuals, regardless of characteristics including race, ethnicity, caste, color, age, physical characteristics, neurodiversity, disability, sex or gender, gender identity or expression, sexual orientation, language, philosophy or religion, national or social origin, socio-economic position, level of education, or other status. The same privileges of participation are extended to everyone who participates in good faith and in accordance with this Covenant. ## Encouraged Behaviors While acknowledging differences in social norms, we all strive to meet our community's expectations for positive behavior. We also understand that our words and actions may be interpreted differently than we intend based on culture, background, or native language. With these considerations in mind, we agree to behave mindfully toward each other and act in ways that center our shared values, including: 1. Respecting the **purpose of our community**, our activities, and our ways of gathering. 2. Engaging **kindly and honestly** with others. 3. Respecting **different viewpoints** and experiences. 4. **Taking responsibility** for our actions and contributions. 5. Gracefully giving and accepting **constructive feedback**. 6. Committing to **repairing harm** when it occurs. 7. Behaving in other ways that promote and sustain the **well-being of our community**. ## Restricted Behaviors We agree to restrict the following behaviors in our community. Instances, threats, and promotion of these behaviors are violations of this Code of Conduct. 1. **Harassment.** Violating explicitly expressed boundaries or engaging in unnecessary personal attention after any clear request to stop. 2. **Character attacks.** Making insulting, demeaning, or pejorative comments directed at a community member or group of people. 3. **Stereotyping or discrimination.** Characterizing anyoneโ€™s personality or behavior on the basis of immutable identities or traits. 4. **Sexualization.** Behaving in a way that would generally be considered inappropriately intimate in the context or purpose of the community. 5. **Violating confidentiality**. Sharing or acting on someone's personal or private information without their permission. 6. **Endangerment.** Causing, encouraging, or threatening violence or other harm toward any person or group. 7. Behaving in other ways that **threaten the well-being** of our community. ### Other Restrictions 1. **Misleading identity.** Impersonating someone else for any reason, or pretending to be someone else to evade enforcement actions. 2. **Failing to credit sources.** Not properly crediting the sources of content you contribute. 3. **Promotional materials**. Sharing marketing or other commercial content in a way that is outside the norms of the community. 4. **Irresponsible communication.** Failing to responsibly present content which includes, links or describes any other restricted behaviors. ## Reporting an Issue Tensions can occur between community members even when they are trying their best to collaborate. Not every conflict represents a code of conduct violation, and this Code of Conduct reinforces encouraged behaviors and norms that can help avoid conflicts and minimize harm. When an incident does occur, it is important to report it promptly. To report a possible violation, **[NOTE: describe your means of reporting here.]** Community Moderators take reports of violations seriously and will make every effort to respond in a timely manner. They will investigate all reports of code of conduct violations, reviewing messages, logs, and recordings, or interviewing witnesses and other participants. Community Moderators will keep investigation and enforcement actions as transparent as possible while prioritizing safety and confidentiality. In order to honor these values, enforcement actions are carried out in private with the involved parties, but communicating to the whole community may be part of a mutually agreed upon resolution. ## Addressing and Repairing Harm **[NOTE: The remedies and repairs outlined below are suggestions based on best practices in code of conduct enforcement. If your community has its own established enforcement process, be sure to edit this section to describe your own policies.]** If an investigation by the Community Moderators finds that this Code of Conduct has been violated, the following enforcement ladder may be used to determine how best to repair harm, based on the incident's impact on the individuals involved and the community as a whole. Depending on the severity of a violation, lower rungs on the ladder may be skipped. 1) Warning 1) Event: A violation involving a single incident or series of incidents. 2) Consequence: A private, written warning from the Community Moderators. 3) Repair: Examples of repair include a private written apology, acknowledgement of responsibility, and seeking clarification on expectations. 2) Temporarily Limited Activities 1) Event: A repeated incidence of a violation that previously resulted in a warning, or the first incidence of a more serious violation. 2) Consequence: A private, written warning with a time-limited cooldown period designed to underscore the seriousness of the situation and give the community members involved time to process the incident. The cooldown period may be limited to particular communication channels or interactions with particular community members. 3) Repair: Examples of repair may include making an apology, using the cooldown period to reflect on actions and impact, and being thoughtful about re-entering community spaces after the period is over. 3) Temporary Suspension 1) Event: A pattern of repeated violation which the Community Moderators have tried to address with warnings, or a single serious violation. 2) Consequence: A private written warning with conditions for return from suspension. In general, temporary suspensions give the person being suspended time to reflect upon their behavior and possible corrective actions. 3) Repair: Examples of repair include respecting the spirit of the suspension, meeting the specified conditions for return, and being thoughtful about how to reintegrate with the community when the suspension is lifted. 4) Permanent Ban 1) Event: A pattern of repeated code of conduct violations that other steps on the ladder have failed to resolve, or a violation so serious that the Community Moderators determine there is no way to keep the community safe with this person as a member. 2) Consequence: Access to all community spaces, tools, and communication channels is removed. In general, permanent bans should be rarely used, should have strong reasoning behind them, and should only be resorted to if working through other remedies has failed to change the behavior. 3) Repair: There is no possible repair in cases of this severity. This enforcement ladder is intended as a guideline. It does not limit the ability of Community Managers to use their discretion and judgment, in keeping with the best interests of our community. ## Scope This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public or other spaces. Examples of representing our community include using an official email address, posting via an official social media account, or acting as an appointed representative at an online or offline event. ## Attribution This Code of Conduct is adapted from the Contributor Covenant, version 3.0, permanently available at [https://www.contributor-covenant.org/version/3/0/](https://www.contributor-covenant.org/version/3/0/). Contributor Covenant is stewarded by the Organization for Ethical Source and licensed under CC BY-SA 4.0. To view a copy of this license, visit [https://creativecommons.org/licenses/by-sa/4.0/](https://creativecommons.org/licenses/by-sa/4.0/) For answers to common questions about Contributor Covenant, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq). Translations are provided at [https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations). Additional enforcement and community guideline resources can be found at [https://www.contributor-covenant.org/resources](https://www.contributor-covenant.org/resources). The enforcement ladder was inspired by the work of [Mozillaโ€™s code of conduct team](https://github.com/mozilla/inclusion). aristocratos-btop-d43a485/CONTRIBUTING.md000066400000000000000000000053001517514752700177740ustar00rootroot00000000000000# Contributing guidelines ## When submitting pull requests * Explain your thinking in why a change or addition is needed. * Is it a requested change or feature? * If not, open a feature request to get feedback before making a pull request. * Split up multiple unrelated changes in multiple pull requests. * If it's a fix for a unreported bug, make a bug report and link the pull request. * Purely cosmetic changes won't be accepted without a very good explanation of its value. ## AI generated code * Submissions where any of the code is AI generated must be marked with [AI generated]. (When code is generated by prompting either directly to an LLM or through "comment prompting".) * Not needed when AI suggestions is used in "autocomplete" mode only for boilerplate or other repetitive code. * Failure to disclose the use of AI in a PR will result in a closed PR and deliberately trying to obfuscate the use of AI will result in your account getting blocked from contributing again. * "Vibe coded" PR's where it seems like the author doesn't understand the generated code will be dismissed. ## Formatting ### Follow the current syntax design * Indent type: Tabs * Tab size: 4 * Alternative operators `and`, `or` and `not`. * Opening curly braces `{` at the end of the same line as the statement/condition. ## General guidelines * Don't force a programming style. Use object oriented, functional, data oriented, etc., where it's suitable. * Use [RAII](https://en.cppreference.com/w/cpp/language/raii). * Make use of the standard algorithms library, watch [C++ Seasoning](https://www.youtube.com/watch?v=W2tWOdzgXHA) and [105 STL Algorithms](https://www.youtube.com/watch?v=bFSnXNIsK4A) for inspiration. * Use the included `fmt` library for string formatting, see issue [#535](https://github.com/aristocratos/btop/issues/535) for more info and examples. * All new code should prefer `fmt::format` or `fmt::format_to` instead of manually concatenating strings for better performance. * Do not add includes if the same functionality can be achieved using the already included libraries. * Use descriptive names for variables. * Use comments if not very obvious what your code is doing. * Add comments as labels for what's currently happening in bigger sections of code for better readability. * Avoid writing to disk. * If using the logger functions, be sensible, only call it if something of importance has changed. * Benchmark your code and look for alternatives if they cause a noticeable negative impact. For questions open a new discussion thread or send a mail to jakob@qvantnet.com For proposing changes to this document create a [new issue](https://github.com/aristocratos/btop/issues/new/choose). aristocratos-btop-d43a485/Img/000077500000000000000000000000001517514752700162615ustar00rootroot00000000000000aristocratos-btop-d43a485/Img/alt.png000066400000000000000000004626661517514752700175730ustar00rootroot00000000000000‰PNG  IHDR’†t sBITแOเtEXtSoftwaremate-screenshotศ–๐J IDATxœ์y<”ภฯŒฦc'K–’Rฺะ"Jฉดh/)ฉ_ชทฏํคT’JQ)ํ%ฉxURฺ’d์๛2ศ2dŸ1~ ฯŒ”–๛ฬ็œsฯนฯ}๎น๗Yq$ @ ‚๐}ํ@ ๘m@๋@ ม)<กฏ}@ zผŒถฉูQล‰นUŒพv† }๋็๏าJˆพ๕@ฐขืฎ?๕ฃ+Jจ1vร[Kค'~—[”“•๘โฦ6]qึ’$ีวฝKหฯH ๗g(หรRง0๛เƒศฤ‚โผ”ะG(Xฺไ”QvŸจ%ฉ.บ6(†–PหGkWุ_E๊kv‚ื๑}็=๖^~ 6l˜ ถคฦECp‘gถ8sฦfืญB’โ9ุ’"u๑7<ฯr9็๐$ถšฉๅTตsจแกว)…ฑ>๊€ษ.นิˆฝรxๆ฿ข–Pฉ้ฎ“$&X]“Cษฮˆ p3J‚ถๅใยYว‚R)q๗๚SSะ๏ iRžโŠ}ผ0๐–ขeฅโฺS$ ]ซkobr(ู้Qว— โะwฯ-กF๎™er6<37?๊โREพ๏ต๐ฬ†๕พฉŸ//ำ_(#ๅัUPด|C-ก–ฆฦผ}qs}๋iำ–}4cย.คยฌคภmcHภ;|อ๙เคŒขข๔ฤ7—7h ฐ๏.uP‘ฅŠ๋๎ `๛Iฯzํํใ ถผฝf!7H’ดnหฎ.PX›$;ผฐ‚vํ@T_แ๚,>ญคข„J-.//ก๚™ rt,”ิ฿z;์S>%#)โว69๔ผี/ yฒƒคยฬอ#๘X๕œโœC1)Jส{๛qmšฝtt๔ E๕1๛*ำ>3jŠ›ึฬhVรV˜,† Nมฮ†š#๊ใไ|มำ๎ิ“ฏ  ฏ7;™rnSS’(คvrพเฑm™‘ม8ฃ#‘  Qฉีะœแ๋๛_`\9@EyE369—์่Bฺฝ฿}ฆg%_iคD`_……Zฆ‘bvฒซ๒ภX—ิืง,๖ Oฮฯ๗ฒPgุมฃ2๗ฤฃˆŒยœOO/Qๅr๎ษ3\hฺ[นตล k?หฬุศK๘๎t๛ทk˜œOทฐ!šKYV*ถฆ^q–๓รˆŒผ๔ไฐkVcษLQ้๕๗ =ฬ็žzžZ๑แโ"yฆฃJฦ'#ณ(Yi;๕บwNƒoธ ๎ใ&W„„ฟF|†ไ…ฉ kใ$‡ซwกkยƒ=Oฦคๅ๊‡’ฎศผ$…uษาZcpPWKะ๔•5ฝ-ขฌยโDA7่|žynๆhณ๓๑๕฿ๆ\3ฅ3q(๐๖Ÿฆ?€Aฅ~ล–”——‡ๆ‚JM๗ศง%๒๓ฐ%‹_ป๎w…l๎ตธิmฑ๑กhตs yึๆ•‚‘aY%#;๋ฉ<|o‡๕แภFฬE๋ญึึป๏$ ฒ›ื?ใ๊มcO*‡›ป_ฆูข.>ืยจ๔พoLำ€i๛ฌ …หJฟด๒๗š ไb๙ซ๒iฺaoปyBvšZœษฒึใ‚ๅ Vy…Zi^พ xีy›—จ่S(m่o์ฐก?ฅRtขแ8ฒืวฌทZ{D4tชM|แŽ5„ื>ัeuทm6"‚ฬJ—ใ EใฮxRฉa|๔ไZe๛ตK\มฃๆ(,AkˆUS ฌ์mไ์$tfแ‹K_ุW ๑Š `ืN˜ถำuลจยKs'›]Iใj:zใƒ:เฐ้0ม้ํปถkฆhิ!‹M๖Wฃ๚าGKB6eฃ˜–Ž—7ุm=ƒˆC็๒\ฏว{f‰๛)u-…9:pฟิ*RNhvš๊SผEฮ_sN‘w์๓˜abœƒ™น***ไF๊(“ล4u4$$ฤฑ“)็6ลลฤxิฬoวeD?8ฟgฒdjYN฿ไ/fœๅฝดฬc้\ว(nไ\ฒ74ข[ศญ9jำtažฦ ฑ E(L# Œœว RSI|…)๘์ภ–ƒ|ฐ™นะ™™j๓ชฺfฤ d'ืQ‘[tU^๕bศ‰‹„นฉœg่qฑAขqvิL*Q๕จ˜&ห4มๅtซด%็Drฯ‰ไ^^QS“_“ ฒิู];bใจC ŽีZ^ฺ2บUš_WOภcพบฦ–ค้VKU@d‰“ซf่Fme)๛)ฆ—wNเnz“เzZf๙[ฑAอตo๔ hDศฃอ๑ลatผ8k~vF;ฮ?™t˜๐`ฮ“Y#.จณ๒ฒ|ZVx€๒sลห3……fD๔Ÿ{@@Lˆซ(Y๐#Gr’โ ๗็๑n.W( ?z์~5ถ//0่M$ฒคx? ั™ฌ)zธ…๙ๆใ‘Šึ—ฯฌRํ•ิื็Nฒ฿๚\€€‚‚(}๐น๑0ถ 9็อ ฏ7๎ฝ/Pญ% <ฮํ๒|8e-1ฆzy€“๕ฑ๓‡n~เ““ํ—|šŠ|ช3b› ๊M๕็ี)๏›TGk‰@y๐=Ÿ7//๚Gaุxmม๙โGmOu H่ืฏ@C˜ฯ™ศhz{ห5<€H ึ$=พแuใezSงฺ*9ฎ?ไๆpAR’ ึF๓—nr๑๔8๎—0@Q{ฟณq‰ ˆ†"c q๎๑Yภฺฯ^Gล‘Œฃ%ึ~0+MbU;=้ี๓๚ฏEู™9_๊„ว,7/๙สœํsิt˜ษข‚"5 9›ญ<วี ๑ำhxlํฯ‡ฅฅษุ=DYc˜”?9{ุำ๓่ธ–BฎนโK๎๕๛Q‘pษศ~ำN๐ๆญ(บทฃAAlx[B๎ุ็1รฤ.zศ‡›'Cส…fธฤd81_€วษT‡๐๙X8ผj<๗ {รu๎๓uŽม2/yฌิ{ง%ฟx<ž—,#-‚ซHz๎นyท_ @}P]ฑ.ฟ/€Iq@}Vx‹p๊ วk๑ิฆฺธะศลR 2lXaฯปขบ†ฒ่‹[ึ{%q5[dคY฿_Z้๙๕ฃ €ะešเrบล }WพKj๎WUMอขง~ัU ๅ฿‰‘ฃZOึื…๓IฉaPcยฃ๋€ฤ”ค<๓๛XZ_›๔0”˜f็GูกxDZ*#yMัญูษ ํN}ญ‹X]fUU@Tไa๗™ตŽ๓O&&<\ฮ“+kรืUF๏ฏ.ภKถิ๘นๆ์BŸต5ŒEโณท๗ฦ•โ๏^พD ๐Lงฉ>X‰ท๋ปp=๎ฒ5<ฬ๖IภQผ”?ว]็/=๘\ษโ๊(4าh€'ิ_ฉไาAฬึิfผ ฬ€ภšqฬึ/Uฟโ”ฤFุjใRNœoขัt: ๐xG F‡VI>พ–>ั FSuVตอtัmxyyฤ–_หœO>AjŽ466@มeใธ†jๅํีKoค1šš่€รแ It๔ ญำ‹“ยต8–ษฅๆF;๐้œใh ฟาุ›gเปฎฝ9๋Hyฒyะn …@ฯฎ‹\S…y$โ+2 j7;'dิQsC=vyFทn้~ำ5๙๗ถEป/Mฺ\ŸยูยlT๋™ktt๔!๚g—าjR.ฦ„H$ะ้฿ฏyูเี%ฯนศ_g๗ตI๚๛๗qา๊๋32๓฿†ลt๔ก™+นBิบ/;วจzZ•_Zฑฯs&ปˆบ)็็พ?PYผก EqwฺไQอะฬ6™๒‰ห‹ำ‹ +ูไฬๆfHน๏y๗u2Ž๏ีžKีี• dษสผฉN๎Wฆ@อคญFf[4ุ๓h2ง69ฏ-h่uฺuฐผK[::ฟฐ‘งeพ๓wฟ฿7ต ฐ.;CDq,ไJ‘$_ิไทž.gฮb€ม`0g1D"‘:๛šิพRiด ๖6~1qžะฬ:M`ยzบีก๖–yTO‰J฿/ป’`‰Dโ€u>๏ำ€(X“ลืก‚ผ๓ fถJา้-ญ@งัˆฤvkNŽโf๐๐แ๐8€๖ฉตฉ™ม ุ ชLIฬ๙็๗0เnžLof0š ใ|‡ร๓šปฺํแ๗ปA|ฌ๖0Qr?Ÿ{ฯชชุŒี7vล†Q‚%ทอด6>๋ยVAAเdee( ''“Ÿ)HZt9ืsVด–ัน๋jฏ0้<^ณrž‡‡ญ{  ฉฉ O$๒0›ซฑฑ@ˆHh“d๎o๊,k๓ฐฺธ”ร0;ต|s[/lll(๗฿ช็ูR@-^ฃฑฆ๒ป๎$ใ๎ซFผุ:saะš{Oถ~ปˆฝ฿ูธฤQฃ%žjdCfอฟณก7ฏ:tU;#ฉๆี”šท2Dู"“ ŒทHXVƒ5๎่ZนY1œีๅ/u๑œ#๋ฆ๋ -ู๛฿ฉทwส 7ืษฃฦ๖็]3๕๙6 Gว/H7'm €H$ะ:M๏๒€mq๘qa €‹ฬj€๔๖ป์ ยย‚ำฆ่ŒีืaSท3W}cยสข๖*lย์4\ดƒ๓ิ๓ ฑฑkญŒฉ~ฒๅD"nคจ@๎—RปŽE2ๅŸv*guZข๓T‰ฌl–W”๐๐๐žhhh`๎Hpพe%ศฑM๎$ู^คCซŽฝพู๘:๐’ี๔,ฯ8ฑ*ิ๘b=๛IำC^YIพ‚ภ26ษˆFง3{ ๐IŠใ+Kชฺๅ^๖›$0๖Œิ๓rฟuD ฉE[™vš››œคคd;Uฎง[฿ื.ฐLL_ฃ๖้บ๚6žแฑxา‰๏ฦ˜ฎร$่ฆๅ]ล9;‹_๏VFmmuฤ๊็hฦw็็xดๆฎ“>ๆ๒„‡ใy2k๘F ๊#ำlฮu+ pพž๎ ฟ฿ญิ*ANlด8(๊š› Vฦ?z †QหqรซVR“Jซhh(iขcทR}](M6_JอilnjจศŽ ๙˜yฯ2vำษฺูฯ,ร๋ฯ—}น ,ฅ่MU%%่6่฿ฬR˜—ว€‰ณทงฮ‘6ชE’ซฃƒ–~ฑ^ำ•ท๔HyBb3ิ|ไฦฉชชš็ฏ>˜,2์ผ~่nๆโ–av.ธxVๆ ฝz)Iซฑah๓BC"ไผ ฮ9ฬdJ1ฆ?ฦศก|ุภยๆวะส5๓–๏["mbฤ %๏ย3!-6–f:l๊wdใ™๐5*Š9ีโฬๆซ<Ž% =Oะˆ๎€S[juฝ+Oc(ๅ…”ŠฆถำใO๊n"š"้ถฌ๎ ศLL”[e2ฮ๋xTย๒+ฯ?g|‘ใ;๔p8xD ยƒI2:8Z=พZa…”’/%Šณuiฐ>ป{กน˜nuฆฟเไฃ„T“ายvใNfbขฬ"Cีณ้0ฤยีNเส#ฑ7ฬLL”3[8๚๊้$’พฑ.-๑.—w!RSvg^s”<๑U[Š\aา…ฤeชbู=๊ˆ5์D"ๆ<™sฤ•ž็ภ[๗ฐ2pอื|v๛ฬแ๗ป๕ƒ@yEื†A}้A‡…ฬœุDKว‰U7“=_เ tkว้-Bจซ!b’ฏ^9›m=ตu๕^Z๎‡“+ท_/daำสkำ:•{ๆฏฃ฿Tš๚เะฯ๊ฑ%9žา๎tฐ~ฎพํแู E ทท๎9ห@{โh้!{`™้๎uน๏ฯๅํ]้ฬศ|ƒNSIขํ็ฃpโฺณษต๖OFณซ ๑=Œว•ฯ=xt— Ž฿\ๅั๓ค๙že„Ckฏฯ็ซ+Št๒ฟHnf๊โ;F€์ฬn3แก…Op&†`]ภI๛งƒwZž?{g๏œ๗ฏํZ %q๊5cฟ๗ฬฅVš้๑{ช5ž๔s@ i%ฆŸ_t,NNeJ4ws3O;๛ mF!็๋‡ๆ/ีุ จต„@jn*๗งพฺ_฿ ŠXต?๑9๓j…ำžS3[4iฉ'Œว>โธ้.Jc๘้็๏o๘ฯฒmKˆ5—&๛;๋๐๊‡?๑่0๛งŸQื%—7jฮ๒pลYฉู็fpwภV^๙(#=w*Oฐ๓ืn$จชช!‘:ˆฯ\ร2ฬฮร็F13ื+‡5ว%Ž˜/ฺทณž’เeณ๛Xไ1“)  $0ชlะะ๚เ็ุุ|ดs• ัq๙๚šพ$k็pำzฃฺ๑ฦkvk*OtvดฌŽmๆq,ษืฃ่>%1ŸˆปŽ๘8 ”&–'ฺoฟูz^l]ถค๐๐„ฒlTŸวœv{—%ห[™๖ยi๋Mn&ึuตQ๖b;๛MskLSโ{—lด[@Fข๐๎1EซG 8nyžnอ6Nทฐ! *‰แ™ย€ๆไEyฏ^ีg๗n๗;Ÿ๗‰ชs^ฒI`9ง๚์ถี9s1ฺFœžแฺบอ!ฯญhษต๏็ื%อึ”ฤะST‰# ฟCTฅกฉิป<ฤ…ี=,็Ÿh๚„5Oๆ> Eอ)ึิ;จ;ฟ8้ปปส8ฟๅทธ์ˆ้go:?ส๎ำk+พ‹ ิlร8ฌฯใฯ๋6œ๓ร;ุฯช}ะ๖W‘๛$oฏYเ๔ฑ๘5ถพaža#ฟฤ๛‡ั;ร๏Bท<ž_ฒน๎ห๗Iบ‡cศ/8๕ํศ๐ป€คwแ =๑ผ8เใQ9.9๐Iqะ๎N&มฤ๗ำ*๚๓:mทวOQ๑—๓่ช฿ํฦ็รLyqะTWœธ้[< ^u,oD@ ? r“๕šJฎW<๋๖โ`‚ึ=#ฦq8ูฑฏ@ zJc๒M ›}ํ@ ~Œ”ey?ไƒ๒ˆฟ_๊K>@ โ—ฆ›ฯ? m,˜;ษ!ๆ[Žข7๙ัw$‡zท|šmโrŒ/ดถmํ’๖๊˜Z์ํcnํž$ฆœGว~7T€›F๎ญฺปgณmหนJmrพ7{ั%ฤ_N‡‘]@ @ œ‚ึ@ ‚SบX?๕ฃ+Jจ1vรูŠ‘T๔.-?#){Ÿก,€„ักเิโผศ; แ้E:Rmnพษ-สหŽ ๔ฐา๏฿๒1yeะj™็์ฎ p.ูนSKจํ~INcAp™_[ษ?ว’ษu*ต$pฝิฯฉ#๖ศ}ร@r‚ีตืัY”ฌ๔˜7s ~ฮ:—G ฑ^ฝจ(;๚™‡ฉ:ณšŸH"โ7ปWB ูขZฎw35ืur8_Ÿrฯqฆย%#)โว6นึCa๐z฿TJvœ็|ษnEP๒๖มƒ€<ธw7”๔ฌื>bหฟ“ยrพลฯ…ณŽฅR2โ๎3”ฌ”ะตบ๖&&‡’ๅ|ษ ^œโœC1)Jส{๛qํ+๋aD‘สรœ๛ร$:@y„ป๛น[๏ห`ไคษขํตฯๆใZง'8ล)“•ฟฉˆฬ6™Az็ฟœึ‚Šศป๎nงํ๚fAUU๑็9"*((2™,ทแ%ต๐ส<2™ฬ y๙y?7ขŠศป๎n'ท๐-พแรb๗:ะwฯ-กF๎™er6<37?๊โREฬึา?gLุๅŸT˜•ธm ‰ีฑ๙Sร์DCiVฺ[็!…ํ?9+3P•EฉilฌHMLjVTmwbBXCo*9๕Qhq—น๘ปมฮ2ฌฎฟ‰ษกdgฤธ™ %ฯย๋ิ{†ถ ฬ<ŸCM80s มN‘m‹ŒeโChXฏ2ฯอmv>พพk๒๒๒ะ\Pฉ้๙tปD~€‚‚Bแฝ†)iจซ 5œu฿ื~฿Nส…eจŒ™4RบUซ/ว„ใˆ๒๓ @ˆL2p†จ&“ก,?ฟ "jคัˆD^6ฝXhฅy๙&เU็m^ขŠม@|แŽ5„ื>ัeuทm6"ฒ>โ๚pว5งgd•7~WF่ตีtฉฑณ'jˆึVW  ถlแ‘ิœฃรx๛$ก ๅ'‚=˜Y†dx่–ผW{R9๊6อฆฬฬ|๋/'0ํศoKMYY~ศสฮ€ฮc&6YไM–‰๑ร้๏ว๑๑๒ƒD"KŠ—ฮ,`4ะ,.z๐ธ.]t5‰ƒuQz๗฿ีŽYฬzb๖ึCWoธ๔ฉ่ƒฯ/ ๋๗ฮ–ษysร+)ษ็om”„ฯx—\6 ŸฉษะŠŠY˜’ฒXษข่‚"5ม9฿;฿vช’rำํ‰่จฺ {qŠ€r฿~๛=ๆ)๕/qฌz}–๓Pเd},T oขๅ„้rrขุ~ชŽึrฟ{>oB๛G9L›6^[๐Tผฦ0(ฟs๖ฐ็[Rฅฎอ”ฝัAz‘‰^ำK›๛ํพEฌด;~=@ๅั9_ๆี์_ำyLพ‹จ.ฟ งฆฎ-FฌญU2V’ ๙๙ฬ•าฯ‹ˆ $ั_Nyภti€„ยBจHfี๋ ๘ัASq๒ ‹ึk‰๖๋‡ม’*9ฎ?๔†๙ุucงIJ’๓ˆ๛นar@`0<‚R๒าผคฆŠ&BK๊?Kฌ์รรN฿หŠ@ล(ceกbj IDAT•ัZขPqอม#XจjขูYC-1๗ฌlเ—ํ?qโ‚๑†ูF…สBๅ๛์ ‡ฮc`}ห&ยส›˜.!~ [?๐‰ห‹ำ‹ +™—{i4ภ๊๎ฏT๒i‹ f์ฬ#^g >mต๚0๛ปลOํืู๘็๗ฆ๏ˆ?ฆผ วO]•'ฏูนืj๎!ืศ็†๎9X‚ขฃWุn6XœDจลแ0„Xำtไ฿r๛ํพ4iws}๖ g ๓ณQuลฯ›>๋~ี้ก ]ฑvพนนŒ&ภใ๑ุ~๒๒๒ˆ-ฟ–9Ÿ|‚ $$D"€No๊\[#๚! Xดl\cลฃสve”๛ทฤwlื+s_nแWุR๘+:I‡ˆ @g์ุ OžสhŒC†‚‚–+-?-"ๅ w?oจKฟuฬ+šTY2Ppูx€7ฎก†ct0 7าMMtภฑ=ๆ~ญืิDวแ๑Yฒx5yššZ”๒w™สSวJŠก6๗ญˆ^๓otอ๐๐เ5†จ(*H‰]Oฟ}฿ 3ห๐๑๑ะht ำiภวGชJอ*แำ@กhŒ™•- ™™Yร1ห&4๑cŒ`ฌ,˜;‰ฃๆ@ดฃฑ‘VH)OHoj๊โšl7ึำN…๛ฌ๎OKtžช{"˜™'++@99y€œ|๕ญ>็Fฟ\atธฮ๚ร’ฦ+Œผw˜ž๕wI๋V<ˆฟ‚ …ฒดฌ๊ฌv๕ƒ?ทTPศhjjภ‰<M$ใ๎ซFผุ:saะš{Oถ*ด™่(ษœ’<8Iษถ›ฑiษNฝฝSf่ธ๙ปN5ถ฿>๏šฉO Hุžฐึช}๊ผๅ|๔บสฺ๙xxะ2ฉร๒๓Sc#@นV=วHฆ|#ต1ฬd@ |wQ๘'D„ ตฒ@XXd!€ข–ป’`ฐษา‘ี—้ซำ฿:_TXกgaถ~ฺัฯ๊๛ึyL8จฐ0ฟYIO ๐ข|ฮ }žฒy-ืธ~ZD…ํูz'ใ๋—์ฯ๑Yt -่ขืAscMe#@Kฯุ๋มณชงำฟฺŽซซญฦ๓ ๒4€€`ํืึล(O|.k:sdม˜์I๑ง1dฐR?!ืมQ5ต]๒œ•e„ˆhอ\t: ฒฒณ`ูŒไWฎสฏY9น=<‹›ำวX6Iฦ1F0L—ฺ>nห-‚คัฃิ‡ VJ๘œษ^’อ๚AูhำฬA๘๊‘QฆV–ใ<_ๅHำŸ€GcไP>HlH ธŸfcต๙ค>”๓๏๊XซแS—O-Šบๆๆ‚•๑ža: ขgพuํะ&ใ๒ใโฉุ~fDฌ„%ZำฆฏญำฒุปHเฎต‰SJ^&ฮzœ:Gvฺจv๕4"ŽPšฒัX0h@l์2+ซ’๒ศ;ทโWฎšปโเฑ๚p1ใ™ผ&˜9 5Y:ดใ‹N™‹ๆq!zตรโอfŽฯ.,็DD ๙๙_„„คข’ข“+(คJ)๙-ู๓็ET“๙>่้ทKa8์CkสŒูมj0 ๓ฑ” }นใฐกddN3Z:;บ‚จจกŽฯ ,ถญ*1๔ตข๑lฝข[o(}็!๑๓—“ {฿ๅโก#…XY&3.ฆ ฯฒrHJ^:  &ๆ feึ ŒQศนๆBYgปฒ33ุ้๓M‚J็๙ ร&Nkปล*๑!บIMm}tL๒dั]ฎุผ\}้AGGณQผb-๖-`>CWUV_W๐๔๙Gๆ ตฆOฮf›ฝ๒”W๏:[8๚ไJห๋…UลEuŸ๎^xฉ๊๐b‡ฤรsฅ๖Ntˆ?–ฦ0๗Oว๐๋ฬ฿ฐๅŸbฉป–o`B{โh้๑ถt ้๎V+tไ .เคำ< ห๓งื]œ3c็ฃฆ1 ด$ฐ$ก๐๎1ุ2แยํฟoฉ‰็๏_ชฑlฉ+ปด+V9ผbNค aa_๊ks฿Ddt+‰I˜ฟณOวาํค›ร\i๎ๆvr฿yึฮN\ยaฟ้€๛NFณ๐ณ๙žeUฏ_u_;ฐ$ฬ็ฟศ:๘โิ5ขXPsฦd็ณฺyิำˆ8B}ƒฃƒฃ๙h^iKGGCY ุš9=ค(šุl˜,˜เตe๕‘๗4ภi-]:๐‹ŸO0ึ๋nrฏธVวmถร๓ำœวคง|MI.LMJbฃ ฟejฺgฑ้uม์`,้tฤ๔ๅŽPšjบลzี:})โฉ[ฌWYN• ง‡ไJ7[ณh‰O๔ใ๘โ๏nVชO}šง4qช*้ง;‹@๔|_ฟึrญ†™e๊‚๖ฎt,ดฦa๗<‰5ฮšณณrชbc2b#?าฒณฒXุฤJ‘˜6ฑG0–‰ั}jj๋yyปŽD๚6bZm\๊๎q๗Gz…๘Y0wบDุ Œฒ๛๔ฺŠ๏โ5ฐพvๅ‡‚Ÿ่๛hๆรแvฮผˆ~]0“T/fฎถป็'.bณตKฺซcjฑทนต{’˜np{๛Pnนตw ็6ปัถœซ๔ะ&็{s+็Y๛ทฮ๏ฟต๓} fำuiเWIข#Dฝe e2๎๛sฆฺ^D@ฐฅ7฿Š@ zNŒใpฒc_;๑ใกoV•๊k'z•?/"@ ุ‚ฎ? @ NAื๑‡เฑซๅสGuุleลง๘ฯสช"ฮต~„$็*?ยf7ด~h#@W=ไGDิ=zุJฝๅาoภoํฏบ€@ @ 8ญ@ ˆ๏ม *ส‹๖ต? >iyiพ๎ซฃ๕ขฯŸธๅvxbaqvRุMวEj$€ั‡?Qสส(ิ[ต^ญLy]Pnสต%ไ^5ฺœ๘„]>!)y้‰มžŒbSศน:ผ๚ึะฒ’B้lิ๙5W_}›Kษอ๚ไ๙ฟแ$€ฑ.ฉ%ๅe”2ๆ/๓ธ>waซcUฤuD฿ฃ๋š๙z‹ ำ๚่ƒแ1WๆKทl้ธใt]3Kสห(ฅ_r2c#ว]@LฏศZv/ฒ7ๆ๏ัOaฌKjkDโoฅ๓๘‰ ฿ภ'?dR๒๒’^^๙gd๛A•ƒtึ{ใงฬš'ฉฎ“ป˜xู้N/ย7hด่฿9๖~:–๏๒)Yiw๕goณฆใ<๖žŽษไ‰๖/?๙WGธ{๊h€่+tv]6+=4cเอYปศmฟX ข๗—Ÿฉคทkห{|ภzซ๋kjom์ฃž3’๖L:fžอฺ๊๖‘xV…œซ3‘X๎ธA(ฏ€mําๆGdฬG(า^คxไฐ™ ณ<ลiผฌธธฌธธฌธส๖ท\ีYUE\Eฤ Qฃ“fผูduฟธฅcว%:jหJHป=ี่ด.wแ(›{๑Ba~ปย฿:"่ ผยRRาาm?1A–ฦbŽŸ˜(ฌ=wPึื|ด๒ภQ dฟcx&NาY=?,Yขt[ฌ•vฦN_ื ว๏ ฅฐˆ]i๑mฤซ๓ีิ&ุ|ž~qฯ4Vๆ8oบ68‰ฝG๛ญgณ่ฆ‡ ห”วด~@๔$EE้ฌ!๙ต๕UY!—-๔อoฑ^3เg9?ŒศศKOปf5–ฬบpฌK๊๋ํS{†'็e…^^กŠo),ก–ฦ<นถ}สทe๖7ษ์p/ uๆ€)>y‡D|jfv)%cฬ็›+ธZ—O4ž“|๕THัืสtฟณwณๆhฐ*›๋›™j?ภN€าฮฝ๊ํฟœำพฒN๊ Rย!>ทโ+๊JcŸ„ไ)ซ เฦw.เผ"–ฑงh~๎คส๕U๖๏jX์ธ6h_^ฝ“Sเ๎“มe Oฝํๆ-uo?ึ๕Asฟ*ต๕W่nBฺฝ฿}ฆg%_iคิๆNvฮ™๐J๖ป›kิัห7ˆ?™ีทใRRZ~OL`%‰9~bAาัแ}=™Z฿P๚Q_~๙ํฒ–-˜้Œ=?UL–I฿ปฮึร&37ฏ+?พ้rfcKf์ธิ 'WŸ๔Z:ํK๘หH†*๋Wystญ–9ŒฝuLปถrP๋„ง๓,ˆe์ีY{+o_7ว™[ํA๋DQ๎ษซ‘๛\6ฬLๆๆฆ&ึ_฿Y๊์ฎฑqิ€!วj-/mอฒิLMˆ'ง U3์ดe*DุชI‘ษฦ;ฎO›™ ™ฉก6๏กสกmFผ0`๕มต_uีT๊žLษ95sๅญ*."“•ƒ"JรX[ฏ3+ส๖๏ฯข$ีG)‰‰ฉสฯF๐jึ‡ๆF:{฿๐]mีแฃใฤ•ื‹pbC‡ส”—ตŒืƒถฝJฯอIIŠz|~ญ&หผภ’ฮ๊ฌ*โฌAXร;ฬๆ๚ŽF๛ีg“[ฮฑฺqL“'I๛TฯU8Uฑ๎‰E!คxnXพaใญพ_ูจH-Oi{ฟ๒ตuTเSะ3wฮ๗cคฃุ๛k้sฤ@[g‚มDฝ‹v†ฉ9บป‹ฌิ;WฤqƒฐDc๗ค[G})]~ฦy่๗๙ล%yi>:/v]Oโ* –yq‡„ฑณ๋๘็›vฟ๚ €วใyษ2า"ธŠค็ž›w๛ตๆฌœ'‚’ ณ‚ยัG๓ˆ?‚๊@ท‹ษอ๕oO‹e๔"‡ใืีj<9Ksธ๎ๆฃ]LฅXง3,zaิ2]\ว7ฑๅ?Vร&••ฟ&'ณ:“๔"ๆwจ‰n2n‹๖‡wใF) 8=็ฮก3ฏา‹ฒŸพcจจH2 ;ฯ‚ุฦžšš"ซคฬ๙ ด~@๔ นฯถฯ3|โ–ะA{}Meี‰Dโ€u>๏"#฿EFTCร๑ฑ*€ๆๆ–#Žม`ˆ์žšj/‰วใ€‘yไ้ะธo.Mˆๆยe8๕ แซJ%ญˆDbcC‹B&ิไว>~oณุ๋ฉ“&๎ูซๆฝ๗bv็๊:จƒ๐”cฏCf‘โฎZ่Žž้\ะXQ—››—››๙ลล{qร†pฆ:fE7K/uอฑ Y@ฺส็รใไฅฅ๚หŽ:.๎~o›:Wa๒็Eฤ%’sOs฿า>ธš๙ฅ-9_$ง'‡vZฌึzdา้tๆMt:๓A๊x์๚ภfฅˆัœไq๊Y@กืฉ;ฝ๒๐asssำให๋j๒^]ผ—ชฅ=œm:ร วใ'~ฌษโ Ÿปฉญณึ0‘””,ฏจเศัส&dQ9๕ี‹ผ<๕ฮYฮco?&ทMx:ฯ‚ุฦX^^+))มต—( ๚ <๓ะhฎษr:๑ˆGMUฅั้‹'hkOะึึ:p๑ฅV…ํ!‰4Z#–=Vศ™9M}j <\SKwโ<[฿t:w•๒ศศ๔c##+[XPภข‰ˆš‘ษ"ฝ์ิ‡L•ฐ๙Y•Z’rl‚€ฉ5ผ๕ลTิ๙งณฆpŸม๒}c‹ZรVXโqw๓ˆ–ฺฦŽมTวฌˆ‰๐ใUฆสญ/„c;๔ิ๓kซท]ตมัๅš๋ _ผIํ ๕ขศฟตำํหtง๛ 9้ฑwื4_y$ฒ`ŒSR •ฐNj๐%T*๓ฦTŸป๓ๆ๙œŸ•๊ฟ’mHBซB O>๘$ฝ 9ุA๊๚๊c๏›กๅลิ€uR๛ฃKจิ็VŠ,\สบ}4eล‡ขยาายฒ๒‚X฿ญ:‚„T๓`็ฦทฃ\B“ฃm%]u"–มช ,->—ZžŸีภN%ีq8œ€‰/๕ปtฎฬจ ธ๓4ฅs{ ฺ๖*=7'%)๊๑๙ตšYG.ฝ๛ €#Šk้iVลฦ•ฒฎ็หซ “ ๚ซ่fฝ a^ ŠฐU“"“/vผHu๙?Jญœ4ŸะแN6†-kฒฮ-/ทๆจMำ…yƒฦ.<ก0iLป5#ึ๏!ฯฒ%ฃนoฮžihฆfฦฤฦคu๗#@ ˆ_๊@ท‹ษอ๕oO‹epงญชฉIyๆ๗ฑดพ6/่a(0Mifyฺญcท“ซu ๏ขฺnO๑ฐ|รฦน[}ฟ๖b?‰สส_““หบ‹9b ญ3ม`ขŒE;ริ]7 eƒˆ๙jEAข›Œขแ4ึpyฏ^ M1›7น๒๕๋Z๖r๎:๓*ฝ(๛iเ;†ŠŠ$ณฐsหใ๑x^ฒŒดฎ"้น็ๆ~฿-CRSSd•”yป ซ^A”Q‘จ+หกTฑบ_ @ ˆ?๖/๕๙5ถ}Fำ^เภฯ็ทvค๛ต9ษใิณM็gTxบร๕SฎD"‘No9ปLงัˆฤ–™hss3๓ƒA [ลฉษ}’ป้g#))Y^^ัฅXcEA^‹T๎ล{q5‡ไT0!฿$’-=๋ๅ‰›ณฺuSวฟx;่ฦ/วง”๓ญf[W[ห7ั้mนๅ๓.mq่่ยFž–๙ฮ฿u~฿ิฦ6ๅๅต’’…]†๖ฌฏ?TPฉbbข ๆทฃ#"œงข70!@I”๙žบžๅ๎ฺุตlht:OหํI<ึ๑ฬ:Hคัฺ์Šจ™,า๐พ"""]I),๑ธปyDห?ญSy‘a๓Mวห@3š๔ถิะอ C8D>บz/(€รพoไN…ีฑื7๋ช1ื“ึ้ซdฺK‰ˆ”——sVO;XฏโรBซ@ั์ฐ๎ํNn๋GBCุ๋6ื[@ ฟ๔จ๓ื_หํ†ffbขœแยัโ$~น้ฦบดฤฤ–7๙ˆจ้Oยeฆฯัญ‰‹-n‘V[ม็‚วร“‹„zห๓ŸGANŽ˜ŠJฟ.คสhย๚ฆฆ“e๙yIาฺ+็kฤD ซ™œ<ผv ™๐‚*F“ีณฒฒูก‡žm๎ู๕uaUI^ฒrโ@)"ญผRัะฮ†’ฒJY~n}—uu„๕๚๚`๛JงูRsฌญWจWฟ<ปแ฿›\^@ @๒|ษอซ๋Žีgทmชมล่ฌคท‡๘ฏ;า27%O>๘$ฝ 9ุA๊๚๊c๏['ฌei๑นิ๒ค๘ฌ†^r๛'R๔ม๋qฦำฏ| ำฉิ’ฯN:ฆ^TjIฎ๛จ ”ฏmƒ๒บ ”kKฺTu]3Kสห(ฅ_r2c#วต๗์7—Ÿทณ?q'Sbš•็ฑฅlF ~,#ฆJจM7T๊kOX‚S฿ๆu~JพืQืง5ฺฝฮ˜ษp!ฉณ`•Z๘๖y๋f,3์€ทส\M๛~ฤŒ„››ู ฅ=๊ยz’ี @ญฌไBX”K+G้jอrMiWXไ˜ฅ๕ม‡_Tgู฿ภrMƒ@ rx…ฅคคฅ~b‚,ฎcVy-—Ÿฉ$ัQ[V\\VลๆMk;œiณว–~?ิWํ›—็จง,ฃ8ุศ‹o–๙ข ฝ๋๊F†ง‰ฆ๒PMแg ฑ’ฤคW`+ฝAƒว˜?SvrYถ.ศ{|ภzซ๋kj;แDGmY ษcทงถัๅา๛.ึ‘wNn;เ[ |ร‡ไา8ั[0šต ษฒำฆ m›cI่Z]{“CษN๒?พd/ภ๐}๏จ…g6ฌ๗M|y™๚G)6จ€ฤซ๋obr(ูฑnfCI๚๎น%ิศ=ณLฮ†gๆๆG]\ช2< RKZH(Xพก–ไœ5d^ ผ7•’็9_’๓ มEžูrเฬ›]ท Iz‹็Hp.๛โqล๔ใ–ฒัOย*ิL.YZ๘ตทฺ๑Cšt๐ุBธ๏๕˜Kn]?8๛Rฅๅq๕o=ฎ%sก€q (Zพก–PKScพธน^ตฝhUb๗MOื๛ฉ”t;6๑g#ณ๚v\JJBห๏ใ‰i้๓(ŸŒฬขdฅEx๏ิbI-๙ฐWCvc•ZBฅพf^7•žf“FกคD๚๏1`—Mฤๆบฦf&…ฺO๘soหฌ*+kจซชnhfิW}mจ*/kะ.๑฿ํj}}I”O@žžพ& IL๘ฦŒ๛pร#บคถพ4๊สกฏsˆะ๒๙๊า˜'ืถO๎ฌC๛๒๊mผ˜œ‰;๏9ป'ฉ‘F yนณ@๔‰ ษf,™;cdrR*ฆ๖ถ›ื/dงฉล™ฬ!k=.Xฝq ฅ 6๔งTŠN4'@2lค*ทข๚ศ๗0฿\น#:/3%๑๓E[j* ๒๊GN™"†เ•Ÿ:I]\B‚…$&bโ U•ฬจ!žวƒฒ ยVMŠL6พˆ}‘‡ 1yโิธO๕y฿ล๚ $ั_Nyti€ยยB๎l#ฝ%ไm”[วFฝ}[ชฃตD <๘žฯ›—ฃ€0lผถ @C˜ฯ™ศhz{ห5<€H ชŒึ…Šว๎็vyพœฒŽ–X‹ีโGmOu H่ืฏ$…‡•ƒภธฑร?~โXzุณWฬใ‰rำํI่[ฟำ๗โุ๘ศวห z‰,)htf7’Œบ‚้ล็nƒo™,:๚žŠญ‹๘ล jฺธฎ—9sโu3™„เ“&“pl4๚อ[=_r}n†าธV๏t ิ$=พแuใezS'ั>.ศปผ^๎์‘ึใ8ฤJu ลไf€๚ทงฮลryJUS“๒ฬ๏ci}m^ะรPašา,๏v้ฬs~_Z๛5๗๕ป4Vr-คxnXพaใญพ๎ux‰…วœ‡ZL5˜>6ฤcซ/@ำK—ญ&\๛T๘ฮe`Y6เp,$1มแ˜ูCx๙อโโโ/…‘v#X;0t๏๛โ’ผ4ปฎ'q้}ื…”7ผ .ึ1ฏl.#ฝ_๒W5›ึ=ฉX๒///€ุ๒k™๓้ภ'BB‚,T๙๘h4:ะ้4เใkฝJืุุ—xใชก™๚ฎqีq2Cค'›?ผxัzฆ๘ูaำg]๙ุHฃžPwฅ’?H[ต\ทkqB\^œ^\XIc-ษ#;๓ˆืƒO[ญ>ฬ>๗n‡D๑S๛u6๙l0ฤฯBRWO‡{žค์€~ฆจYส™xื@วฮ„d0g*?ไ=zำ•zg:ฌษฟmฝ๖&Eูฤ๑ฌณฟGฑฮ๎ฝ+Rฬ7่๗บสโ‡:฿ฅdแG4coู์ž^lข*jN๒8๕lำ๙^ง๎p‘Hคำ[>aLงัุช"4zYW๓กDZ#^Dte˜šุ'™[o~'„ Mg'฿๘_Xj@Ž‡ถเeใ|fค๛lินk#ศืTS'ด6ภz|3+I,›อ-wถVyฏ”๖† ฮŸNาY{๐๙๐8ืLฉ,ทg๗ถ-ึsแฆฝปธP๘฿že&&ณงŒ:nห“R.์"ฝ /o%Kซอ;o็๓1วฆฦฦF€rญg๏พใb€ฟ๎๊šิตKKก/R”†$”•‘์ddoE‘๑ณ"พd๕•/ู[2ณ…ˆ4Ei๏q:“vื๏†ิ็ฎk—๏๋๙่๎}๏๕y฿็yŸ9l˜้0}ƒ-ธฦa-// P๘€jfฟฐห‹~(,ญ(๕๗ะ6œbjฌ/|พืD‘1uผโu๓ิJ]n'R333ค   จจ‘Qต๗/<ๆŸธ/ฑo6hrŽูืแ๚Iื๓อืง\?ณฦ†ป 7Y๗iN[กv•๛x็Œณgฬ˜=cฦWลY๗์gํ[ ฟ; † „‚wŸINจAGเฌ$๓Kpเท๒ชฏwฏ!„8สฝ๓ฯๅควน์lrPมd๒๑U?4ŸŸY{Œลb‘ศuv2{ฬq^]่<ยPO่๘รag,ฎan5D๕ฯฝ|I@@อdVŸ๎ฉฌฌ้มVณeหŠJ˜ฒ22yนนœbษฯหฏ„””$23iีƒ]šๅ๓&๊/Mปข‘๓EIมฯฟ4)G„ฺ€€9๙ีีd‹ชง‘%†}๘3๕ฦŒา*.ั[ฒmบศ-;ซว„I“"ร `ฦ[ง˜ิYF™แแ฿ˆŸGC๓HCcปฅx๔EJM0yฤโ“MI0 ๅ๒ฉฐ NuŒzt?~ฝํฺฃ;ศTหนJeAGWษ‘8ธŸๆ ‚UF3ฆะฺ่฿์o%0˜L†ข์ิœ “๑Aฎ_Yz˜OzีฟLK&@QjฐO$ €เw€zแ•$'ิ #ˆ๖›0}ฐtฟ|ิ“ll๔RฎW–ำš`ณะPu‚นฐ%งทมข#„ฬGฆ,/LkFสคจ(ลyำt/‹na\u๋[๕ด๔ ชๅX#ลธd1vrr6??Eด{72[H^Hลขnj๊โ‚ฉ?ส^{YEc๙iฯmš์Wสำฏ6sฉ:ทผ่จœ–ำ”_ye ๔›>qภืงั lผ่ฌฉS๖}5]>Sมื'€Ÿ„1‰”๙พ฿ทะV/ภ+Kkๅาก!ื=๓ฬ'ข2L๛{ชkำn€ภw: .กvถ-P}OA้หอv๒*๊|๙โ๑ฅฝ้ž๗BKˆ“–xo›๏๒$ปฯbงญ–าฑžŽ‹]>p.'*0 d{๔ dผxต6”๕% เ{iqฺ›nทกV~v™ท๖ZบฺยmลยŽฮ_}น๚ŽกฬwO>ๆ––d>๙กŒsฬ‚์o%Ÿo~ีหษg“๔ร“๗โxkิ)5๘tt๚ไFE}็’’ณAสt“QทU†‚ ใ7นน]2ธzึ)7nฃ›๋ž•บๅWฏfทhQBบ๏i้Q๎ž[ใLฯ†%G๛ํS๕Zv๐]อ3‹๎ุž2ฺ๊‡ศ๗WH๓๛‚ฤ๎O‰Qํ๙Nฬuศ˜๏ในD ๏ฆ3–ษตํฏ'5@nง4F^๔งdN๊๚Bฌผ*พ๑i\fbฤMKšำฆ i~ฦ~[ยˆำ)_^8)y-๘'ง˜„2ฯฏฒlฯธฏA'‡}Xป๎Z6T?‰๑h™ฌๆฎ0:ƒ๑าVฅ*ฒๆฎ0:#?5๖…C๗kk7ญ๖คบgAlWอ:๎~ซ้M€ำฆNแ๕๐Bผ.†ฌnbญ/G–3^ถy6ษuคษแุฦำtK[ฉŽฎยิƒใน]…:ยAชn`็นoกฮฦ;xี?ฬจฺแRo๓๛็>Wก&๊ฎฟ๐€xฒo^๖ถว:้ไ!„Bจcแกj?n.Qพูั•@!„๊๐„B!„ฏ๐B] ^…'†I๘ช<„ˆywtะŸฯ? „B!„x…๓„B!„ฏ8ฯฬg3่กŒvอชกฆ“1Zs'4!+-๕ซ฿อใ”pŠB!ิ5แ~j{โy์šฎมxy๊ฤญD๊ธug\็ศvtB!„Psเต=ํแ#$ ส–U{\ืœŠแฃ๐ฮ}„Bกฎ๗โP“”HออH๗Xl(^˜ััuB!„Bอ๓ิพุŒค๐ˆŽฎB!„j&ฮ๓6›HBอ *ฏ.+R’›J+จ์่ช „Tป<์~—ธy๛$็=ยƒ )) ls#,$ฤeyƒB!ิq>่ŸฟzึL็ eมbๆf$vข ฝ+† Ÿ Nšทฯญ๘U‘มAP๖ึ7คขฃ+…B!„š๓Qเข;z’,nถภjDz8,?๖ฏ_Bอยxฐq)ฒ“์์ๆ๖-|ubๅบซY]'„B!ิ๎Ÿ๖๖ะ\“CํV๔๛๖ึuฉkGื!„Bต^…ŽB!„โฮB!„Bผย๙B!„BˆW๘8„BˆA"*ีเ๚mฃZ˜œ็๋>ž฿Ka9—าyYqน—Nณั<งาฮไร=yฃ™ี“{5š€็า ‰S5๖s4ใm /fหช„P๓เ๙„B!„ฏp€B!„ะ๏Hข*J]‰ถ"(ง$'ุไ8@mฎวชว ฝ:ภภm z๎‹Žฎj3๒‹ŸลนŽค€แก8฿ชŸฝ>ตeiฑ—fR[1O G฿่†อฌ3BกFUงบx‡วfegควฝปณลคv Nข๊ํ๐Iษr[?A_\zร๐:Œ]“่yนดœ๏ฉIแLRไ^ƒ&o็MFVป฿'ภkฅfี…‚ฝง}๒>‰–ž๊ยŠABœv7Xํ๘%ƒ–rkทy0<GฯหฅๅV%ฮ1ตฑkRอ'ฌป'(ยน๊o๊›œGXP‡ํ|๕ๆ:ฑๆ%ว๙j'วŽ–ะ;บgGืต)ี™3{ฟํวใ้Ow9ธ๚2Z3O„Bอฅ6XGฒ‘(}lทLw6Q“W๙หšเ๛) 6๏ไƒเฝสY โKฯq^ู-=ณฑ’ฃœ๕คeznŒ3?ถธ™ี'ึฑƒOs๓ืำŒถ๛3”—žฃpวFWญทฮขท}vnš*ล)eฯๅ‡7P.NัPึบุ๋ณรWป฿HAJJAJJAJ}ฃ_ใ50?zz›5ถ๗ณซš8n6*๛๎๒!Kยง_uท’oNrœ? ๖มb๋MU3ฆ?฿c'Sทš-w๛fซๆ3IaาฟAฑด”€K๓๛ชร0rยŸ]ฺh๖๋จ‡แก8฿f3ฮลdค][า—ฟIy๖s eะ฿oำTX๕ˆม 3ี‡d๘zZyšLKŽ๑ุl"Uฏ ๔d๓s{แ!„@x๔ๆ›วWh’ธF*ศอ-+)(,cณJ ~–ไๅ–@๎—็;,g9ี฿ฏฑy[฿{ปฮง๒VƒŠ๏ฏ>I** ˆอบ้J…ช๐พC?๏Bโด'ซLpy’˜žpษึฐ9ํ฿ฦŽn๚ซ<ฟาฒ“ฃ฿ž฿l“ห ฟvYแ5็“สซ> ˜่„x\Ža”–ๅ;Wšs#—SRRœ๗~Wฯ„bfล๗ Wกฌ^ฝdyk€฿3Qฑ9yT๒‚EฦMโ–`Œใด์…ฺyจm\ฆล‡'„ฃ'jQ_b†Ž›9y ˜่ธŽฎ j;gฮผs๓cํฑืœ=๏อaดย_k๚ัโจ!KฅZœฅืK๙ื<›nŽืิฐ|จพwƒน@S๒Œ>คO•5ุEsท ReฉTSื$Ÿน฿U•พšฆู.š๕๙อCซ7ึV”ฃc๚kX<๚kฟ(พถk „๊”ฌ›!ญฑย~‚(ทX๎6kl KOŠอxc๑rบฃb(ˆxp๓ylAธd ปฝ“C—๑X~้‘ร๚ลE~.(x๙,PฬL@ษิLโ๙ำ๗lN๙Y.ว๕CV้จ๖3=Xผ๚œฝn,;X_yฺRณแดฝ!ส#sฝj‡b>sbไ‡ฟ†) ))&e€ํฅเ๘คดฏZ๕แ|IT๒ฃฟฯ Qค๔Lด ""sชย๛lx–๑้ฉฅฺ"\B`ภ๚ห›สw.<S}ๆ„ำธูp„ข1Žหฒณ"๎>ไ›=Sš ็จ}ะ๙ฅ›mu0่็WาัuAmFฯzF้อ;QฟRo๎๗uยท”็OY๊๊2\’ฦ]qพ๔‰QY้ZฆขZ็€Ms๓์ฅญM{q๗CNiqบ๗Cแฺี‘ฦ_?x#ฆU๒%๐c3 !„ะ„bธฮึ€:ub5.๑คงt้๗dษ(ำฑcฌ 8F•ฝkE้ฑw๓x(พถเŒlzzผงฯ–หั๙ฯยอL$G™ช>๗u๖นพ^ฺฺ฿ž฿ +`Uะ}#=HG๚ืwฟd2Y€*/'Nส~yfํึป๕wลำCMํgLLS $IุXฏ่m-ใต๏u]๗[หqN ns“‘Ÿๅ&๏6}WP„mชo0ิt˜ษธ้›4œ-Rๅ’Zs๋•ญBืก5zตแhุpŒใบ์qqฑ =ี8”œเ๛P๛Œ๑{]ดfูท—๏๒gฎ่่ส ถA6ดš‘๏i^๗“ษฌ๚ง’ษไงpป‰]sa‹ล"“kl4?O …R“YQAก4,ˆ{•๊๒ˆ_หะ๙๒l!ซTณ™wยา[ทๅeฌึฯซบo™oะšu#ฮฌK|ฮ h๋‰1WฤUคบ{mx;h๗๛ทD1…†o›†วข…)\wณซ|7ฤิ5‰$ิc‚‹f˜Š,๏็‰Ž# ษ>ฒฃด}<˜ำR(ีež3*€"Z”๚ฑ๖B๕วŽ๔s๖Nฝ]|ึ+U$zน๎ฺu'ฎœcถ222yy๙uุlvฅ฿•ณŸ๒˜๗๚์ํ8?}-ธ’อ1+VิซjŸY'ฎ!MZx—^žŸ™^_ฺู‘ซด๛pผฐ+j฿์[cŽ\y{สฉ„JŽep Žq\—ฝ"ฯญถ]ป๙F†`ำงนจำ๋gฑภฺTํทgฟQFฬดLน}‡x›ศOกTTpZsย{ž,‹DฎปAซ`2๙๘ช/Oโใ็gVิฟ…ฎ™UBก?HŸK†ฐŠซ‰M^<…ำmิ‚l&ณ๚T@eeฅง{๚™ŽRT]๛"“ม ว*b}ไจัH5ุฅY>oขา(๒โูwณQบFฃ Ÿ๚ฺLm็g ีืชฏฏ฿ฟ๗Œs5wk7; #.ฏต0๎ฅ:p๒ฮฯzวŽ,เvำp~~พธธx€ผ<6ภฏ๓ต;๎ FC๑Sฌไ€]มˆ๓๖ห=Z@yฆ๛ญตk–ดัป@™qง–:nธ่8ื็ซgฟน-;ฟธธH^/'Š~‡๓ิ>ศษฏฎ ฆ ถเyรจ“๘kฅ๛ีcว๎บLซsงภhซ‰_<ฝพQLน—Œ™"?n๒ฐ’ฯ‘œึpะ„D~|ผผ0<ท:ฦ™ž KŽ๖ง๊ต์เป๊˜ิ‘{ž%dฦผu’ฝผ๐`0> !„xzdๅU๑Oใ2#nZาœ6]H}<ม o b}ม ง7kbถšปย่Œิุฏญ=\แ\fœi“—Euขm็ทฆ[š‘็5_ุ๏—ช1‰`์ ‡ฆL๙3(>&์๖ฌ[ฎr;xT๚๏‹ฑu๖ำฯญ‘iyแCb”ฏK_Ÿๅ[๎ิฬฒ๊†E๖nO4ฟž•๔๙แยาร๖๎1ลO๖9~ิ=๖&1=6เดษ๛๕}ช-ไ_g๋?๖_ืIาฦMNฃaร1Žฒซ[L z=x฿huภ๛P›หrŸDuฏโจ!ุ๋ตAญ!๗กƒ๎C‡บ!โ3M^๕ฃn#๔์‹ณ๕’ฎ!Žฆ5ุซibžP}ฮf๘น:ฬ„{vๆ๗์๊วK=?ณ๊ม!„š€ๆ•ักz>ถฝฉถ“dŸ™าƒ[–๖๊ฒ๖๕)lA๚‡ทัJ~,,แv~|ํ<มุมf„žsœ~x”ไp๗zอ๓๊Jco™฿n0 4 +ขฮ/vพ^ฌŠฏWํฦ^ๅฅไ{๕šัฐภoภช‹žrˆฦMNฃaƒ1Ž๓ฒ“U็YYy|B ๗,แ๙„PหILฑ2|แ้]ู๓D!ินuŸr95%๚แาผ[๏lF๚ึ;Jƒvฬ๚G๏Wฯึ๋ฉฺฅวํ}๗dQ๚%ง›“Om„P{สฟ<ญ๏ๅ.g!„:ŸŸทญnท }๋Œฅ1WๆฟขœŸิ 5aŒ+Jธทrคำ็œf.ฮB!„๚]if๐งฦcuQ%‰ลอว๙ƒึnถjOscnžํ’‚ดyฎงเoGj3]ฅž„>wพ*!„ใz**WGใ๚mฃZ˜ผ…๙}ผ˜I-ฝ.ฎ๙ๆู่š๐5ฝ๔บ:vTฎ็’<ีŒŸฃ…š๐kถW•ะ €B!„โฮB!„๚ITEIขฃ+ัVๅ”ไZ๐>.œ? ถgไๆคฏ IDAT~<›Ag0่Œœค่ภ๋;ฦ*โm7!„P"6ฯ#7—–›Kหgะ๓riนนดคFvtฅฺYa์~Ÿฏ•šต{,$ชŸ”,๗ฑ\ำŠซnŸ\Znาแแ 1dอ•ทiดค˜`mฆr$Nฉ๕ข‰'ฦ๒OนžM๗ฑญนMm™wZ์ฅ™ิ:๙ฺซ7ฉรvพzsX๓’ใต“œทงvบ\๎nบแฺนๅ๊๛B!„ฺ™ฺ`Iฎ ฎอ‘’R’šrŽๅฌฏ %ฅ พM๛ิญ๐inพใฺcšัv&€ฺผ“B‚๗*ge๐8vฟ‘‚””‚””‚”๚F?-WฑฮXiซ๕พ&h่q็ \^+อa:๘‡4ฆฐ~…ง?m็เ๊หเ˜ฐ‰ฒ๏.ฒ$|๚Uwซf๏Œ๓ิN๒Coนฺ1ŸK`๐”๑\฿'ƒBกv#ค )ˆxp๓yloษ๛lx–๑้ฉฅฺ"Ÿ™^:ศฬL’  4jD_)iiฮฉฟฟ๖)iฺCริ8๙ีปช—3„8jศRฉg้๕ข๖šณข็ฝ๙#ŒV๘kํ_?บzNึฐๅX_yฺRณแดฝ!ส#ื™ƒฐ"๎>ไ›=S—ทซ ็จ}ฑูl2 W<„Bจ ฎณ5ไ N]ทXญฉ‰{ikำ^SZœ๎ะ_x€ถ\Ux๕ƒ7b Y%_?ฒz๕’ญŽ{fๅœ•ซ&;iฮ{ฅO5ตŸ11นอJทฉพมPำa&ใฆoะp>ดH ๒ี!‡๗C/}ฮL‰ <ิ;7H\๘“า_ฟ๊f6ฯrไ_฿b๎'Ro๎๗uยท”็OY๊๊2U [žL& PๅๅฤI๙ั/ฯฌz๗ทiH\\ฌBO5&/'๎ฦก๖E"‘ุภ๎่z „BdฌึฯSพAkึhโ#y( “Y cfE…Rฝ'สfW๓,‹ŸBฉ‰ฮˆy๊yื/ฅคลตnS222y๙๙อK[žŸ™ž––ž––๒ี็์ํHอ€•เนส@EฝwฟzึF›๋Nะ'ฟ>vซศฏ|๓)ซถๅ+™ฬฺFnุ๒้็์R‡น๘ฤ$ฤุ?CใทษBy^^ฑŒ —๓!เต+‘๒โ™™Y]„B๕YฐdซธšุไลSธ฿F]_“ษวW}y??ณขข^~ ฅขขๆ6ื0ทšnขฺน/_‚|qqqโŠ๕ณX`mชV3ํRž้~kํภ๊ตป๒าƒญfห–•0ded๒rนœ ‘ ๔๑ํH)<˜๐{#7,Œธผึยธ—๊ภษ;?๋;ฒ ๎ ำโโ"yyอTย๙j'๚ณ์6๎นบm น<์ณฬŽฎB!„โ›ช๕่ัณ๚O}มอฆํJ&EE)Žžฆ+%$ฌ8ึยธ"*๊[Uธxฏ~=„ศ๙ฑ“Œ‹"#ฒซck,?ํyฺแั้\ž?ิ dฆฆJชซw็%๊_+ฏ;vืešHี็ ฑแึึ#„„ไ๔็Oั ๛ ยฦหบฌ1’Uฟ|ฆ‚ปO\3eํ›hs&ฆัยล”{ษ)๒ใ&+๙Yศ Zžคฑุ฿๓‡๕–ฅTไeั๒+แทK@zชฉ็fค•๒ฒฌฟม๙j'า#V๎ู2ฏก๏‘๙KN'โ๕K!„PWว๐๊gz6,9ฺoŸชืฒƒ๏ช‡w๊ศ=ฯ2c:ษ^^x0ธfฬฯ”ฦศ‹”\ึaๆE้๓พC,ฦึไŒ>žภ`ะฟ๎7ฑพฦ`ะำŽ›U…็ฤ„%ๅๆ|ŽHช^ขโ'๛?๊{“˜pฺไ‹๚‹™~ฦ~[ยˆำ)_^8)y-˜หค_7Gิkx(Žฮ`๋๎๛Lหอฅๅ39j–Zรั7zฟa;V!ิaฃ]t๖]Q๕wejGื!ิy‰อ๓ศอญฺ_ข็ๅาrsiIŒไŸท*ว}ฐr_\z–๛ุชOชS]ผรcณฒ3าใูbRตท*ุ{๊ั'๏“h้้ัฏ.ฌ$ฤ97~๓ฟ๏ฤfฆฆFyŸฒ้k—ผฏฑk=/—–๓=5)มIŠMฎvSp"*lธMTาZูตaa]ไ๘๑™็ิhฯฎึ_žtทƒซ/ฃๆsุ6-)ฉ)็่SI„ชF’˜Jน”าxฤVS๒๏jปี;๎งตyIŠฅtอ๘๙ฺผ„Pณจ ึ‘ไกเฺ)ฉชฅ(g}))๕๕oZ\,๎ƒIฯq^ู-=ณๆc฿-ำMิไU2ฟ&ธม~Š(/=นGแŽฎZoEo๛์4UŠSn=ปปjพต5้๓ื`›j๛-ฌิ฿๛€(g}i™†ใฬญ7nbฝ[k ฝชT•R ณใ3ƒwhฺ„ƒqดฤศ+๚S`๘๑4:#๔ฌN%ฅe|<;K@zจํๅ7แฉด”ฤˆGn๓๚Wอซค‡ฎฝ๘:,™––๒ล๛๔"-.“-|_ฉฌ&ฅฦ'8ไƒา บ’ล>จ~_N๘ณKอฤธ&๏็ส ฟ฿ฆฉฐ๊ƒAg0|ํีศ*\†$ฆ'ฤ\ฒ5ฌžรษ-ฟŸๅn3๙Ÿ—q™‰๏ฯNWjR=ัq๏icKoยSi) ฝฯ์#ภฉห’ิน$??EyyjgบIื๔ฃ†‹C7$(ฝ ไบOกI๕Ÿ,93^yiจ”FUG ่2ขำod?])_•HsWXไ>19tฎn๚ซ<ฟาฒ“ฃ฿ž฿lSˆSAผใะ฿ K',ˆฬฏ~Pvn’าาXs;มๆิ5~ฺร๊Bทnๅœ_ฮNฐU$\—ช@ศ๊2ƒAฒ\–8Gfฒฏ‡งวƒˆผ฿BดŸz๘ํ[Bิ›๓+๕บH-xR{ฆ‚Ag0hg&‚Š แiๅีo๔ิฃ9LJŠ๙ต๏(X฿WS'ว@uแั›o_กูœฮษืำโศ“ะdZr|ˆวf)ฮี1;…วำhฑก^3•i$[ษษฎIั;‡ูฯ ฑy[฿{ปฮงึไๆ–•–ฑYฅ?ห ๒rห„ LtB<.ว0Jหr‚‡+อน‘ห!;A#ำ!๏ฏธ‡ั‹Ks>^ุป7•ํV|ํ๗IRQนi๛ูญ4P๊fผ„๕aGq๗‘KM^bžsNxฅ๊˜ํvตรŠ๒ิ%z๑ื๎|!๗ฒ\;ณ{}‡eฤ‹{>๛กesโmกั{=vNUJพฒ็๏[๊VGOฏืlJ…*#GฅTฯหจ,~.žvR<ํถB5dฉT‹ณNsฃ้Se ๖Eั-จTY*ต๊M~โณ\Ž๋‡ฌาQํgzฐx๕9{š่ยฦ&"๎S๚jฺGตีซ)๕Da๕{‡ะ˜};,ปฟlฝไ฿ค~KOฏ๎Sต^—!DR'c4•ฏเ2#ไVฅธ•ไX{ w.ย<น”ฮ3aA%ัŸ๗ส๔ึ™ลฤ]ฆศ็™ฟ–ฉ™8€สH3ฑฯ>pˆY•gฮฅธ๘ภ๚สำ–š} งํ Q1X ธ%็ q',ฐ A+ 3ฒ—ƒ2.Œม\%ฅืดา$-ะ˜?ษ>์โ7&Yฏpz7็ญ"๑–ถูไ็:gธฌฑ),=)6ใลห้๖Š$คค˜”ถ—‚ใ“าพzkี‡ใYjI)้ฒ‚ๅU๏ฮ๖Nฦ๖~๙ฅG๋๙นดiuo•yŸ‰pn๒ไI@ึ™Mปํ y๖๔Iถz่XEE‰ู๊่๗8ฉT6}นžD๗๎ ฎซ'๙—Ž;นฟํV0l‰ัz’ภิีฃB%ท]๎oIฌ™=S๘๊ฯOฺW/mํoฯw‡ฐ เม7ง์tค!, $เถgl@xPX‰H'p่?ซ~๏่ฅซ'ywo{พy'ฺใฃำ˜1F๚ขฤ@ƒ.ำื๚‘:Yฅ฿฿ํRN ๙…aป~ฆ“สสY"bษ$>โฮ๕‰(Oโา‹šดD%eq7**่AๅLap่2?ผŸ…m6LภใI๗Qฆ*/ฯณ8ล ่\d2Y€*/'NJ‰~yfํหช’9&oกฅ$ฎ%P๔œA/((Ž{+ฅซC†0๏…จ-7|hYไโoผ**ธET'*4\—Z๘\่|/;๓hrb`Lฎjwkซช**ษe๑ฯฏฤ๋๏|rH๖‡๏†GขHAyฐ`ˆแx.3ฬ๐โ5—!จkQเฤโฏ–โร๖IMd3ฏ:•ทฌžกVA1\gkศ@บn๑พ'ว“›”ธ—ถ6ํลฎ9ฅ…7kหA แ&ˆธลภ’๔๓g€o`1ฝFž{fๅœ4อยเง?›T.Ev๖ฎฅวฬ๎ๆม๒ฺ0้i]๚=Y2๊~†@ฅn๎แ#vฟ'‘Hยฦzๅำ&hฏ5ฺr๋๚~k฿Wฒ‰r$‘ชN!‰อน๏j dršx}็Hๅ๗฿œฑ๘ุ1งf[G7ฑ๒๕็ถซf๑˜๒ธ๛ญš+o|wฟฝ`…o่ท]kŽŸฑูl`ฑ*€Lฎ9ืQ^^™็-T=He…ะฯB ข‚ Lf  `m ;าcห๏หฮฉ’uชิ(Š๊2ฯภ@-JX:…๔SSวืฬ{cvu%m‰z๋g! 9็Rา&Š@ทn5G‚๊u™!sงอšQ๗$ไ—xWgฒ @›์๒่อU{fu๚ัฏฮE˜g? ขาซ็M์q?้w€S—ก?}ณyค้•ผ™ึ๋~Lฮ1๋จํ\้็์z;ป๘ฌWชH ๔rต๋N\9ืไญฑนจ-ฐ >[&3gศขฌ‚u.เฅt6?๐ ’ศ$ฮื.๑VQ€ำ–ถู*%t็::Œ๙KJˆ_D  ˜Tณ@ค3Ž_s่Ÿuyฮข๓I•ภ๕,_0ษ`ˆ|?นกT๖{Ÿ‚F๒&‘ศ‚ภว์บKŠ„:Œี๚yUWษ๓ Zณnฤ™๕o›rฐ–Bก0™ี{}ฬŠ …ใลฏt—pต้Oฉ('‹+ม›ฦ2fฤ<๕ŒiBEบกaฆแฑha ภฏนTทัึcฎ, ˆซHu๗ฺ๐vถั๎๗qlvฅ฿•ณŸ๒˜๗๚์ํ8?}- ž?ฐซ7ญ๓ๅ<`จห็ฃL.วiพ๎b๊šD๊1มํลํ 3L5ฅฝ๋ฯxS‰7๗†คผช„jvW~a—Ub)//่FแฏษdV@YYYM (NืO๙่๛1๓ืมน†๕l๕ˆลb‘~‰+˜ฬD๗#Ž$4!“6žา .ƒำ๚๙ซw”——ไy9˜8‡V}Uฮ๘zm—yใจBuฌŸEข  ‰ ภฏ0]@0ฅ,ํ#a็"ฬณฑา›ีใ8t™,o๏owอtŒไ‡„>_Uส-&‘ยˆหk-.ƒUรd๕‰+G๘[œึHr^*฿ ฟ๓พDฌ `œค฿<ยแบฃฦJOœํ๛? ฃ๒K C61พ†ฑ8L"ทŠuพต.ฑูl~~>’ŒLcW7 dฑ๕๘‚>ใงyw[|๛™ƒrM๘ ว'‹๏ฑt|]s ^ฉฟ8Lา1œbชจW|พsหXpจมA๊mvš[ฮ#ื฿„ =กๆ๋ณ`ษVqq1ˆM^oข.N(1Mธ†ฉm฿ nbใฐtู๎EC2"?1ˆ#%E†€ฤ[ง•ซ๖-5ศ Iแ 1มv๗สe{N\8ๅไ‚พMธ  Uะา3จFcฅไ๛จษ๑@RT”ฐัฝ„„๚-q๗ฐี๏Nสบน  -ฃ9ํƒ๊œž[ใLฯ†%G๛ํS๕Zv๐]MฏฟQM๓๛‚ฤ๎O‰Qํ๙Nฬuศ˜๏ในD‰๓>Xnง4F^๔งไุฎV่‘•Wล7>หLŒธiIsฺt! าฯญ‘iyแCb”ฏK_Ÿๅ[๎pœใež_eู๘Ÿทq_ƒN๛ฐvตlเฐ๗ šปย่Œิุฏญ=สuฌhจmŸ‹ลธoซ้P'ภฯVEึถAด์ทGๆšฉ๘˜อศc-)=ท๐กda€G ู—}|ฺOv+a๚๒่s6รฯี `&ณฯ๎๗Xูgฆ๔hI-ัUƒนA'—Œ:๙{,โ.C่{iุo๕ง้D‹8Oขา› ๛็†{„] b๏@๊Fct.6#๔œใ๔s๕B9ฤปฐkฤdฦeวทจ๔*์O~ผใ๒=งญbƒu)ลึฑฝชทkงจ—9็Xไ9ู๊0๘„•ั‰ฺ๓ซ2˜ุ #ฒบ‰ตพ์{ื๋7ฯ&]๒เtŒฒŽๅeq๛!ิ5„8j˜ึฬLธggNด๙ญฟQอ{ฑmRฟm5ŸŒ๎ง}ฐ๛๋ด๏ทJ…ป€บร อ!+ฃC๕"”ฦถ3ฟอห(S‘๒๔ำž๏ท0ยฝ฿{uY๛fีถสŸ\]„BmฅปยnใสพExู‹ํ่๊ „j'm6wึข:ทUๆuiุ;Pk้ะu้วอ%ส7;ชp„Bฆm๏@!„BIšyกcKJXz'|Rj'ฌ๊(]ze่*=ŽPวVพK7]ปiล้yeAณฟ€_.฿Jjช4งN<ใ=fิคั$m‘g3Rตฐxla้-Oีm๑kš:y„ืรทญ’Uk้„U๚oย๓!„B!^u–๙Y^ฮส•6&สxC7B!จ}'BกNฆ}็ๆวณtƒฮ`dfฤพปํ<^นฆ|น);OุใvศบแปŽ„ฌ.3๔'หe[ฅ ิŠdŒึœ๗ MศJK๊ws๗8ฅjไๆฌ!ฯ‘Œ๊•ถๆ๏ŠฮŽฯ z!ใ6*ดีšฮx6ƒบ}ภhืฌฺzฌzฬ`ะ฿T=ด|เถ=๗‚Eาืnฌ๒3าcx8‰ทQE[ฌ%]ฺ|๏ธด์๔ะ›+๚๑4+ ซ,บ๙๖า,ล&พ‹ฏ† Œ๑ฌนkว( –3ฒฐ\พาz้์ƒd) ?jน…~Us๓K›ฬ1กp๓JCFt๖ฺ์สิ–ไ๔gŒ๏คุใหy{jวฮ#7“ควุž98‹ZH;7_g๘hฝ ฎญ๘@ย‚PซŸxศcืt ฦหS'n%Rวญ;ใ:{x๓ฅ>=ฒc‡ำŽ+aๅูพ'w์pฺแ๎Ÿ฿x:ิ) ;Z@c์่žอJž์เjป=ฟ๗šฐ๓๐ส~ญ[ตVาฒn0uFะFหณ%ใf๎@’ฒภFŸ๓LIุp็—ัว.mิn๊ปฤปkŽ1_0ฯ@ฌฐจN ๏แ#ิr฿_ฟp๗nXฅ๘rฟอKีM‡ซงฟ{/ลFจ5”…ปฺn๕Ž๛i]ิv:`z๋ธั ป๏dƒ –VoPY†Agไฤ…๛๙\]^{๚ค2i๏ฃ๐X-6x็บษZ~'Ž–yfŠLS ‚แวำ่ŒะMฐ:””–๑๑์,้กถ—฿„งาR#นอ๋/@้;ื๕ลงxz>มศฮหฃ3๎ฮ%N. ต๘ิ่ฤo฿ขœ_ฉื ดถ2ฒ]นNื๓ณ‡/œ๛xeฏฆVพ ะ>BาฏlYตวลqอฉ1ฺˆŸจ= „C+ด'Tƒ7t‹WtVr๔“ ƒ… UึN…๖๎ส๑ใ'?Œfไ…x?~๒๘อฐŸี_RG๎|•๔ลkํ@Aเธ&^zžJKI๘่uxfโ๖ไะt2รn|ฮ %F‡Mธ1ฎ<;!19ฏท0!‘๎P\ศ”5œ8LSขธฐPค›h๕7|2ฺ“ X~ฯพไึก?Qyy…จˆP+fศหF€x๗€๗A ตQกฒา๒Fฃuภฟ›tE5ฃฑrYYYP๔สต+ฏ*๋FRำ yฯN์;sๆภอศ:_ฐ]u{ๆ๏w๗ุํHhD‚ชd?ใ๘ฯ ทG1ปwu]= ศzษไ–3@R3ะ“f๔๋—ฅ?ฟฅ$ฅ~/<วTŠ“E˜<฿หฮ|สฌ5‡ฮธพ  ชR}ุด,ภ๓฿ะLจ๔ป๎”@แง4ฑ๒] ›‘Ÿร$lO h~ข@ ง๖๘๑ุy๙^7งห๏๘edจญฒ†teม‡็-ถ๎TENฎๆJผzซb/]=qศ{{๓อซณ^€‘พ(๑๚IุtชDw~Qq‘ข/๗\ๆอ?SE ฺ“0Oยz.Q KoWดw~้f[ ?๚๙U vœ“xหฝื=อL‹QY%9IกสสJ>๊ ‰คั่๐ุย–ๅP—’šMk@oI ฑึสงแ๎๏ƒjป‹่๎Ÿ–ญั˜๐ธ#ต•ทพฎ(Iธ~๐Z q$ …ภdV6&๛ล>๋อ+H ผผ2ฯ[จzส กŸ… @E˜ฬ Ry~Rf๑Z—/‰%Œ4๗-gยj3ญ—ผฒง๎\G‡1I ๑‹ˆ7rส‡๗สw5ข๒๊ฒ"%นฉ‚‚ํษปJ Nํษ,ฏ`TV2€D"ตสาU”|ฯ)ช]๖* ึdษ9—’ฆ0APบu…ส๎ํIุtๅฏปกธk๚ึs#ถฒKS|\–ุœ๘Xภc{ฒk/ฉ@˜ง€A= —x.ฝใ ฦ๘ฝ.Zณ์หw๙3WpYL"7์–^ฅฉY9Ÿp๑rฯ6XtŸำ๎u'Qำ฿ ๆวgฑ*€LๆpLŠOa฿ื5์`๛~โษภMาูฯw.[๏•ั ;๑ๅy๗—Rฅ“ถOVK}sึณดๅ๕ญฌd’ศไ๒ไGง“ด๙*+ซWผภGIjฃ†่ฤx‡3ุ๓hฑอฆ นฟ\กv“าฏoฯ!)วๆOยƒJa^ฉ:ฆNั*ีF •—Wคgะฟ|Mj4fฬฒ๎ฯแfโฯ๏)_?%็39DbฑX ?๐๓ถ~ห˜:ฑำ+~๎b*Œ๛i-nฑห‹~”T๏ฒtฃ๐?TญึฦlY.}•NใPฟšไBSท_0ะวa4๏n‹o?sPndูyฏ|ฯ`HJJ$ƒฒอฐฎ่แBิž<ดเน=[c ๙พ&็y9˜8‡V}Sฮศฒ๘› =‰›ฎ"ฦcจ›ๅ๛™ฒๅ่‹-/Y{ํ™›— )%I––ศษษ!ฮ๓3A=‰—€ืา;ž€@ไนีถ‘E>c็๑ฯกเภ1}Iๆ—เภ/มค€ฝ –่๋๗†๛ฺฃึMBุ฿]}_ี฿หหหซv%๘๙๙H22ี๗ญ๔uธ~R๗ี\๓}%v๏g–฿˜{ืc“๕ ฏCํtฎฅคธ,,*P"D‹ึœp`ๅE= Rฐ?(๓V8ใ๎ B”สJึ—จค/Q๏#†จkื๕k#@ˆhwKศbฯƒT5|y\'ั๓‡ขค`๏็_~}ํ7a๚`้~ฝ๙จ'ูุ่ฅ๚]›•žฮ‚a3&)Œัฉ“š๘๎uภ5$[T{\ฟ—๏๋ฤf} ๘^Zœ๖&คun2,๑6฿ๅIvŸลN[-ฅc=ป|๘๊๙๏kแ๑๛็๔้“gฮฟํโทC—๐ยค’GGw>Oื\}ุ๊โng'ธr๐T=Žืถzๅ;ใมฦ๙๛คศNฒณ›ท๐ี‰•๋ฎfท'ฯ“๘แ+ํถ†tฅ/7ษซ`จ๓ๅ‹ว—๖ฆx -!nOยฆcFzyๅhฮ๐ฯ๗-๚๙^N œ^WŒๅญ=‹^์\x่IฒธูซA้แฐุg6qžD๕ไœoW๙5…„ช/ำจzRCำไฦmtsณRท<๐ชƒใี์ถฏpำ๖w I้/qฺeญš๑h็ŠฃaYทบGไŠ 4U ฺy8ธ:yA๖ท€ฯทNฟ๊ๅไณI๚แษ{qmSำžฃฌํํ,.K้7สnม๊QŠฬ๘ท๏าไŒๆ-ž>S/์้ง์฿.V*{ๅŸsุจ^ญyG)Bยฎ 7‚ซŽบ9MV€A6nnGทOR"=hย …:Rํธถซfwฟีต้$๚l|บ]ๆฦโฉ๛?”ฐๆ†Wlื+อ๔(j<)Bg่์๘์k+xvช†c@+็,ะsธ…ŽLึGฏ ดบF"คZqไชฝEก…704šœ{ยo›ณ-J็=O๎ฉšืJc๒ศ{žjFำตP[šอิvิษิาvภ๕K_๊ใ‹w'oด8`-@‚ส’์˜'[๗฿วษBต“๒ฟป)] „Bฤp@ <ๆ๊’แW;บ!ิน…;kQ;บกŽƒชNpB!„Bจ‹ภ๛Bจ 8คฑ็Cท’ศเŽ|ƒAoHฅสVำึ๗? „"ToK‹็B!„Bผย๙B!„BˆWอ™?จz;|Rฒวr $ซNu๑อสฮH{wg‹ {O=๚ไ}-==๚ี…ƒ„ ว Q็๏‚%€ฤ5WFคั’b‚=ถ™ส‘8็‰P[ำp๔oุบy๖# ๗u๐ฯฅื†taํ…฿Dคัา’?{ŸYคีZOญ'‰wทบkx๑`ํ+Lบ/ 6บ;ไZี฿uอV*่ฯ"jคs9fะฅชฟPๅuพ#๕–฿ฃsึE@^vWผฮ•:kฬ)‹ื^:’ ,ฑ.JgืRY ^ฤ{,yฐ๎้ั_ฏŽ๊ฎฏ๏๔tลฃXปฏฆ-6%|O(ฺ…m๔IP9_ …B]WSŸฟค6๏ไ?vf‚๏3 ์ป`ปeบณ‰ฅWŸฺฒ›!๖SNฟป”ฏผ๔ไ…3uง'๓ฺ์uwำิ;snd_›Q๕€):โฐ๗’ˆฯ ฟๅโ*ึฺ้wS4—]ผ์u™\9›N๒&4ๅ๋ปฺ๊ณ}๓žM>๗ญ…U้าk’ 99ฌ์๗๐โ;ใ#ฝ’Z˜๙ฏ๔„่ญฤoฒEV(ซผ๚ำ๗œฃ&๙”ช…ลlnJ'GHฐ๘4‡‰ภ›">ƒ๎}๙กฅฟd[กŽ?bn5‚/๎CAภ O๊ฑž๓€ม฿Owงปฉ๑่วŸusi๔ฅk๛E€!„xัิ๓น_ž{์ฐœๅฤh,ฐ 7ทฌค ฐŒอ*-๘YV—[ d`ขโq9†QZ–์<\iฮ\€สขœฌ*4๑iห๕^>— ญฉ%r๏F,ฃด”ั๓Qบษpmy5ฉปั„l<๙nม"2€ข]ุ‚yร๛๏ๅšวŸmŸ%Aั~๛ๆL“ซJ&ณฬoๅ*&6ษ–๙๑ฌหๆŸ~๕้b“.ฏย฿O`x(ฮwฃูŒ3A1้ษ็็๖"€่๔ูOWสW%ำนฯ ส—นษ+ไS\RJํำ‡๐ฏW็ŠYe‚หรฤ๔„˜€Kถ†ี'จ๘zZyšLKŽ๑ุl"ลน๒Dษ๛9†2่๏ทi*ฌzฤ`ะ _{uนๅ๗ณm&๓2.3๑ู้J 6๋๖๗ง+ชส์ป=๔๓!œŽฦvแ›ท๕ฝท๋|j๕gย.สฒb๏<ฏส/-ห‰x๖.]M]ตๅอY‘๊Kฟ>๋ฬๆฅ'๚9~ญ )Aื–๔ๅŽ-G0R˜;๏ฆGอก’๕๓[EทŠผo"ezฝ๖ช๊wRcจ˜"€๚0ั์/ฅW_๎J_}>5๛ฮูะ:5”’ํ%“้{'็g3?โ‹–Šฮ€Žซ Bก6So‡ฆฉ๓‡‚ˆ7Ÿว๐˜แnณ๖วฆฐ๔คุŒ7/ง?*’bRุ^ ŽOJ๛๊ฏUŸ฿vMํV^t๓.€ฬ๔าAff’dฅQ#๚JIKsศ“ฒฎุท๙†jšฬคธ รM%@j์4ฒว”“ำgวฉ๎ขฯP”$ซ7\@ฉง^๗ฤ ˆ&6ษY_1อ~็+ํํk(GWyฐ'้ ึV”ฃc๚kX<๚kฟ(>€"ŸgZฆfโ*#อฤ^<๛ะ๒ยU๎Y๚ูXCฝท๑ัุิฦฯฟ^ >หๅธ~ศ*ี~ฆ‹WŸณืŸน฿U•พšฆู.š๕๙อCIœ*O”<๚>Uึ`_อ‚J•ฅRM]k3 ›ˆธO้ซi=ึvV/€‚—ฯตอชSษิLโ๙ำ๗l่ฟ! +%ซฮ฿…าบ Yรn๏ไPงƒมตcโ.๓มyุห฿H’๛ห็ๅๆถผ=+“ฝฟ‡'V6žโep.L„ฯ€UsE9&'9เฏy6ฏฉa๙P}๏sŽซM—&4๙ž๖ฉฺว^jฌ˜+RJdก [ฉ ‡ฟล5<ฬ! 6aษ๗๊o๒ >•u /คeP๖9„Žีn’ฒธงQม ฟ/ ฃ ปTNoธ0 €_Q]งˆธ—คๆ=ฒ}๔eํํทsถฺศตึEwPZZ&&&ฺz๙!„๚˜˜hqษoถปZzฺA—~O–Œ2;ึ1มสม@€D" ๋• ญeผ๖ฝฎ๋~kน_ บMœk™|ฺWจ|uศแะKŸ3Sข๕ฮM‰Cžฐ>$‡W”}[TRTNจบR+ื๛ุ—”"vูื๔–„ฒ ”ฝฬาฎย >ขงผoาgV›5ษ‡์๛ถธจจ่๋๋ืู……E‚‚U;N๑ืˆ)d•| ศ๊ีK~x? 56& 5สTๅๅห`NLธทMผ žŸ’๒“L&“€D"K๊ V€^ฺฺ฿ž฿ +`Uะ}#=HGบ*๖โ๎‡œาโt๏‡ยดๅ8Už09G%ท=c‹XŒ๐ ฐ€|๏gแฦf&’ฃLUŸ{ฑฮ[ 3V็ฯ๖วK๎dg๏ZQzl็ผ_AปŒ ฒษผํ'๏|u–ผฐ๓Ro?X“™พqbไึษŸ์)่ฑE}”ง˜„?ฤ]qพ๔‰QY้Zฆข* ภqต้บŠ๏N‹ฺ<1f๛ไุรฮ… ›•M•ฤง(Ž-หพ๙˜เ|Žะ)ด\ฟฺุ€๒ฯ๏๘ดฆKh|แ|Lค3ชLพบ-K๛ไชงŸW]p–๘‘VU฿.N:ทp์•eๆื6๏JWู6ฦข๕žF๛5&eธฑŽผ<ทน Bกๆ‘”3m›R7ฐอ?mด๕ฤ˜+‹โ*Rฝ6ผmด๛}›]้wๅ์ง<&ไฝ>{;ฮO_ ฎdWืd๘8ณ๘'๛j<ฮJ๐\epkฝจ`eQIทฅ์Œุ๒|ดzฑซ๎ฑY,>>~€—‰ฉ๋{ %K— }ฺ๐,j"vM#ณX,~ €๔yฬๆ‘คW๒fZฏo๛qผD&แผีฐ{ug…%9๙PJยฉA_๓YPธaร; P(ชห<gTEด(๕ฃ`U “Y]$ณข‚Bแ8ํ$Lจ๔SSวW—ๅ<ัqค!ูGv”ถงสI๕/R"&4์4<-L๘5ญfv1ณƒวค\=uqษž—฿ส9gฺBฌBZYaีฟดภฏ ช oู`๐๛ส@&™ฯ{cัสซฏ๙ฯ๔UVต@Nทi๋฿ญKขˆืO๊o*F{™•S'(ี๏ง9™‚“ฑ…\็ฌ;ใ๎“…^ฯ…Y%%–ž†ZcV?{gEื๐ณฝtwา"Š„ˆ]vca ถX( ŠXจจุ๙ุ"Š( ‚„tซtw , ›๏‡]e—P๑o?์œ=sฯน3g๏œ[R[ฯZ!YOY Ÿ๖™ˆŠ๙j0Zkๆิฑ\\ƒฝ-Š€€€๐ืัาาšžY‘ิQ8`ํ<žภ RYฬ4H$ิTW3พฯทื๊@วฤ„|ญ}ข่จ…‰มรส@\LฌบชŠCšฟ‹ฃQ)PšQพ@oธฌ๐่โศฟ8๙XŽBaVnKฝ+๓ฏk$i๓~#็์k์„2ห\&ผ7W\^ƒ”Bฅf{ฬ3;“๕“ƒม0ฟcฐX*…ยษ<ำ่t:ช'•฿ท้หŒึOŒา~>—๑บณฎ›D‰›žWณ?5มI[P\PP\PP\mOxำฃe‚Fง2ุe……ษฅฅx€j:—‘ธ‰1ž€C Ž0Tkศๆ๔c;?จfp ƒรใะ#DGซ5ๆค|)ูก’`ญ’`ญ’`{ดก๕EŽ5ซ๑ ลฃ"ึ”๓ำ•ค5x.อ๑ฯ๗œฮสษ[ึส qR“FM(Hส๚aศ๊G\งบQgu๒ิะนตฆŒๅ%เฐย#‡›ฉ—ฅฅ1ง๚Hฏว&บg=_ฮ‘CE๒ถl…g6wwy›q‘Z•่ธ็Vุโ zVฌƒ(ญ8๖๑บํํU)ศZ™)ษ฿'b^~`ไลซ‰k๙๓ฃ[ฝองbุฅู+ˆฃ๖/}แŽoษ+๐๘K[ทnŽ฿6ƒŠร{O๛มqG}ณn๐6ๆ~๒Xน-ฒํ"ง๘พฒท-ฺk฿?oอ}t"?บlP๒ยฯฎ[q6š๔x฿>}๗')Eฐ ๙็ถ}mาใ}ป๕/^฿&B-ŠพณvK(วชlOh|yโเฬซลฎ%ึ}:0qัฮ๓.฿ฝถๆ๋–อฌฆ(‡๙Kl2์าc๗—‘Fกธ>'-lWzฑB|๕ซฎฎVOะqัทŸฯฆQ8šžฅฺ์ซ~ๆ(dใฌsEZฺๅPสแd๖ทฃฏ. šI/Ž๐ฏ:ฆ~IM.mŠ>T๐‘ำUŒ6ท|vsaวA0ิ๗eจ~์–๏o๔OฺžXฤlRฯœ=-๖ไพจ~zๆ+ -…Eพ›฿j๋ e–W๓4}ฉa๊M™wvธฎ๐’ภถ””๏{๗บไฯไก๏ :ฮฒธภใ้๔f€‘ฑ‹ŸX9็๎ฃผ?ํศฟŒมฉŒ%Sฟฟคh€ X^ห]ค>a ๐๊{|ผ„i์Xซ€รใูงXฝ›ผ๊ๅSc๔ฏผ:†ทโธK’"๛i]ย/A"Ut Š3ฟ๋)„มม€ญ@@HZc_?฿z$>s/…ส`0€NJp๐ง฿ผหgu7รอค*แฎตW๘;oยภ๐5€€€€0XAฦyH! ›๏SD@@@@@@@@@@๙Kƒ€fj?l3๗ำ>ิ€€€€€๐ื‚Œ? ๔ค€€€€€€€€08@KŽ^ฒaƒต‰2แา?ํA๕7"าs’ƒo›Šฃz'Dหฯr๒ŽHศฮฯศ๘์p—ฑ๐้ญป“™›%ไมIR?8ญj๛ก(/๛„~qพKƒ&K๗wชHXฟ๚์jŠ€ัว?๛ฺ*v{B฿ i๖ร“)ฏ7ฆ•ฑ€โ็šDๅ’ oปฏ!ธน’{‚๊๙€!6 ์"u„7ฝPพซzๆ•\3ึ3%ฤmqQ๑T„๊‰งาใ5X%-ฯHแ O•ฯวจžz)ki„Eภp๑“_TW˜ ˆ›โิ๗ญL—%ศmแฎx*\๕ฤcisฎ(=ืm ฐ*—%Wหญห“ถO$tยŸ€ศ3ญV~ำ>nๆก„ีกห'Ž^8ตXฉซsๆ=!Uญ—๘-"]`‡ฟ—]}—g`หด~)ฤGํบjCฟตB_cิคmQgMแํ•PuฉŒย“5ิGX>ยmฑ€!ซ\์๐๗๊จŒ0฿>แาฎ๑˜vs" ๐uนEย๏E~ฮ๙ื/>Qบื 6็npcห9๙ˆ‹”Q;ฑ&๛ล‹๗fดk+1V์๙๗ƒ@๛ด`ทAฆใ‘VญbZh@ฐ—žU~lR–mฦไ3ขCะภeqJ˜๑ฐp฿ุL'‡f•#โ:<@GkŒ!ZGu๕(ขGุKk3ณy‡1๙3›}ิ}ศdeฉ‰ำŠ๎์%Kุ๓ซizB้ๅบฆ๕ฆปฅiORจ9Gชƒฮ6ทvฏู๚ฃั&๓๊iFmkKeยs฿โ1cตz#„๚๊jrs]#™Aoฉk ืWW“•ๅฺyN•๒-*(Ž>Tฉญโยeฒs๊+็ป]o=อต8PqบjO•๓กC7, 0๓‰–ๅ[rS้l”๊i/ู™ฃY-”4฿ข๋CฯDชž๕–ฮ?รUO>“™<ร …น๓ฤ^<ฆทฃ$ง˜˜“xำZYย ™~โEHjN๒—;…&ษพnทไโ›่'ึฦณFผ3 hน)ฮฯ‚’3พ$\8Z  Cยฆ‡D}NI)ฬ ‹ˆปนˆ9๚ฑีl๖ฅ๑™ioญPรr6ฤษ๙Ÿแฑผ›ยF’y ฑ?<าQ€w”อํภธœไฟห;& a6๓1Š3Nx%gงฅลผ85Gร)๏ฌl~LฮNM ;>ฉญปฟหผ[๋}ƒV\๛tUกgญƒวฯแีาุสจOnH+ม‰หr<ฟŸnว`UR้๋Cnฅ1๊ใrx Qเึุ|ณ‰ิ@/๗ญŽข๓๊ชไD›cผ[›Zu_jJyิี ฅนึG `่bE ๙ฯfฆ—p๋Nh นีDjค—ฟซŽb๐ŽP้ปๆ๏ฃ ๑ใ‚š"!nํูx,่ ํƒแค’‹ึ=ฯHนนศtOvบฯ%5ถฝ”_š—็uzพ žณ&B!ฯ5ึGzuฉ๊(มถ)๒›‚Hคo ‡˜ช IDAT!๎ฏ๛obฆ;…})*อNzๅฑำ\ๆ‡šZำc5)็๑b‰๎4คNหlช•ท๖ี฿แๆb,ฮผ‰ษ-ออŒzho"า/–๚#vH%ล-รว™ ฃp2ใŒU…EDz#„โ๋6;๋v|สHIฬ|?=`ฑ&ศ{{๒Nd= '5"fง‰๚pร•wำYC]ๆุZ๏#๔๗uŸณjF5{อ.ฉ@ โeฤh 5œN๏ง1(!'\ฌษl@กxตyไ๊[ ชฑB *‰ฬ5ใœ”ฑตฆ'(PKญj%jŽม ฐR<๊J>fsฒบ1™ฬ3LฏฉGIŽๆŠ!mูœ๎&5FJbfณšฟ!.๓้…ย:ŠิดคฬZฆ”ฤP๎[ซด…ใ้าZกฑ น‰“Ž=tฐไ ต_ผๆbŽ†วีM*4`f1PJวD‡› *.‘b_Rฺ†…ซ>žดa็๕C er๐ฮiBqฮk6บว7BƒฏcA.>จ0J๔้}หปัD๘(U|Y ภ๋zวž@˜๏โ6ำฦัŠรฦ.]|ำ~ ช,๕G๛tvoœแต่ฌดุ ใJี๙€B๕F"–วœิ฿mš>uึฌ9๓ฮ๊ตอๅ_zฏด$3ดฤๅลวข(b๓๗ดz8ฝฌ๎[ไO๎คย:hMmฬiล‹ˆ^N๒ลทนพ•^\ŸN$ศ‰A^๚ลทนยhสiฦ๚Sโๅิจ_ต4ำ$ฺ4!โก~ธN*#็[5?๓J๙.(xz์‚_FižŸoDซฌœ8(ji•~๐Šฏji*๒{Nิิ’ E‡„6556ฆU466โ๑xE-ญ๒/“๊่ิ2ŸWก"ฺ:"œ ีไืฃะh ะa]]…6ญฌ‡.}ญฅ5} k•“็dˆ“๓ฉ๓{oh6 <ฮD. šh4' !.5iทwzY   ฉY๊๗,ชฌนต:๑ถ–ว้(Nyชญ]๖แE|5…R—™^ภŠ:vyืฐ ศNษ๎๐yธL„ƒ๕%b 0๛ธœ๓[q'•มyœิ๚็v ^ธ็ส]๛ฌๆz๋ทก"“ @@ใฉ '7š[R€Aฅ pzร็fีำส๎aส‡๗ใŠฺNFQ’ระšV๕)อ2ฝ†€ฦQ4,N^•M<ฑฯšฟ‘ัสาดฏ–%๗อ+CŸRhฌวakุใ‹1ล@ yเQ€รโ”F๊ @u๐ณวAืฝโซe4š‡ฝๆŸฬ ยฟND ีอ‰ฮ๕Ÿ]ส๘ฦิท๗ป๕Cๅ'(ฤ€ๅเn๚ยuู๒หiํ?กy'ุ;‘+ร}๗๕\F—š2Jร‡—๚yฦ~ki*|็‰Kkx,‹้—™๔œg[M<๗๐จอ|+Ÿo4`๔Fศkพ`j๚ƒ๕‘Y4€‚๋v๏็บฤ†ิ=ฐ–zˆPšใv5gหzฃ={”Ÿฌ_Ÿะ“ฎ+F[Gƒh ฐ8 ณš๑ ล,์1ุva;(,7๎ยP}* ๐อไ\de'ะฃ็อ&=ทฬ๊ ขัXe•FCฃั€วแฺ…*‡ใ๘˜ลใprซ๎ฮฆ–ปฉ0พสlˆ^•ฆs๚Cิ๚บโจ}{รฺไํทฮ 3ญ๗สy6Tพ๗ฯุi:$1N+่E ่ฮžใC9ฟฑ•ฆไDy_tv๒สข‡ฃRYฑิโ๏฿–ฃฮyวaฑํย.๓žuฯzขwว๚us  Š๕=์เ๕&”O๗kฎน5ๆWvั5ทc0ำไYธ๎Š[ๅyiXUCฆS0(tCใ:Œ–A%”{—๒A๐ะฺ‚wSค} Oแง&‰หย๕ืr๐ƒj~+‚Aก๋ฎ˜ฐฒIแ42sอƒลbฦWWS เปฏภwพhภjฝ’ั ฦ-‰d^r'วŠ เๅๅaฏู†ํฦ=vแ;โ 2z0 I~w|๋#™รs๗0วhษ๛เบฦ๚R๓<}๛ห๚qGn'Q8jถ๕Y A;x้XฌฑืกrBฅPpธตŠž๗–rvNQHX•๚ฝโา/ํนๆฤOฯ#ส@TLฌบบบ7Bฯ QYƒh4@ ๐kZLๅy]ฦ ิf๙‡}sฏ /หMวIหหพฮภฒkPชsฮdนnj Qถ๊ƒeะจL“ํBhฏ฿ะจไ€Mนพ๙}บ.เฦฮž™๏5ฉ๋ี(@กR๋ŽX †JๅXฅPฉ9ื–Lฝำ!้EGอ?LีฐฉUฯูคษ„_}บ…vC˜wH^[ง๔ƒ_ู*3} 8ญ-LYร็;ๆ=œ ฒ๑ฺs7\–Eฬฟ]ึ1›^Qatme…mฉTฺwอถ/l๓N*ฮ%u๖œ๕>\Ny',ข>SZืfŽม qิxt๖ซ&ƒั”V-ฉฅ 1มT+ศ ะX! JM9`g๒โขj3*ร/า6 TŠซ ก &ษฌ๔šZ* ƒไhฌ 83›ภKะBl‰ฎK-dtฃูg Fk ๒=~ๆWWืุตๆOOJŸชซ?nสงอ๖42™ Pํตรฤ)†% }“ฺัW=ั_ฐธ ‡ม๐S|าp(4`ป™*BI{ธuย#{IMCซฝgOXฺeyg๑KHน{พd๖ึ‰kln์heฏ๙๘๛ฟ ฺมH*ƒaUt1X,•๒cฌ๛ฮฯฯ3iผพมhญฐˆคvaฟ๔rญ9แด^_„ศ-?e๕l‰ˆฐฏฝึคงVถฐ”%ข1šVS5ำRำhสs]W๊ `อฃ8ษD-/7 ษuด”‚””‚””‚ฮจฆงkคzำx gโดฆy h!>jkQ%P* pใ‰ข„‘[Dดx5ฑjc๑8œฒะชs"C…~ฉ)ฯผปซ ไฅฆสLฐิ&pIO˜fDMMแxBnjชไ˜ ŠDข๚Š ท7Œยs0„วD%$,ƒAฺT>๖ฮซฌ9w๓๔ฉGฮณ:Le.๐๓kทmนqr@` ”WŸr\2fจž\SVFขะYูœ4__‚ˆใSZt๕ำๅนยœ๒^˜—+g6]K\\eฦMxปฮ{'ุ[0ผdJMท่—1hกแ ฤวicะy^ %rE!ฃ)1ˆhบ’›Ÿ->IXำhี%’‹ฌน๙hQsa}๑ฆด๖ูดฆWซŠ>๖ฆ8๛+`4%M:d31“๕‹ิ้ ‡คถฺ๓บำ์;ชสrกa‰6~์๘ุZา›4A{ุ˜Ug฿๘\Y;’F`h๕…B\ฃฮš]ๅo›rมฃ1z™๕e € ฮLk๋ef (˜w7๚๙้m๓†๐•PWQม๊็‚บ,ฝn ู5ฮ๋†ข +M„™œไd™‰sFŠนd&[S’“{ูแXWื่ญฉฎะQุ/ใEท๖แๆนšทฉ ๖ั†=พ๕ฝฦท{t๖ศ‹คณผด๊ฬ c๏ภ“Ž“/฿(„jฌฬ=g#ฃ๏~า"N– =*ใดC/m[šฮjฤลj๒ว–ต๚๏ฉ๚<_ดMณ|่9ือt%ๅviัเz'สoƒ{ยผ ‰ฯTuงGzๆฐินKแถยดโุ๛›v†q’ญ}ๆph”ฝ๘=ย˜ฦยเK{Xoฃ้l(๏ู™LŸะผํ@mศt฿ฒ๎Bl?8_•‘˜[-ึ๐9ฏใ๔Šิ๗wl(vph ๘–”Œuไ๎กโุšิwN๛V0ณนO๗๔ฉ)’ธบ์ง๖>*็”๗oฯN\๎๑$rm๚•๕ึv]ๅ lญ๗-g•ms™ 27ฌ ูณศ๖"—ภถิ๏o‚Šู–~๕=ป“๛~;/M๕ฏN๑ฎ>ฏ4YZชศiืสฒ€็R"็$y8K-hxทใ[>(G+ŽJ[Œn-n]šุภJฃฝษ…d/zœk‰์QษCXjAร๛]ฬlิ็4Wฐ-)dJwš}‡——ปบGอ_ฅล"Gฌณำ]+BsูgŸณ/bš๑ใะ ะ2]๊To๑‰Mมe/ฉใž)ข bพ็‚#๓ีRำ๖\˜kฟK๒๒šธ~ัฮ๙C„฿าผท:า m}#๋๚+}7n=2๗มr_všRงefฏe5Hor„J‡’gจคว๛v๋_ผฟM„Z}gํ–ะฟงฃฎฎ‘๘ใ&9("๑๛*ถžฒ! ๋‘S_้ญ๕i๚ํ†๐3/ฆ.ั]๚ดPxตํฯ 9๋:D๗%M„_ฆ๏ทก[T๕~ำ}2b‡Tฏๆ‡žg๒0Eh็/Œฯฟะ:ย/ำว๗ห๑9ุ฿ผŽ๐ฒ˜?*เถํภื5ุ"วฟ๕ฺ|0หN •ม`”ไn๗นi"2}พƒค€๐หิ๓ฆw#๓ศฺ)*๎้ปŠlุ A;H้ใ๛ๅำ‘๑„ž‚ดุ€–ฝdรk9dถย ฆ฿#น?hๅ >)_Nด๖ฬNษ๎๐น0ƒ&ฏ๎ช+oC>'วFฟฟn?^‚)ิ[}ษ;0๑kLฤ๛+;ฦŠก8๊$V+:o๏๘nD๎พŠ“e=Aขถศบ‡*งCิ\žศ[ŽEŠฅอ^แ#;F:Fym๒๋ ฒ ›n_๒$สษึ{lh า`็;@ิYPๅLจฺ‰'๒VH$๗—ล-ตณ‡x%XyEJฎม๊ง}W- โ@Kย9Jmู‘]จฦฎฅธ?ๅ๐/€ไž~f่๑@5ง{2fj]=Pzฎู๏บ$‘H?|‚์ไ9ช+๎TAชบ6ฃ๋Dyyถงvov?{ŒะASื๘š R‚kwp๙MA?อdCg๖\@Xร๕€ุœาฏwถ ทษ%ฌ]>q๔ยฉลJฬใฉ๎ๅฬิjŠ ำ‚๎0เ”โ@ัณ๘'@ซ๏๘TUQโ1™yˆณ๗qhzaVr๐ต๕:ฬr=dถ๋ป„๔’๒ขยŒะ็{MŒr>n \#F$ฒ๊Y แท#1n๗ฃ๐ค‚ฒไ๗v‹pŠv/8>ฏดฐ 5๘ฑฝฉ0็4[$๗c!.G u็ผ๛‚กW+T้๗ถG‘Oูg ‡‘^l.x•ุa{W<ทชFSิซึ&2ฃแs…ซyas?๓ดๆ:}ICฎสดV pื๚้~cm#ญยฟ*†มงฃwอง4๔žป๛ew๏T*@uิcw๗ห๎Oโ๋Dวุ Jศ/อหN|}a™&ฦ* EะภX= UHYnใฏฝ๚JpjvYYVrะอ zผิ?|•Xษœฺบ็ฅyIืฌฤ~_Qx4ฬGื]ถ;›D๙๙ฦทฬศศˆ _ฏว_ฦUv•F4uฦO…ยl]6ฺบ}฿ท/ยพ๘–‘๒แ:ฅŽ๊uษ๏ฟๆ๖2`ˆB๏†‚M *H1๛ง/ผ‘SPw}<P์E|j$W>JJOส๚ฤž™ิ6„หฬ€๚‹ร7๊Ž0ึbfฺํsกe๕ตYž—žางฯuUUญอu ญ zK]}k]uี๗%o}๙์ะป+…7ๆ<๕้กโ๕y_;}๐Šว›แยZZ’์…รMอ„ ‘‹๋U‹ฆšN=รแ}ฟ/’๛ซ€jณorยษKฑŸ}xใต+๐ฎlๆจY๐ํAt '4ยpXืไ*€ฺา’-“ฑBhœดฉ‘ฒฐˆpw†~†`0 ๅg“ฑSฝไvQ 4@Cร็ข†@’Gฟแ๓€์J'ƒTงซ-คว๙[ Rทไ๚ฑN7ZL๘| ็๘‘F™ํขรq€ฝ]Z6กุirๆฉ‹T}g1eT›ฆ%:`}ฦอub[Eตq@NผVี€B๑ใ–ml)์kOื_‹า+ฌว<รe๏•ฎ7มิˆfjย ml"๘ั?ž—&)iN>›^~g™’’ฆ’า์+ฌaศUJถVำwGซ4|ณœ4ฃํ'้™ฬ>Y>็}ึEVžฟ€็ฦ"ƒๅ๏‡์฿8์รฆkิfY|^&ต๏S๋]ฉขƒฎกšืเฎ์~Sว เณ7ท^ึถd฿<๏]hU;็Y1Ž'#ฏพฐ” ”•ถ์๏โR•’’)ii(๒ฐRป'พ0'ฝ(ศย๎๖ืm›ยโตถC>ด๒RZงฦ็฿B…บ๚cผ๔$SM:‰Tฯ^(",€Qต~””W๊สqb4ํ‡฿ษำ~ฝ{E๋๕>l*<“ๆN-๐|–&ยkูYIaวลฎญ:C …^<”0๚b๐็๘P_G…šB@กบ1ิ rไMRi3›๒ฬ~SฺืะfeCn !ฏศง๚ฌฎ‡HŽบ๘ํK.๕[h}&',xUJ๒๛ๆ†Vzuh]&(ห๊‹%‡{ิี9ฝ)—Œi๋ ๅฒ”ฟฉ๎t๗มฎ<๛ทฮ9๙d?w๗สlค7งF'ฑFH_๔MŒp‚ฆฦrœษPไyส# ซผ ภ/Š,-+ ššๅ_'Vท4ผ$ชkˆ35ณžœyœRKoNŽLh•‘kซy6]2b๖ฬ/๏…mOญำโ>…7756ฅ‡†V665โ๑xMอŠฏฟิำฉๅพ>aยZฺยœ ีิฃั( Pกรฺดุไˆ!Žฮ{ฝš[Q๘๑C4}ˆB๗c/ฟ—ฅฅ(u็ธ[หณ8^ไษๆ? PDส77ซL็fy{IfqขคFข5,๘ีำšฐฝƒ€ยQ4Vvท?ƒFAแ}ึm ฉ'5o=.๏ฝ(E}=a(‹~|ฯ;ฑ€‘t๏ฟ{๗žE–ิxูMตZฐ๙ิ5ำžฉCไ9ฏz่ พŸB<ฯ?K๚]Y๙ข๒กkVฌXณbอ๖3UF{.๏ซ&ŠีSล=๋l||T||T่a#hL}{๏ฟ{YดN๊ส[฿$œ๛ถxd๖> ๅ>GwŸปtแu๛P์y|r\ธžฦh 9w9‘Ye_tx}ห๙Cž†๗ˆ\D …‚“>ึPUˆB&ˆDsาUใอš ๆ“'๏ฮZ่ฑCŸ๕<ถ๏>โƒฯK?๛ซ สOูๆ๎9๚นชˆ'_6ฐขP คA๐ฺถฦ1ฌ6ห๙ะlซ~c$๗วฬขม๖ํC=mํ :๕(aŒฦ›ไ๚Ÿ+๎Nณ๎ษ:ฅง8กณ\=Nฃ–ุ๙|ฃ็zํ™ส›@mjๆ]๖`ํhFื†:รVุ0t @๚ิPฑšW ภgHL}ุๅ๋ิtZ๛ (,๎ปFEapl ต;h~Uฐลล-/ฐ์ค jcQ\็A๎ฦ๗ผcq8€ฒ€y[ฦŒB‡ˆšh{EvŽืะhิ๖/h4p8\ปJฅเ๐mKI;bjฐ ฮฆะ#ญfีพ\˜๓kึ;รแd—_cA,wsqR{e่gC๔ขุ ญc>Aป๊๋KcŠhO‚mŽ~ษyึ• š_l๖FqXvR6pŠไศๆ?๔ฦ๐g-4hŒชŽอช  แ๕Eโnย๕ทspBฅ๒7AfP0(Lc‰u,ƒJ๎ณๆoƒ@ P(T R)@ ูkา„F.ฝc’šหอะ„BฑืcQ๎wlฑ_ฟป‹ะFsvศ+VO้ซš‘๋ว/WT”จ‚ˆฌตผค–าญๆด•S-ก็W8Rฯ:NCำบzv=ฒณน_ชธะ้’ซ—Gนช—คฎ]ž=หŒ๙ลห›@&“ ๘ฆล‡จึะฐ`Š=Žฯ๖ฤ#^มภH๕8็ท๙ส”šฮ=aโุTฎZ™๐}แskK+‹ญ๗Zฎเ ธGnmเธxFฺฝUa4€|ฏม‹ŒŽD@๒ฑEO'นŸ๐ฬ๊J สซไ๕ถjท๏๋บ๘า(OงฝWnผJฉe`ตุ Hyํ้ว4!p”๊๊ ณg ฒIณo‘์Mื้ฌ#+ร~๕yดTŒMคไdž'ูฐŽGgk_š<๕R6€–‘a]๘ฝฎ4จMไ{[ฮ ิf ฏ:dฆ>ย:Vfฤpฏจ ญฉฎฺ้P 0XYš7|ญ‘ำะเๆำn๚์๘ฝUส ช๛š ƒFEกXPh ƒฦฉ/–จkŠฮyำTห`4ๅืงืHjƒธะnำิ`ฑ8 ™y‘ ?T]3ฎ':2ๆรฎ๏u:ƒŽ๊*SฉT4†u‘1,•ยiไ‘_}:›ฐแ์฿˜Yำ ผ-บ^5ำs๋@ฅR๓nฏฒบœ!ฉyM?Zฺะตๅ.้า๙Wพ฿แ#Ž4Eg3#9ฏ>ฃFrงH๎l๛ิาบร่ํ๛—๚ุ4\'2jŸp์—ฉฅิb๘x+(F!ตือx #&rตฤึฆ1บัSษd^0,ดีาh4‡ระˆ๛W่|ุ1mฮ;ีฯ|wศu“ฐ˜๙๎3vzM๏]ท_‰\ใฦŽš๒ IDATIƒโkY๎“ใวX^+4@f•€\“ฮE<^)MIv`|&น+อNTืT ั ฃ฿คY{ไ–”vแCs๑ืศ๐ฏ‘จ0็kFV†—ฑ]๛์ๅ๖ี๔ป”Anฌ%pลวg‡ฤ+Uฯฯ#šแซฦ a>Afˆœ_๑ึ๏cH#N้๙\‚‘”ไจI)ฉ’โb<žภ RYม4HlkdQ3ฎุ8™1๑DR๋_y•Œ]6่๒T๛:vxx–—L7Z*ง€‹—ž_Pษ"็งงKอŸก๐Z&ัhฒ5งJUษ’Mุp?ฮjb๊ห ีXุYฦV3/=]bฆ™ยญตYฒ๒U่กน๔KuP์q|พ๛^F;cตฎก=# Nฺ‚Nฬฏ๋^&่^–่ภ๓ึืmณ‘๙dž ็c฿ฌH ง&e9G.ภซฏ1w†Vสิ๖D๗lw›r3๚7๖m‰‹”ˆ่ฏถe-•jH๔บ-ฤN˜๔)ดvตๅ’ƒชB%NลCExD๛4c$์›Oฐรต4r2บYผา๔ํ๘„ำWื ขฟๅ„_vธ“ล๗๎z:ศšทฉ0™Aฟ^฿|Œบญข‹š\ิ๘qiv[}ฆ0ด฿Zจุนคใ:’ึ€สใdึ>ฦ54พX]ฦ~B!-สญT๑ ฬแZYsุก’ NuคๆzŸ๓|ึ'•'๐Ck59viPง^๊~ใฝcฮ๑4ๅGถuˆmป _>Šฌ_šถwoSีฆท๎ว'Ÿ๒๘ฐŒP}l๎บวล์าƒฺNGt]ฯnฆ•ฤ?ฺพ/’ำEf6เg5๎หหฃฮ!๋ฑuจ{แไฌ{โฺงยุฦยะซid† ^\ศz๎—ย์Fก5F{lท๕H่ฮ‘nœฯzu1|ืฯi๎–‚˜{vcจบ\๏sŽฯ๚”๒Df$฿*ศ)’๛žออj›f1ธ/ฮ€f๏ยวBœส%๖หฺ€กW4G;–ฦึศtœ ำ๕ฬ˜ฟzย™Yษ}opดยๅmณBrš+I˜–T2ต;อ?F๓ปห]นœญW;๊ำ*’๏๏ส๊Dฆ๘:m๒:ฒh๑พรอ‘—ฝ>{่ฝšฆ+็Ÿ˜9ๅ™ำฝณ๕DฏKlบpv๓Œึ.XgžN|•H  ซœ4ฒ9(๊ึ"ˆ๚‚ฃŽs˜cยยc79ญปŸvอ๖ฦ–ชฎถถHฎศ๐:rุแ๓QS๚&ฎJEณ%ุŸ๕†•,Nšจทw‰#ุ๊Kuดา๘›๗ธ}ฅผ๙ž Ž#@jฺž ำภ{อใเF‰)ป.Lฆ4V…฿฿ฑ๛~Ÿ฿ ส>{Ÿ@๛ ฒ สkใ+๛ฺ—N}J“คdœ[q&‘1g6wwy›q‘Z•่ธ็ึWใหญถๆก‚'ฌํj~๓…้ษvNฌ- ิ#๎v$;aจŠS8ง%๋กUฆ>;เเฬa่oŒdิ๗ม =ž๖๊ฟ๎พคตํ/Sb‚ยเ'มทเ$—ตE ้ ฝ#ฃสดฟL‰ ‡cค'9^™8๋ฟฃษฯou1pโ“-พ=— ณ!ด3q๓รฦฌ~Q(ผส–๎ นŽ9ฺ‹—์6็๛B฿ณ‰ะ-*#ป|หL‘ฯกŽ๕ภ๖!๕=นAfฯ2๛'ฯ ๔’ŸJฺ๒อ๋เแท๑•Rฉi?]Œ4 ้—ขŽV}โธใ/i<Nทา ๚oืภืฟู"'พฝฮ>0ฺŽBe0@ฏreWrำ ้s6 j๛ก้้ดN3-kฏšึฒSF๘5โ f,k๐^7ฬ๛O8ำคว+)Cฅ~๛g๛ํ๏฿4B๚šM„Aร๙๛zมฟ:€€€€๐Oม๘ใ Ž@@@@@@@@@@@่9H๛กง๔บภซณย‹๗Qฑ!!ฏ.๎0o—ฃ๘‡o}ใl๒ณฅ5ž‰ฑ?ษขeฆุ฿๔๔ส&}~Žยฎ ฑ›k1%g?MืŠใ†ถ eDถ๚ชฏœˆ้mฦปJAlมฝ ร ๗=Mญ๏ฃ“ฃฟ|yบ^๑GนE๗#ฯLoŽ‚ฺศ๗ุOญU็‡ฤ„G\_กย)อ^ย6อ2๐~ข†n๖9๗้œ๖Orด๊ดG…ํržQ“ฮธ†ๆœ๓ถณ›$๔kถqฤ…w†kบw๘ฌ2@ pO?ฅtฬ_่mY35ึF๓}4/|า8ฯ๘Jฉภ0 งp๕ฅF("ฺ`อKp.3ฟŠ{ฦ“๛๙บQเ™zB๙จฏบใ YSี฿ue์–๓q๛ะฮ฿-). „=dถ๋ป„๔’๒ขยŒะ็{M{ฉIPž}๖MtNiaajภญ๕#ˆOฌิใ/ยา‹๓๓“฿]ฑึ$ด ธ๖]A๚๙ํ–r*ชซJฟUๆ็$ผ:1Sฆr cNg”VU•ึ*ชซJซชท*~w>ป$'=๒แม๑’€บ่~lJnj ๋dแฐ‹€๐๋๔ถฦ'ป๘€ ๎ฉ๕ธg%\:›o^ฺc|8”.7ูa๕Brb็}ื„-w-ๅ)-๏Rจ4ฯvRษ…kื`ไ]zตzสƒ่gตl…]b~ฌุLฺณซชQh\๛vqeuฏORศ ์w?ล4๏‘™1]ึ๏B4ต{อ_J๓๋ฉ)๚ง`ฤ N/๘)๙x๎pEsLฏ๙I4_ตMเฅ๙ร7ก}?๒^ฆ๙์ำ์%์ง˜ฅr๋qธิุšN?๑YšศSิ.[่2wฤไชธFY^น7+N๓nุ/u]พ‘ฎZีณJR"ฯ+ย™€พ]vXN๑Iว‚‘ไgฑœ…ๅ…th}ณ4๛O{ฅำัj\ั„ึๅUฦภm&>0เ ๖ษŒืG}ํz—P@kษห-:ใิ‚7”tD,wIy!ฒM9B7จฏ8hY่db้๕ ฃธ๖Iิvซซกw:—[5ๅl.•z4ไ\์{/ฯ=ณŸ/yTล๖t้ีnร–š,Kกklzเ}jeภŒซฬMN ฿ฑ+i๚D๊ œ์4ฺ-'6แธตmฏ}v‡๕5›แปTฅvมฉŒ%SอX; หฺ\vQx9๔ผขฎงwœGฌMžตZีkพz†Œๆ<)ภ%$DฏฉA๊"€vกrC.฿๔ษoฆQชใร?3ไ‡ˆ@Mzฐ๗)›อn ?Weˆl‡พ;๛คธKa‰Dnih"3่ญ๕ ไzR ™“ฃกŸู2์ไA>๔p‰พšง฿1๎y/‡๛จjwDL็ป.…“๛…tv uzฏฑฯA€ูลŠ’ไŸsNๅ˜ฏ๚ัrๆZฮiZš•ใ~ฮ๗ๅง๊2kXƒ“๊;—Ph๑}^ฒรx{y™๒"o^'ะ~u(๔JižแK/ผ๐‹ |๊บัL–ูต#บ๘ZŒ๓œI‡๏Gฟ>1MŠcšlq (๖kโ›ปglฦุ๏‰๏ไ๖ฬ…ใปCšK~‰u1รŒฺโ๎>WŒcšlDK›๏ปแ๔ั๓ิสภ1M@หNpธ*,&$ไี๙M๚ฬ๘™}9๐‰" ฃพั;ะi_?๘ูc2ย\pyโX‹ ช1๎}฿ง3ฯ฿๛Žgy3•Z•…!!/ฦ1Q!ร๕ื_๙‡†&ล๚๚ผ๕;gลห †ucฆŸ๐๚๖โB% ˜9ฦœฑ™ใ๒เ๕๚ำํฝ}ดE{ฟลNoจ *(ค ืDaลศสะ"เึ1k ป฿XHซ๘PC็ำQโœBzshI}ฎส๔มU •Dิผฺ–๚sทอJžแฆญaki•Uq ~mๅ฿แ_ื๐Ž๘0<ฅด<75๘ฆTf็4Z~บซwTvaVZุ[Vฏ3Z~บซwdvI~N์ฉฉสsแYn‰9ฉŸไAืRWUีฺ\ืะส ทิีทึUWqฐำ$๊›่F=ผ›Fji้d*หฉ๑@027Œพ็_ัิ๒-๎–๓‘๙808•QA๚–เ{gืx6ฝ”สภฯย2r] j๔ข‰^ิƒ๋_ช›KBoyŽ5ัƒมแ0 ะ€•™แ๊้นcิูG@่šถ ?\|€ย i๋iิงฆV@CŠฟOHNงยะŠซvMH:w-พตka้ํŽ๕^G†F=™บม้C3'!Cฉฌr3M>pฆ‘Xธอ4y›iฮว2hzn•ผอ4๗S๕ฯ๊ธ<๘gy‡ๆ—‰Ž’ŒV…ฏENำำฯฅ;$&ฯ1Mฬ([i™ฤโใ้gฎPGSB5ฺc‘คพ(ฮdซPลๅฒไฟe'ตAe๚L‚๏๋/]๔%J.ุป†pDณู๋/$Jjท?‰zฃน๎ฏ7Ÿไ”ij=sHฏาL<6NOKฆำ๓`ˆๅY฿m ญ๖ลจ๏YmqžZว4ห.ัึ3qŠฆฝณืาึำา^~งค‹4;๛ษ7sŸฃNโมiฦ^iถv]ฃล1Mพ™๖๊ฑ3วNYไV1๋ไz=TฝtฝอXนำJ\zษ>ซ3nA๕ใgฯhN๕‰”ูiK:ดไ๒ร#ฟ๓I๘>lRx๊c|= +8RMญ.?ํฯ'ต!3oวยช ๓ฬLฦอพžS|kีถ—ฬ Wš3—๛๎Šษใl>ศ๏ถ‡@๋H–=ฆพe๎ๆWŒIฆ ฟ–ฟ๏„๙่O๊ษ €dPHd๎).า†๒R%Nี๔"Lนฉ~าOอ๙‰โ๒9DyZa)%ฟcRXAฅ–ฬ=ูYฦ€yADปnY}bํชๅ0ƒ9ฮQrfฃ๘ธบŽฺจ;DรdำฆGฒ„็GFnัWPึ]z3ตร@ซ˜บฎ‚ฐˆึ%ฎ?“…ž"๋-ต{โ sา‹‚,็nอqotvšB""Tœ–ํศฬœ‚”wชpœ(,"ฺZWKfBฏ~—QปUล-ฎณฤŠŽซ‘‘๔ๅWว™ปAHDคฅฎ–5ฐWW[+"* y/<ขวŒ=*sำณ~ณ๛+ŠZ9„}„ฎ๙•Iจ|sฟ~Ž๘pD์ึ†sqœงฌˆXl]Jพsฦ—ิPx๊>{ๅ@๛ล‹–/sษณ8ถFวI8PPkc๒้Œ๚ๆœT/ฃBI hna0jƒj3นไ8NบฤหจPS>45ดาkย๊ฒDFaี‹ท๘็†ŒงUพ๐๏ืi=รgMk}ํ›ั• ฦ๒‹Š๒กj3?=rp๕mฏ๗ถฤพ๕ฮiขืฅฤm๏N{’&'Š_ป฿ ฯฏ, ๙ว"า/iv๖S^]ฝ2ไ]rZแ.RXcวฅ๒๊๊!o?ืด6—}ˆ!จช‰0๒นxIoฝ้พŠzใฤ›Zด}๑ณ/ฯŸปธๅ๙W?7v๙–ุฦป๛žธทฤ3c,ื5 ัh ะhมแZํำรsฑ"๗ฒ[ฃฤฉฑาฬS)ฉQh๕๊ ้-จ?—ƒ„€ฦั4NV—[œAe]? ฦ JJ jRฏmู็Y 4|xู{ฯ๘::ฅ๔•g่]QPาั)๓{[Eฆิฆงๅwจฏฅ_ฐdรฦY;žืsฐะ7D็œtีxณf‚๙ไษปณz์ะ็XZฐำDกP\ฦzไณำ‡ko‰้ๆฒX‚รู(๓วฟไ~yyQyeIŒƒgฏ4D•Wf>ึฐ๗nj_๒ืm.uพ4nิจฅOทoธผtั…๘_œh‹€ะg~eะตำV๋Ž_aบำ๙cจUป}ูv‚๔ถlQ|นkw€hืBcห๑ูžปโr้ลฝณy2kไ…คฏ์„Qฟเlฏ ๏dNด‘คๆวฟฟ้vๆm๎ำฅK[ทช—ir‚Jc•ŠลถxŸาlงO'ฝุs:ฐ\อลŸ9V†p8\ปKT ‡cนDMz่Yถrcม๙Wฅี๛วฯCTธ[๒๕๚ซล"?Rะ}ิ#,ฟ’มแ[kPsฏพฏd{>ฝ8!K๓๐ณw[สโœขไ ซ?NงwzS ิŒyหC*XmมV่ฦบS๊0cฑ MๅViiu\†ˆŒ"  8ฒQŒHรœ?บ,’ฬ `P˜ฦฺ[3j0ฦฌ าoุn\ภRT\๙W/o ใ‡qfXุ๎จ์ไ๚a›,%'หํ๐แ็dภแpCึ>ŸGOc~pX,•สถ๑LJ{๛8ญh๖,ณสxJ-ž‘voUX ฿รkg๐"ฃ#ัม์Ty'ฒัฬ`0h!๗ฎฎฆBuเ๕g!ฃตก€อ=๒ŠaHรๅaŒ๋—ณิ.4ๅ˜กน[Š(=‚฿ณ๓LฒTเพ3ŒŸ€•vไถฝะMงf|พž(zดc…S0ฉ๓ูH(œ9ฦzOษPํ‹ํBถ7ฮห›๔9_ถด w๘า๏.ต๊ ฝl?๐ฉNฯ›๐*พ‚Aฉห ‰ฎkข พA์4•Œ%eค‹Xษ:๙uุ5‹ƒ6ยU฿๐@ฅ~ฏdŽ๐๗ม ัZƒwg๛๖D…j›$ƒฦ@[[ฅผD—ชถDD4๔ทม5%ก7` ฆO.|;๏๛ :ŽAณ†ต0˜ถ๑ญฦO‡5ž€ใWิ_ๆ|๖ภผX›GœW‰vJ๓]รa)”ถG~?ฅู•J-ธทaั๕žh~ฟ j!„ัซๆ>็ŒYตH>เ^A[„๔ทŸ=Fm˜‘ดจิk๗eฌc•87s-•งr%=อฌdP๋ฒ’bพ-3๛ณ;]าส~Lศขฑ;ํ™z]BTัฅeŒŒgผ๏xˆรว[ใkำ‹u”Z ฅุ7Dwง]ฎI"๑๒ฒๆM๒๒๒ิ0๛u๏nฑธ xAU“M—๎Y๑ษโz…Jอ๖˜gv&ซใ้T* ƒa•๓hLวa{ีฉSต#฿†ๆ7C/Ÿพ#lM`Pฉฌep4HlŸ์ฯฏa1{DCศ‹นญx<อš๊jภ๗็/•Jๅpˆbี~<ˆฒฒBลษฅlิ~€ัR๒!(๙๖Lโฉ']๗_ฌสืTW๙๘ฐTเใ็ฏฎชก™็ญH฿fy ึ&`WˆA†”ตN{v๛๚„~ง—๓—hŠ3v-าๆGš[ิPฉฐ€S ;ู}ฒถž–ถž–ถธใ๑อฏถkอพ–หVHสสจึ~jeลลฒFใีDลTฆ๏ด1cฎSG).9ผ{ฮ่!"8*ฉผฒ–ะีNบำ์ผR๒ย84Ntโ่ึ๔ดส~Iณ3™โ๚&๒‚๒‚ใV่pก*ศศ”4™:Lˆ@”4™ Gษฬจภจฏ:`sๆเ๔ ๛Yํ=๎gI๒š)ฝq”๔ฦQา'ศl~zy”นOMj๚‰๓uนั€โVะัWซ,ไิ^ยแ"bb ƒAฃๅQŽHp+Š4็gถ2ฟ„Œ—r๓sฃลฬE๔0๕Iู$QOะ`4C๑ิU๊ Okzณน0ไท; ๓dV๏–ูฐU€๕ฯ`4~Dณ˜›Ÿ#:Ntฆ๎หo-าsbc๙ง-#B สฯ›mRG@ฉฎ;|๙Xeqฅบคด†ฦฌhๆ$'KŽจD jฌ๑xh;šน9๒ๆ3‡KHจอ:ธuR‡—จฎป๚๘ช‡๗ูน๘;2ีฉษ฿ -็ศัasghฅ$ทอRเqyOื9]hถD…&Œฑ^ง-ฬล-;~ํ|ลศˆฯ ตD|Œ6\iซ'ษอ-nฐษfL”๗{6๚?‚แ–Ÿ6~xe~ภ,@h‰ O4\b3Lˆศ-eผrŽ|xุจ๙`?u‘{\- ัhjkk+™ ่zXแ/ฆ—Uฆ๗Sใ\ฮ๛ฌ@5UๅE^s/`์‘ +s˜ๅงWKจagt8ผว‰~พถ฿หษVะQZMnธ›ห“Nย>โž๗Rq,svภฃa3ก๙ีๆ่ฮะbKํ‡8ฺ`ัอไ๔%%[๗ด๗ลฝr—b่ๅMแG‹3(ผูแช[YY-ิผ๓5†N!ลฉW} fธฦZ˜${ปtœพ_๑ยํฎน๋u฿eูO? ดZUษุ้Mปท+ˆbIgŽฟเธ —mšฺ{n/c๎5โk ็f,นQ0โ@ะลฬŠ๗›ุmzzส๒;%9>Wขถ๎y"ลZ๗`ืQึbT6iฒ…mšl5๋ผOธŽ8z1`‹ ฆฉ8–S:วฑ๎:๏วG8นผตข–&=฿{8š€’]~p^ัๅ1อีI.s์L>m?ู3ๆฬY๗ลฬŸ›โ@รฃ‹f;“ู่5ฦ{ั9z๋๘r!hฎ,>฿#Nห2 __ฮน:v=ะ‹โn์u=ฉ. v0D™ึโ๏=มญXๆ€ิ^oญฐ@e! ฅอE๖J.bจฑw–qQ5]?wXz้nฑlฑปPT์nTDEEลFE lD้๎ฎ%–…ญ๛~ ^]ล็๗œ=sๆน5qf†Yฬ๘|ดเ]1€@O๗ขปาบฑg^ๅไ8`dosฉ€ฺ,FYก>™ู<ศ9•ฏธMa๓};ฏ6dwi๗.Zดอะ๓'#3ฅXูoฯฏ>P๒9–ธ๕๏^-YbE\ภ๎^ล@๓ถอฬvยN*ก6;๔ไบธ(๕9pfโ•‡1vI๎KN/ะbท<๕kMพ๖kfฯZ6ซ็y|•—๛แภ”3"์๒ไะฝ›ฏๆ4P–Q.S“ัะ‘f๎e‡]:งฎ~ฺ%ลษไk๋t๏ห5Š“ส‰“ฏ”ลัทึ,€ฎ)+?=ั%{เห.รั๎9 ฟ'บdสฌ)ฮ๓rุ๖แ็Osฐ[ฦƒ%’-ล๏3ถpหศพ`ฟ[๋ไ๕่=TVNฤญ•Nซ€ธj^๚cฯ,ฟ”Eฅw๖าH@ Œฮ‚ดGป™฿ฦภ๘?"ŽY<ฝแYปฅ|}›ฟƒžโg{HฃฝŸ๖มย๎q- $ญ•—/ŠปY๙ง๚งะ2๊žŒาbž)์ห…๑73uา๐๎lรๆ?๔ธ๙฿ผiแะŒ฿ุุ‰}฿๚nฅ•žb๓wะSไ36$pฉSะk;EQเVว_ž๐งยภภภภภภ๘-`ํŒฆ๊สQ๗ฃ6=ลO^…์™ฒ็O{ั ศMฐ๑ ŒŠ๖ไyึถ”๐฿ฯkิ๑…k=Sโƒ?```````````tฌ€ัY@๛ัทปjืภ Iลr‹‡)^= IDAT๗ณWฯB/œัซqงiŠม,ื[๗_พ ๖uu"จ)ฺw๖‘๋wC^๘YiFๅ7œจIoxจf*ู๔Ÿบฮ๎"บ๕ ฉฉ7™ฺhธ์ฝ๖ahxX่‡ื–ชถีQœ~๑ลใCcE›7ุxe‘R๗๚ูaF87Ÿ ี(%ฎป๕dงy7-ร๙+ jR็ึH๏uอ9V‚ฟตไT—\yโd๐;s่Fคค‚ Žถ:ๆ า—^เฎปกฮ jc๛ะ•฿ค7ร ‹-zlเ0๏f„!zRK.้ ะwUm‚9฿6„ฆํs์™พkใq_Aซ๛|ไวื”’Š๒ย๒ฦ#ใุ0PX๙‚VBku\ ˆฦlฏO ™‰ก.c$ดฯ$ƒ2^:iด๛วL=wT้Z3{๏ฐธผยฬิˆ;๛ฦ)4 %ฬW฿x“S˜‘๔ม{‡…,ุƒ๐3เTงบN.(ฮหMy{o๋Pqพยฮ'็ Aeก๛๏“๓ณณใƒฯ/ิ๛ีW}EpN๒ต-Iปe”T”–•fg|~td‚bWOฉ›็?(NตyRRlq+กœอฎีRงฏอ'่.9}jษจ็[h 36-$LSTกถ2sฎ”ืษ๊Ptื—'ๆ€ฦ฿&L)็U"บ‹vNฮ=0t๒ƒ2ผ๚ŠNS.ผฝVษSศ#1Ÿไ<5–zธ้?›7t~ททญวฎ‹Cฌ/ไ@nเพ5u๏Zoฌภิย-ƒ(=๒ะ๓‹๋Ÿlzฯำ$บน@K}tฺ๋mชนหpํfษ ๏ุ'+3kธ_/.ดDQ์wWพๅ28ภˆ‰ˆใ.WกB8KS[2๖v`V  !่UฑงI/xอ{‹*4ํZQฮuน‘:๕ๅKฉ 73>ำp๒ขS7ษ๕"p‹้๏O็?‹a€ศ๕ํ:U>,‰i–dFxมลCดJŠฑฬ|Iyq…ฬ-/‡"๏ิkมœn)ขžˆา๘๑’O}ๅl \Wbป์zm}jŸปุ๖V!๕™นo3ešฬ.]๐zWภ ฮ8ๅง๛bkโๆฑŠีoNฎ๓ผˆทMžl tท‘€๔s6o’[?ารvบl-C{๏พs็ใœVZ”œxโฺ๔/ŽKฎgใt–yŸ;3ว๙m เ‡oนrto Nั—{ฎG.Gั€ŸโฆKlฐึ’จอ/รง{ฮ฿๚„ฮ+#fิล๓๑wW/ัอฬ_5“~ี๎Y%ชŒ~7$Jm๔sF ต:ฝ„*%ภงภำyžงษCจฑ๘Ž๗bU๗ˆY~ฮฆ๑๊ฑpน๔ฒฆ[Onฎ”jdฑO€˜ ผ$๓z \W*ฅฅ ๑l€ิบš~ยฒ@์/T–ฺรjฅ%Š3Ÿ709ภŒญอๆสHKBRปหp่eฯา{‹ญษs—ๅ ƒขx"ว‚ขต๓ฅ ฬƒVปย๊ฐฏ8ยฆvO9Zh า’Bฏ>p*8ซงbu๘ฬ›~TVฮปณ๋ืนGะ IธฦD)ศoฆŸkถ 9ษ-๔ไธฺkหF์ใ฿o†ค๗MซcC]xH$wปฆ ๑๗7๎๏Ž7ถWT’็2-้ไ%ถษๆ๘'ข!…ไ—นoN~‘™”ฑ"ฬmฉตWS๖NK<ๆ]_แ›5:Bsฬ8า๓ ”ฟ†์ด๕๓9wึNฒšท๖|ฌผฉ~ห๓&`l,่ปึz’kฦ ูc•ปd3ึีjฤsว{฿Vg•&ฬT|พm้ฝั:๋ๆ›ใ๙ูฌxr๒:ฯมZJnฦ๋l๗sok@xœำๆ^ัฮ3วN]|ฆฬ๊ภ’~อwH;?ฆ8Nซ๐X8~ฌ๕kY7Vทฉำใ|ีหำžU6Gฯฌ”|เ๊W๐๋2๚ํิฏฮŽ(@Dษr’lzUGฺํœ็yšผ„ืfš˜y!ฝ๔ถใ๓ฬ{xใก5D‘แ“‘๗ช™Pรค5๊๔' x-ฅ๑ FซMf ๋H‘u Rพtpฯ…0cฏ•gิ E—ขHgไำ:P&:๙a๏=ื5ๆN;‚ดด7„ฆๅd''Fž_nุ&ฐlฑf%ู๓tp@ึ}#ฎ|ฺฏxลฏf]ฏE๙;ง`Œ฿Žโา#๋8&๋k˜v0ByxQฑ™.๎ฆvT{[ญณฟ์d$Ÿ๎ไ_วOุ๙ไผคJ5TW5ึy๖๖โฑเ,ˆุค##.>๑R ฯ4ฉCzง|‰ํโต ๆO#€้ณผVN>ฯ9No๓:๋ๆQ+‘IG#ยŸ๛o—บน๖\ €qี5ฮ่฿ห็ผ7ชTๅtธža๙ Z>•X\QิิHRะb'†ึี6p+รซาษŠอ!|ฌฏดO9\ด–‘‘ฬ2p* 9‚ ž ข๛w|้V๔ญF5=O๋Hม!DQ)ชR~๏ ๓–:}๔ณภ,ท&)&ฑZvย&? ƒฮ๛Dไ”ๅฟ๛™ซค*J๓›hŽ฿q9๛ณฎ๓ู7N/่Yฒ”t๎“€Œฆ[๑ืdิ- }%วฎW฿tIA(ฐ0"ฟ#ีvฮ๓ูˆI Œ‡ร‘ฤๅdลสฤ็ถ๙•h=๕‹ฎๆฒ ๙ฝ’2๊'š}๛=ป๗ฉœษชJNสn๕Iพธj๎*ปI๋๏ี|/3ฑ…ทi•๙๑งๅNO฿ฮเ„ธฎ8่Zl~V|˜ซVy ๖ RำŽบ๔X6าbฬ˜Miณ<ึ›‘๘ ;Ÿœา๘Y๋U\œW\Zนซ/ฏ๔v|ศ+.ษM๕5{ฑ๕zbO้/ุ”๛้ั”*TE๘=อ๖์ฃ สjoเOQฝ๋่nฐ๕ผอ <8+๘จ ‰รจงุœkิQWNk‘”hBภti๕'…™,@”ำ4€rุษ~ฬท[2-kPZฏฝ}งพ”๎wช;{|{8ซ15A+ณ;T*บ็โกโ่teก ;๗ห‹็ฮ<หfตUธฝฦพ‹6๙มiพฤ‡@hนมyุdว๕/žท4ฯ#ฐ9nŠ@$ถ$gณูDยทwH‹Ÿhม— mืุัk‹cŽบFw่<นŠ9Rฑqยsๆ>8•๕‹2๊๐:vš๓L™‘หฝฏีไUtฒkผลyžง๙s—@ดˆ”†ทฤฉ–†ไ อ#‘€ู€xDZฝY^U+ณ_ชึ'•N์yY‚A%๑ู๛”‘ 9ŸyGๅขuฅฬฆ.ณข๒่T)5€"žš?็ฬž;ํ…‚๛f๒าeVๆ็69›s้๎;รM.aุXหิ็ๆษฅ๑๛<ทH\9pk๘Ž'qG๒|ึ/ฺ>โโฏ๗ใ‚ฯ]ว“ฦฐํoอฝ์ดW๋€ห‹uJฌŒฐn{๖Ka‘HT]แfร"…žE"ภf๓lบำ’}“:ใAีYโ^Dqํ™go^D&,๖+แฆ๙ฺ™YG!s่ แๅkขภ๓A8๐บฃ1GŒ&„GอฑNบฑไ}  ใม†ืณ๎๛ลKศs๛žษyj6฿Jี dฝaK์ 6“ฟ[ ฮๆnˆ€‚ี้gw7ุ uํิอาฤ_0PUU…แแp8"Z#ญ๚Jสชษ๛Ta>H$๔ว3–d2๊9’’U4๗-^KzฺบGs‚๓ฤ'O'#(‡ ธฆ€‡G9บสค%ฆ˜TŸœšไผ8๕๘ฆ‚ฯy=+ข [!˜Œฑฬ๖ด E€rนธๆBฦแš๏ฏบควW/;jฆ™ิ>6N–joฉ›?่ภb77Sxู$ฯŸLŽหฐ`บRS?0›อnqว๓y#€ฌ๕๚๏™>eๆย๙Ž'žๅ?ผญ}F๙›†ว\ฟ็Bฮง9*ศ/สจ; ‹ ถfฌษz๒ธบำ‡ึ๐K‹ถNถิwน้›ๅ๖ูฎูอฮbำะh4aแฆธ^aaJee%@mฬu‡‰ƒ5U๛Nฺkr๊๘"9`ฑู้6ƒLM™šš๊iู\ฮ6›ƒว7v๑ญ_ขb:ใfMชฺa๘’XŸ)sสสขฅฟ)5สค๚ฯš=Xฆฮ`ศHKW”—๓~ๅŸ_‰DFู์ฆ‡# ภGุˆh๏‰‹ๆXจ“;Jฮ“สŠ ฒจXำ่„€’’D~~แ๗œC๋ ^ผŠ๏ีฏ/?ฃผ๙ พึฬุจDฃษ3ตลไLซ๘5&€ญ:n‹ฃžAฅAฆ๙y๙@๎7sำ๚9}%ศ‚ CmฦJ}ŽJแc! [+IปVœXวŽ8_†Ÿ%g,ฬยL’๎A '>@T“]_Xฮ'9G'Š’ม๑_ qเ๘กฉAกญfใ(˜ ำฆJiŽq\4„ˆ๊Œmk&+KXี%eีœึอลฮุ์9e "Ž(5x„qCjr9_›xy›GsdUจ@? c"‰€้-ัW‘๓Cแ‰ฟ’r–่ฐ9sFศ ’dMLั“ขฉ™LLหฟ•/ถŒ›ํU8Žะะภd๖aภ๘•d|๚$:~ึ *Y@ลf๊ะผ่(ขc{๊ะ‚!Z2DVEAaeำw3#>^nศ(Mห<ผMษ“™กb1มPVถืคkG‹฿ฎŽํ฿ OLๆ—3ฐufp^_8Šฦธบ™™Y 8ุ๖„ห๊Rี๑ถ3ไ฿ฝส๛Aเ$ \&›ๆเpQ”ภaท=š„๕ญ.E9๕\6ฃ๕มแpQ.›รi{pัฟPศณ@*ใหฬ'OSภแE๕ง[๗IˆOไ#€^ซ<ผN๒s™&ิAržิ‡ฟhพุัDNHHf€๒AŸ~w€/ค2าฐ4;ปkแณฟ4p{ภษI•สรึP๛x๓ศC๏<ซบ}฿•’๘ภฝฎฯชเ๕…SC๖ฝ3OaTไD^s๕อ€ขปG๕v๎บ?ƒย(ˆ๕฿u๔Ÿภ"ฑq๒#Iๅ๎A,h\ห๕ฅฮ%ยฑ'j?หWจผm6[R~8/_-ถ ๒YŽๆ–@@ ้!‡sB๘/๔ŸEp ี ฤภญใสฯ๙ wสoVึƒCw฿L˜•‰)„๋ŽฎVฆชา_Ÿ9๖˜_หทM='sณทนjeำโ<-๋/{e)งงฺ*ฬ บ๚ษ~ฅ`Yม†˜;;Žฦ |l" ณ7Mฮฟด8šQw"hา‘•_ฏซt;aฐsฯฝ…โœขุ‡{G๑ปC๒ƒ.g]ธ๓f p๊๒cฎํy=–ั>#้‰k“๎ญxRะธ–ซืพUฆ/ElF ฑ,HขE๐ล9๖ึปฮง็Yž| ™z๕ิˆ].wฆ“k?Ÿ\ถ๙แon้f๐:‚๒น๕…\b†น*;)oˆgำ#ไว7ฯk๙๙^๙.มจ:/:wฏ"ะPูz+msจ6›QVEจOmh:๛๚๊`wa›๕Z๛จณ„๑ๅd~๘_งถ.ภy“ๅษSฏาๅ๊๒ฃ:ญ๓lžC46๊“š฿2์_Ooิค?๖ฬ๒๑KYTzืiฟi็ฃS00:ฆ>hšก็OFfJฑฒ฿ž_}6 ไs,q๋!฿ฝZฒฤŠธ€ฝŠ€ๆปm›™๛ํ„TBmv่ษuq P๊sเฬฤ+c์’—œ^๚…ฮหSฟๆะไkฟfvดฌเฮ๑n}v”@่ฅฉฏ9y$@๎Eงฦg.ฤฌกgG\บ๎I ๐xxวTลŸ๗‰o/v๖k/๐๒k{แา_ฺ srฺ _}B^D_ๅๅ~80ๅŒป<9t๏ๆซ9„eIัๅ251 %็I;'•'_;)Šฃo;ฌนY ญึ_ˆ.ู_vŽvฯ=ั%{PfMqF˜—รถ;•fึฃ Žv3=xื S>0ฎv฿๖สz@น๙+E ๗ํ9ซ๖w"ใœ†ฝ˜ผๅ/ฌฯ๖›$หฯ&~šเX Qc้™ำbg'œ๘ฺm"๓= อพ”๎ษ(ห฿;ใ‹็Gชตฐ+๓~ ža`ดะrืM4มcžฑ๊=‰o^ฟม้ฟvbี็Y๒๎ษrุ(ŠZหq้ซขvDGŽ๏vo/ํ ๏6™๑ฏŸอทฟด”อnMโ๕}ษ˜ฦk?๐ขด๚ฮjl]ฒ๏Rpํไ‡M›ลฏ-}}่[iCwe„๑ว๘ ๆOc``````````๔ฐ๑ Œ—๏ึl‡้๙ชฝฐJลพฝ๐wd„๑ภภภภภภภภภภภ่,X๛ฃณH๛ั]~ึ/h‹Y‡BD~„ฝ๛MŸ ง<\5niBTๆไv๙Qะƒ€;งwOี&๓ืDฤ ;Ÿ๓{r็๖…-ำด›vOไ)์Uว›zำL{ึš๊= Y—Ÿฺ4ิฝนฌ๒ยyเ-/7‡1j]7ฑ …I๎พ{FŠ|_ณหฌxj–\‡*Bฝf๏?{?่Aเฃ34บdผ—ฝศ ะะs T~ฦษ6TE็\ิ<๖^ื-H}ูl"!ฦ7ฤฆ๊ต๛nŸ}žZs'6–Qƒ:๗„๎{๚ป/kฮ'ุ*Š =ฆฟ]๓]ืK~๛c=€,ถภฯ`๕ิn~”~Qสศํ:n๊o9ฆ2PฃรJ็510[๔?œXRY^X|xNํึ4ษZSO|ฬ(ฬอM นบาจๅkŠˆ›์z‘Uเ1ฆ้_ู^Ÿ2C]ฦHvง{6฿2ˆ˜ู{‡ลๅfฆFู7N@aๅ Z ญีqu2_ƒ•q‡๎ฟOฮฯฮŽ>ฟP๒ƒ๚Šเœไk3ฤ›์–QRQ^XVš๑๙ั‘ Š]๕ผซ๓ไวo^7””_๚=กš๕ากลW์ืฟขแ&๒œ5~ฬ“ู)[WH=9K!^gžซหผก{ŸV๑ิ$qุbžๅj๋œ&hพุ๊žนq ฎค <…๚[@ 8WOO์X ใ็ศ{uึ5‹ว{™฿Iๆ•E>ฅbฝฌึ:;/ส_|!žีEลแ—Ž•1พิ๏พy๐ฬbฏ<,Bษ][8๙œ‰็@ญ฿๊_็q๘^Y๑'9ป˜ธาkฯH๗ฮ@ใ)uy#ฎS อt€ำ”]ถOึ๐MVT5มt…œHxฦัญ๕ˆŠ๔‚ร๒&*I&k•†#y‰m๏TฏีO>ัq}D4๐ฃ;ฏp๚หTusrฮบ1H–n”อY]˜ฯ๛uyM Œ i.Cแทฉ๐๏Ey๙น๒>3ŒงgŒถ<๐<๕\Ÿr๕๙็Nฎฑ$ว|ฬkัS›ดT็ม จU)‹,v>๓c „ทฒ’ืtย ƒ)ถูฐฆ6}ฮฤBฑอNุี๙ฏข‘ใ”ซr_|@†LViำฑW™>SUฌตฐwถ7€๙ ลi็็ฎฝ]ฤณ@๔ื๚ู•ฎq๐ฮƒ๕—็ฏZ{๛wlฬL๊ฅWพฌกŽ ๐ฅไะ0@Q>B>๐*%5ๅ9p}ะ˜Bwๆภ’ฯŽฉุ.ี๛่ผฮ3ฑ'O & ihัฃถิ3P€ฤ"๗YฅDชยจcคUg”Rฅd*9…Ÿ*๎W๖Sำo=โ”VWำWX่‚„สำ:้๙+ ่จธฌถš๐ฎ4fŽšžZa~ๆOjb``ศฺ>๏ช†วfhะ7O[แ—€Sฑ:|fM?*+็ู๕๋#hภG’“BOŽซฝถlฤ0พ/Yณก"nKขq>ฆิX1+{๊ฝ๋TPฌฅ๗ร&EE๑D". Ek็K˜ญv…๑่ ๊iตค(ซ”Ž๋cฆCm-,ฉHย๎%ZXศx‹๔ก+ำZ˜_๗:g:FOถต0ท.$7`B๙ึยฌบงaคม“Z 3้~%5๙6 •fz!zaฺ< I >๎›Vว†บ๐H๎vMx^H/+hฌu ฝทุšš฿RฐลฺยาฺยrซหnˆมขMฦ GlงL_{ณv์๚Y:ŒศฐMSS €œฑ ๅcX"อคฌดด๑fžไ0‹๛`หฌi+6_I3ึฅ”f็Pdeก![ฎ[ะ คdค rrQˆ?5ฺยr๓รสoLฉXY Y7o๚ฦwŠvs@n‚ํDฺ••ำฆฬ\v+ปะgฟฦeดฃ“n๑E“fฮŒ๚s] IDAT๕$‹ำ"\ฏ๏:oโU^ 6;g๋@้#{K๋)n1—‡-,ญ-,ื.๚ตาuฤ๑ยlDqา๎็ฝNช-ฐ&แ๙ yรฏ”ฺ—'เ๔ค‹.Ej/žA๔= ร(uห6D"?Uuฝ—ซZำ-ศx€บงkณ?V "dY 6ฝ8๙๏+“r9฿ZจชMa ๋H‘u๚4คฤ๖จ>y’(สชbR,ถ(๗WdU—ล๘ล5t^ฃมมC…<ฆ่๊;%Žqœฉ b3]M#์๚ฉ๖ถ8Zgูษ๘ คu๛ฉIR๛ivํ-Aฅฒ‰}ฏ}HอศI>3K›P๓่๖ำไ6ae๗๘8โสงŠWjึ๕Z”ฟs ฯฦFgแQศ™‡.‡ี DชษPร๊˜6ี}ฒลš•dฯำมuLJRฅชซšยAho/ ฮ€ˆM:2โโ/•๐LC1คwส—ุ.^ห฿„*n้hง๎:‡ำyฃทฬึ' € zณ|ืฬ™ฟฬ5Aืษnฌ$M2‰ฬๆฐ Tํพ}TDXl‰Lๆ#์<(‰cFh›ษ`ฆ%4ˆH6Žฝp?าีŒ„๑BF"โQ5Y(?MŒN€ฦบ/ฺr=ŽV_W้Kฎตฑฏ–dhา— fj,๑1ๅงษ 9W‚Z.ฤk!เ„ L•Fj2?>:z๖e%ไไศสHฉ๖า•P1๊%&+Cอษ)เ9WSkธ๕ฉ_˜ฒr’PSXHGp‚ํญซภ?ญ’ถVู‡ค*6ป6;ซฐ้Vิาฌ๘šBGูeฏ_E‹k๗โแ{Eื] uVู๑‰ฉ๗3Tทษ™S๙yรฏ”ฺ—'pใขฃ๋๋Œฬศศ ƒA$๖๐Y dŠ2ปไ๒ฤS๎te;c‰ฆ$ $วฌU฿เก@ .ุมMฬ”ฯxํ‘โZ๔ฺิž๕5&!Dส%๔)าย(‡๘อ่ผ&ฦอMฏ๓Š‹๓Š‹๓rฮŽm‘2฿๕MฆsiŸรฃ š††EOขซนฌยG~ฏคŒ๚I๑$_\5w•ค๕๗: าEDpฐ ๓„•กม`‡ฦn‡็ศ๒ัฬ}h?ขywิึŠ›7๛t4ถฯ๎oBlแmZe~iนำำ๗„ท wถž79๓ึอ)คqพฏ่\ฏโโผโา‚ศ]}๙k๋ํ๘W\’›๊k๖b๋๕ฎFฯถšฑษุ!ู๛csธ…^อ;7ฦ๐j| ˜€‡้ีจ๔8$็œžฤ๑าLg1๑x|›“฿O&ฐ˜L&/aภ)Y)O%€gฃ…_›คต‘ี%ณ„U‘#มดทต\š@Pwสฦ๕ึjD6 –จ&ieุ‡์Eฦ}OTอO!1š<ศyฒmลซึuฬทŠ@๑#ทซสซVŸ›#อฮ}ๅ}๙|h.ป$7[ฤTMEฆๅAMmY‰†œ ŽขešCtธ(Šรแ€[›ีkรy๏ๅu๔’ุ“'ฟ๐OJ ธœo;—‰Dข์็ #ู@`%๐ญ6uบ@~(—v=๔‘Y๊ฝเ}/aฯ๔|Kฉ]ys €rk#uจ๛\“งญข‘•xํ•šs๛3?=.๗นQ“_๙Q…‚่Z้RตwR้ฤี-ฯBู8ว ZHภภฃl~s:ฏ‰๑_$ux๓rฯOD"Qu…o˜ ˆzv™ŸhIพI฿ษEQฮ›—พVฐก"๔า”7ฆpฃ˜ง*Ai>ฯ-WพใI‘<Ÿ๕‹ผฦฆฤzชnฬ๗"Škฯ<{๓"2aฑ_ำธaุXหิ็RขMŸj๏ฒ0ศ%๖ปƒŠr‚ณน…[" `u๚ู 6C]ฟwณดๆทตD"สแ4Wธ\"‰P]]Kสแp๘i–—แ%ฉBu@•’*+-ๅ#์BžtPJ<5์บ6ฅ„r9d‘มใX ฒ"k;aHชŠI'ึF2‘มฟฯั฿@ ซO`QT’UU“€`ม†XZZ๚M Œฮยbณำ=l†O๛ฎฤtฦ3 |›อเkฒฒขขอŒอๆำร&1แคฯขไu“wT-ู๘f๙€จU +Fyํ‡uJฤ๚Lฑ๙เ^„ฒh)มoส\Fƒ_pใo}‡ฅฝพศo๊TVTEลHLPR’ศ/^–h}ม‹W๑ž๚ @RFภ[`uVญฯp Y2‚ฃhŒฌ‘•‘ภL๘œl`=US”, c2iคBืT>š่—wa๊g๗‘ข(Ÿ:๖6ฐ๓เGFPข„PC"S‚Lฅ 8fb$W{U#ซ:™ัฑ&ฦ๗ภใ ‚B‚Jฆ๖฿_šA•W&แŠยยLL่—Qืฑfื@ศโบ“Y‘ฟI@”งnXeeค$AdU—•ืp฿‰ฅู9TSใบดิ๔4ฤl 77ปKo;$!)Eยใ๑xาฆฎ:mใ ๋\‡7ฏvW”Ÿ/k2DSRReุาšึžศฯศค P$ี'n;`ฃว/Z‡w”ษ๗ข)IUนjฮ@ Ÿด?ณ.9Ah๐lŠNา\าTฉ.-‰'K้฿‡Y—žF1 (Dฦ‰๗ฃษีee„Xฌชฮ4แะŸmฯห๙nะฺ„Hณ)A(โ๑ำ๏แ…Tฦ[–fgw-|ถหใf๏ธX5ึb๖ผ ๔ภŽE๑<ผู˜฿&!NUNไฅณ‹ ๘ก๋%• ฝ–‰qJ“ž:R ‰ผ4๋_ปำฺ์p๙Ž$;?สgฏO สOุ1‚CQ.”Tพx*:๕|k=#๓‘…šv8ปฃด (ฒZhฆ ํJ~S ฟ&/๐8—XศE/ฎ>ธั็ฎCEใ{ฦ๎:็ ซึ/ศ‹YhS|ๆlำPอNฃพย+`YCUARุฅืโ˜-9 ฟุnฟญฒก:๓๗ภ @sฒAM/;QLห–•ฬอะ_ด€WภŠๆxP๐โz๖ษ๋ม๓€SW๋ํ|เVB=ะฒS๒ซ$่)อฃƒดงW๏ แrห&๋ฮ{แ“ๆ@ํณ3๚›Y"ŠgE๚žJ็ืzแS ๏ ฺแrkZถฑG๏วM]‡;วง7Fธ^ X ™—4.ะ๔3ฐ^๏+–ฅดฯฯ-a|ุUYลOุ๙R๚I—z ฬ๐ำ…2*็ธๅuัny15R€H,},ัข๔ี%ึ๛=่8๊-8 ]ํˆ%ิ?ฯฺ๛ ไโฦ]ฮ‘wTrผLเึผq-hY’ต6ฏฎผšะมdOฃำะ|ทm3sฟฐ“Jจอ=น.ฎŸ <๕kMพ๖kf‡+ๅ^vุฅs๊๊ง]RœOพถN๗*Fนง[ 7is ฺkถŠchใฒ้=ณ|R•uฺฯ;8ฆ<†[|{๑ฅ}qํ…g6๒hฏ_ำ^xhnt{แž Ÿฺ ทŒo/, เัC๓๒7;ฏB๖?ธs…[Ÿ%zi๊๋cNอvDcฃ>ฉ ๑฿‰ฯฟb็คrโไk'%Bq๔m‡57‹กี๚Kั%{เห.รั๎9 ฟ'บdสฌ)ฮ๓rุ๖กkฮ#฿xหัnฆปวฎ๘KAฤ”ษH-G {$`ANBO^๒o… ฃฆŒิิR๚.8ธ‰xnขหปฑ‰รท<ูf๋3: Dตฎฎข—fœแ๑f/ƒ•R7 ฎ๛†Ÿฺฯo…ฑ?ฯTka•Š}ท;…มฑœsL4มใืึ ŒŸ็›ื๏ฟบฒQo™ฦ8}<ซ„๙dึx๘=H Y}ศถฏ@Cqา3gท๗h!ณ฿‡ฬ^~๓6EQเึ${IำNu`ฅ„๑฿แ_m?0ร๗&๐พย๘•฿4็ŸvโทS๒๎˜ปcฺ‹ฟฌ”0000003`ณ‚10000000000:หฟ:€๑OัดF‡ดc````>ฐ๑ Œฮ‚ต0000000000YprฆsWญZ8T๙Wลuน ค;i๗ูK~ผผฯ๏\jFm‘#ย:‹Nผฟพ7๚ˆส๔3w›ๅบ๖ท๎๘฿~าx๘ฌ์หW“wFdอ1Nฟ๛เึmฯร›ฦซ“๘8ฉนผฯ’1ญŠHNฦจฌo]Š๕yกr:w‚ผฤฤ]บ[< ถน๋ฬ/D~Šo‘šชณqแ/ย๘“ษ#’ใ\oู๕๛ตัpทฉฝย๓๖'f+ตี‘ท:vวsˆ–ฝqtํoนฮ”๏ดŸ‚ฺำw๗พ๏ํ็ตช?›]„งอฎา ~ถC@Wjั™๛๏๋๏๒Pท2kฺๅฅŒญฝ๓ŽถS*ƒ5ฑ๎ีจ3้mฟnฐอ]fคเŸŠะจ;ํD[dm้น.๚;ฎl9ฆ1ฦ˜ ญฐังฯT#€,>็F_ ^l+ํN“7"ย›zmพฺgร!Us๕?q/ษ-Jหบ`๕ฃลซพ"8'๙ฺ ๑ๆc หห +io7้tœr€kสK'o„OŸ†ฌ5๕DภวŒยฤซ+๘้)ฌ|A+กต:ฎNn๚7ู๕"ซภcLวTฦบ>9?;;>๘Bฝ฿ฟฝ๎ƒ2J*ส หJณ3>?:2A๑็ฮใ?…๔\฿Tญ„นญ7_ขŽอแ‡ฑน…Yi1็–๕๛Wmn๏๘รๆ|ำKšญบ๒)ฃ0;3๎๙ตu%›ๅฒSvŸ;ฒด๋อฦวน7ZซฬหMzๅฝ~ XOฆซ5>ู‰๖6„ ญ๓‚Jt็;็๋ฌ3Ÿธrcœ์ฆ“าK้‹^6Qจคฌ•$ืหnฝo^{ห฿h๒ฬHbฌํB‰ฐK7ๅโT&๎:บdLฤ๎'<ผค•1Eฤ‰อKŠJEสvพ๊4ค๖Šิgึse%ง๏Rš”๘"๓gศ&๗๖fฬ/]ยต•อิKKf]]๛[ถ฿*•Dxž.oˆํ์6ฟ฿๘I6ŸบD๔ํชล @jู_ง‹6ฟทอ.า ~ถƒ4ศN”~0˜Iา•[ฑG6}v^2งgซข›{๚ƒdขฐbซL–mถํW;ˆ*ˆ|Ls จว)Iฯูฃh•๖‘F6^ฅ<ค/Rาzณา€ฅฒ๘Tื&Q[~ษf๙ฬๅ9ฉ€โ5 … †Ž๋-ขF€๒?u?ฯำไ ฎ๗"Ul3 R?ลลkๅrœ บ๗^i)“:`ด9.๐อฬ%ษ ทฆ ๎]หfฎั; ไwภื”[x์'“GP^~nฟผฯ ใ้™ฃ-6Oฝ7ื‡็R|sถžSำ2X๐ฒ˜XPŸ๎ไKrฬGuŽถ(,๕pำ6o่no๛[]‡X_h”๓๋๑L-2ˆา#=ฟธฮษฆ๗?}ž$'80NE;0Te้น๓หŒ๓ƒ]๖พถZ๋xjE์€EจซWทีซON็“\x๔a๏3๐ั^gˆฃ–ฯ๋Y๕ี`m( //่ฆ‚ฯKLkฅ^tt_`๕`]๓v[4ุ%ฑ งำีN $๗ฃฯะ‚z›9 •W”€๊Œศ—Wถ๐Œถ*C6šต@ๅํี€’๏ฺmงษ3#i Jl่๓Œ&ซ*-๒Kฉœผ,okUeLa ฤg฿์3ฑเล h“€H‹Yํิzตฯ&ตม:๘Ÿ•„ุ”ฃ}v]ึeAๆ{]‰5อฺจ บฺn]Nูวh‚บ p2bv๗vอ`ห1u ฦ๖ล๚ผฮpC ›ฃ๚;.๋ฮ-€eน5>}ืฬฏต฿ง๏~ŸฆA^.u!๙฿ผ…ฅ๘หะD ํ€พƒหtYA ปฯ^~๐ะห๋ิ†นfฒoy‰‰๛๎ฏ5ุัล๛ ›†J๓ตษ]๛[wŸwfc,ิ๖)๓u็<>นmŒbซูสฆ”ต[ภMq๚๓.๑~tg็8*_›rๆ๖}/๏๓ๆ6๖ัŠู๋yjฆ"€ืœ}มkอส/๐๓')‰,~๙ฒษAkใkrPฒดP ีGซญฎใ”ฝ)ŒŠ๕Q็›\ิh–๓๙‹>7\ผt๙๒ŽัB7รlใa›ฮ]๕ป}jง•2ฬV฿฿f3vใQO็q†ร—ป]>ถ žฏัžQXจ6ๆ5ƒมB้™ี™ๅ$I`}.>˜๑,‰ำJ)‹.z๛ถษA้Iีน\ฒTcŸfF]ˆ4€’กPEF9‡…็i๒DXฯดำใฺง<ฌไ *ฺ[ฅ;kูrดfศ>„a#”้>ลซš^ค๚{ขฟ8›ศŽๅ9ตฐ09๒มv‹ฆทาื”Zู็ k-ฟ7สย+9"?แLxraึ๛k ด;๘๎โTฌ\Gค็ฆ%ฝฟๆ8 ฅฯ$'นลd$พ=่ฟตๆ‰€ูะ~ื“h๕ e Sโำxฝฌ ‘Bฑiถ&ฯ]ฮ€๒ธงป&ฯNใ“ฌ๒@ ๓7<ขK๊๊หขฎ๗2›฿ป๎ฌาะ7_%•๙Ž‰๐FzุzŸ๗ฑy…้‰<6X(โ๐ำฎ็ำ>mืkV>›ทฯHKฯฟNL/*J‹ue•‰0@ฟ]ฑด’ืiVGƒS ำฟ]ฉG์Z๎ แแ๛Nƒ‡7k:Tำ7์K€฿ร..๎:Tสร†ช6‚–ฅ~๘*่ฏ๗รจ๖๕๔ต%นทv8y๎OฏKฮญ5๘j๒ฬ(ๅบƒKp"ขข&QS]อKv‹#N$* J0@N$,Aฌ*eเ๛.VVNษ9น,ย}๎@GูๆqGrฟqไ8ทไ3gkไศj๓ซฬˆเ…˜œ๚ๆ.แิ+๑W™xรEส๒ ูงmใ/xณŒๅิšjฌฦธ๗๛\i’๓e{r‹Nฯ๙r๚ฃ:(m๗œ/ป็คผ-.u2๙฿ฺ0Kา—)๔%JYญœฮ๑฿ณhžใNฏD#–J/นภร=๓{d›NถP่’อคs๓fXY๏z๒ํwAa๔Dู7ฮ๋ํŽลiฺN3i}5[, pฒž1๛l,๗อq+๋Vึ[Š;ฐูOŠๅJฤSหf.]๋[?eณ_› [;อธำถณ—ฏ๓ฌนeVhฯ/=@ง-%)=qๅศผซื#่ฟฦฯŸ€wณ<ณA(ฝ(ŠtF~€Q eUฑ(#w(™(ฒชสˆขT~ษeว/Oปพv๎œE๖ทs‹๎ํp~๘BP3Vเๆๅ๓ถ‡+ฌฐ@ภ้JŸนฅ1wม๏ฤ tฐiOจ{ฑ53ช„dฤ9u5ภ)ˆจLษฆVpท,‹€ BZย๒Œบ‚ฦQั๊š4–ˆ–ค€VofZB7;“๐$! PDๅ๛๊ส75…฿˜~$•2vGเŸk$๏ํบฯ?dE|ไยIฬ‡Wดnjฅ{ญ[ฝr๕Fวญปฮว+-[1^–Ÿ&ฟŒˆ2†#:ํบtqฑhะ๕ |>y—1iDi5มšืx5A1qญŒ@–Seง„ีีฃhuDe†ˆbS3ๆvIZ!ซ๒sUJฆ๒ CZwfs™\ d9UVJXษฅEWe’ไš:Œขn—าQffm.‹$!ฮห—:™ฏ ืศก กo:ŒไBpADB‚5ูŸO^|R๏mˆ{’[ึฆลง4@ซ %ฐษโข๓+‹"?ฦrๅZOุl๏งผ†FEไ๋4:ส)๗.FLC›๏m#ฏกQ๑UJณก$"+IMCอ8\z๑แำ9๗ฮฟl[๗3~$‚cี\๛lw$พ]˜ษ ใl”K (PdDP!๒ ฏ)*ชCp8‡ัีi™ƒ’|Yz-ท>=.‰)#+ภMˆ‰ฉฏฏฏฯŽŠฎd0๊‰ฤ  ื—นJcํ EกŸ ;Rฐะุ๏mธq๑แ‚์ฦŠ7ยL๛‚ำ!ฎAฏI๏Yร‡„#rP.(ฏG‘F9l{้ท€˜Ž๘94ŒS๙โEจQ๓จช‚ƒ"[!PGZจ< ภ j6ูๅCY]MฮหฐT99>cเ›<๛๖ม3กiEYOยธาาk=๕‹ฎๆฒ ๙ฝ’2๊ื%บxชขแ:7[ฅฯgŽฟDลผคฌธฯp—^'Vuœ๕๑๘@\=”>ฝhูขEห-s:Z.;p๓ฮน2ผsjฎจ M:๑vฯ@ 'ธy#$ญ}Oึฺภœ/Wf@ศ6ิฎิŒ…าŸ:[=#+sฺตูโ๚šg'(ฉฯ‚๙Š/ŽธดบปY5ฅฅMฏฟโภW้4T*yj๒ฬHศxีแm&EO=;r=:ญ‚จ`V‰๋จใ Bjฤm)๊\ Eขž@2คkภ„ิภฬkชท ๆ`X.ม๑mฬฃm:ร<ก%9สแเ๐„o•QA๘E๑uฉsษ‘รkC7๑kษ5R๚ไŒ—โฒๅn3ฅุ๙ o๏^ฟ๒:ฟmรณ๔ัฮ]ดษท้แp8Bห S6[h๑“@$สLุsj8๐๕%ษ|+C"๑.ฑู„ๆฺ2'้๑๓าiณ ฎ‡ถ‡5~ ŒงY[ž!‚Šโ3vชภึ์/L.เ๊ชผfWเอ๑(›๏3‡ลgk;บ]]TG/M8s.ถEMท2สๅโpๆlผึbํ™F QAๅw}ซ h฿ ๊ฏ™ฑ๛"(/1eƒ*ฒ?ซฑค ฟิJm–ฎ}˜L'๐โู้ฐธl<เ4฿ๅ4ผกƒ{้Gpด›ู๘G^~q๛_<~m0zค๊ฤล9ล็มยGJžน^P๘4iห3$Dฮา ๔๎6€ฐ๑Šณn ๕ˆ,&NL ^uี~ษู์ฆW^๋—@{ˆDข๊ ฿0)๔์จ–^ZR oR‹ิIรป๊YOไA$Šrธ๔ต‚ ก—๎ฆผ15€<ฎp „ac-Sœs๙k๐,บ‘M฿j๏ฒ0ศ%๖ปƒ)= ฮๆnˆ€‚ี้gw7ุ Mำแe๓๑๋๖™>x|hญโž้.฿†ึgฝpYถ๐lTFf 3„ยBVY๒‘‘  ใy›ึ๎E ‰ิฟ"€ข(pนภแpŒŠ! IDAT‘›กGก8TO„ํAษ@de@ฒŽฝโ,o:ฉJTvqAUใ+‘›|~ฒ๑C-ujC~ฒสถิP@‘ๆQำ่ภฃJใ•– ิีUฆNโ1๛AsๅฑํฉE{ู'๖Žวq:ฮ๓YณซP}ึณ.<Šอsy4›•yทฺปุ~ จ 5JI(GูตyŸพะV˜๔‚ืผ4U๛๖—–•9๎3ญ้ฝ@ญป+๗อด—xด๗QฺT3ๆฉน้ฃZ๛ŒbL&Y•]ž{๘้wงŒrY4ถถ๓m.ƒฮ5”cว–สๅ4„I~รทwมใน~#*ต /@hš•keŸ!ูษW‚P.ม5?ึ8สํp$EiS…๚ฎK'๓Œ†)zใ๐:สๅโš`8|ณทŒดg'ท=‚ฐฒแDงํซฦล๎โ9๑อO ฐYอu”_dณ›]๘p๗†฿ฏ็sุ์–มใ๑-ี’กอXrRžฑ•B๘ฃ–‰คฟฺฯNC04วg…ะซQ”‘W“NS์ฅ_"ูีxขจ@ลจฌช2>ษฅGฎ์iํl—vQŒศขๆฃ˜ม+3ฃ้฿ำิ7มๅผกื (ฃ :ณJI[b;TRi_ณHตัLdภo๗ท›ะ3jˆฏL/FjYี8ขˆ ˆ"ฬช_:OใN‡ฟซŽM฿_้t6nฤูไฅ–”๋๗่มมE~–ส™G>ตซP˜{ภพ๖@UY‡_Mบ่ว๗“ˆD‹oี”ลfง{ุ ?žึ๎1qใ ่฿f3 m๔_F@บ๘“ผๅ ฺ{โTฃฺ7๗_fถส่;t(ํ๕ลŒL๒.:้ ฒจ € JJ๙๑฿*ฃ๕/^ล{N่+เz๛;—ฃuฆIkG๚l‘ำ3Ÿฒ๕ฤ‘‰ป7Nพ6็mV&ฬ;VใUOฅฅ Fˆฐร3๓&žw_ิ๗ล๚๑ำ‚…— ZฏญM<žL&๓ฟr3๔dศส56ฉแ}์n์Iป๏ดฦใe=Ž>๎ปX๏2r๐๑xฐqjฺ งใ๑ˆ‘„0@Ni™ภ๔‹i๎cข๖š|ฑp8€ษd๑พ๎CฦWHJJpr?$-๔ศ,่่Nfไว}‹๛€ผ?ธh™ฉฉึ’K-4tฑ6สQฒpXbญCม"(obคRฤืฑิ[‹ญgXYฯฐฒž1๏|B}ศ+๛;นีlกพ#$ษ’„๎จกjiษ|4yf$,,สช(๋ิz3LZ…ฎ.Ÿหฮฯ$(ฉฐhUะPœCT7"ˆสRำ6ศ(7uแลๅx้'ฆฮd๒‹)gาณ2„Mฌ…„ษ8AeชiNN ซัฆ๖@!!"NฬH\ร(ช์ศญš2ฆ`/QU*ADž,Œ๏ภฅN&ใM,อ2B฿ทj ”ห™ซKHช_fcึข‡(Nt\:ึ@Aœภฎ.ฏจแถtฦf— ศ(Šีt !33ฝ๒—ุlOAV–คก‰< €ค:nรฎ)บ|/\aV–ดษP-QYฺt€''ณฏ1ีฮ4ึcวฉ๛ศd[ห–(ซ_๎gงแ๔[ญ0P ษ‹hฉ2ห‹ะฺ๘ณiA๖™ปผง†ดดZoQ๗Ÿ~uy^ZoไซJ*ต3“ๅ']๘x๋ะชษ}๕ษภิWTฐก$ย–ึีญŒปืะ„" …8Pะ6่๊8ฒ—<ƒ-wมชมCๅ๛ฯ^ฝ`แŽy}Š“พ็28Œง0๎ล‹ฐ/ย^ผH(แ0ฉ‘/K nC @ฒดiฺ3˜!m7ืm๚ฺ-๛—น\้D๊๋7์ฤ”|’ดใ"๏ต‹๏๕IZT”˜ษF‰ฏรj@ฯuืั›ท“Fณ>ฮฒ๙จู3gํ‚Pฐ3{๖ฬอKuๅบš=w–•ฮส ฬหkgN`G\:mฟfหษ‰ฒ‹Vœx=เ^@•ผ‡7ๆโ ‡๓ู๎ษพ ข‚ผ`ป|ลกkJœสœpOฤ-!‘ ‚y?ิข๕v๏ไ}๏D†็ำช„ f€•หึpi(.้.6Z3™€ใps๏–๑€t›๎4หt*ฟœ้[H[ตๅF+อื[ๆBฤ189wฉแน-6๕W'ซ˜1yํN^เF–…ฺ๋O?ขJh`„nกฤT‰tฉใมSz ้™vฒ๕๔šg็๎๕^ทใฬ๘ย'วE85nม]—Mมป.7ก(†ท`T~^ฐฒl}ฺuฝวI฿„๋›วŒธ้}~ƒKO•7ˆฒํฃrl]{$ฎ3ฑcv‡?Šญ6ฑ`ฟyำ๘(s_mw;คฒg๖Dฏ๕์า”หซ6ˆๅ-[gบ๙PฯNŠฌ;;ถm 3ุO0c;ฒ{๘ๅ‹ฅqg๑I€เŽmowNsไ?วFย๙มo˜๊#ึฮcV}ธดzฅฮU#้ำcหง|mใไมœ้๓n๎฿qอ็Ÿb๓G๐ง๘๙%ฤ~žื‡%ฮฺฦ„จ?อ{—…Yง:ทฐฃ} ฬาู‘๙้L๙5ˆ|Iao.Œ฿—qฟ#-ษฏ–Kžv1ลฮœภ๘้|Vาท๖’ฦ๘ฎศ๖b๓๐่wญ์)6ŠŸ"เeFผ™8'่ส4พEQ@97Žtr+8 Œ?ฌ€๑อะCทธ…Gm?EQ้๋้๛ซฝภภภภ๘›‰๗๎ฎเซภภ๘ถ๓00000000000›`ใจฐฃkซ™U"v "ซtเ”h Œ€?```````````tฌ€ัQพฅ€ปฬุxeฉMปBDอa๖.ใWฎžนดg๓‹ฦญ‰š}ํ8x๎rะฅS;=GJ€๒ˆฝ7/j๕๑์#6ธธุ%สcฬVNoฝ7"ููวฬAํ JซMูัํŸkฯ]]†Zท{&฿ขำฎ 7ซ๏{ค'›ฆ ‚ผ]4D้จuแฤš~ื๒[ิž่8ฯด•@ผKCสtไ๚รว.]9uฦgฬJ_Kขฅฑ่Œํ†๒?/ส?EตyglฝZ}&๔ภซ+ŽวbM€๕บCf†JภH{ๅซฑV€„โไSถ๓FHRื;‰Œฬ€ๆซญVl5ฐืo๗…าqอŸ ฮl๕ป๊Š’€แ_e{y\RTš—uc‡ณ Fำ.ลคๅฅ‡ํฑฌŠั9}(ฏ<พL=_ฎ๗-!fœพหะ๘ฬ’๒ขยฌ๐[๚+`แ฿!e5๗๋„‚า‚ผไะภyIโ5ฟ,‚@ฑฯา‹o J)‘W7Vog2+Aฯyฯํ๗™ลTjj่ษู’-?. -ศฎใš?•Kd ‹›ฟ,:ด†xn„้9*ู~๓›,ห็fzgฒY์’ฌ9ƒฝž…๐@JQQX[๛;ษ ใ/็ณŒ`6วk|กw๑wช๐† ฏGy๏T๘›Žg)ญมVฺmฮJgฟสB›้ศต=ศว2ิQh-ไรm=ๅึBnม™rdฆชพjk!Ÿ๊Kgชš*Kถฒซำ ภ่ ณชEฅˆ๚์}5Œณvฮฤ›น_~ฒ{ๆ“qAe"๔DAฯ๖ฮน wMด กJX.sํ?3Mh๎qๅมน/GŸjผซ…wฌ(ixื๚ภ๒To๛ม>ข๊ะ=ฯW=xุนSE:~จฯ}{๑nlพอš^ํ Yt:_ฎอCQคลk ื๓ˆ&ŒณยผŠ˜(@ฦอuณQv}uใ–๗ˆคแ&๑ท–‰ .:"‘}tA*SตM๘97(w฿qP)ฅiพ*น๋ณขk€4hw‰๓)ฯ4wj(˜z9+lcฦ‡ DQaฬ2=KE^nHํืl!ขชเ;ฝtถ๛• e๊ผb๑h+M fa๒๓7๎ฦV๐œ77Ž๐ใ^ะOsม7ขJดMDฉงว:7Gๅ๚ธ‹พGยJQ0]ดูY ฎ,กิ7j™.šU๋๗Dg๖Œžสฬคซ~Gž ฤ๛ูคฉDป่{๔U*ํธ๙์x๏ว5 3w)`ี9ๆŽ๙Ÿภๆ[ฃฃkผบO.%\๕oŒงn?฿cŠฃฑœ 2๓้™ำ7R่b\BŠcC2”rภIOสNาR€๘hฑ า๛‚hก9Hปๆ้ ฉ๑:ํฉษZนฌš7H_^JV’U^‹+ ๙็เ+]ืcแ•Agน=&*ผ=๑Jkๆ4ำ฿mมูฟพI๗ j›Z„ชใTต“K๏Tษฬฤฝl6 Srz)  ฿ภดSฆ”%น&ฯ:Cฦฬ–ท†Ng|ฌH๙ŸaWโา‚ฉ๙S‘ธ~ณูํ f$+toDpN"^F 7ซA6Šโ‰D<BฺฃwŸ^ร5jหŸwฮ#ฦŸ…Œฝ{ ๏๒มฦRดŒฐ๓{ฝ}C๓ู8ฝQ{ทMฒUๆผ;พz•_ š„['๕ิDJŠ92ฬอ”ฦ๙„ufœŸ?h็~;1‰ศ๕ีี•zโ๊้œ๚šj ฯ’สMปจด–ะุ๙ˆฝ‰zka=๋e1ฎŸNื6]฿ ึƒrœ“บY›A๋F2Zัผอภ งแงc ูฆกB็ๆ–ยฏŠn?่ชษ…_Iชe$< /œoค บ ขzฮณ์ฎu๒Z&M ะc€<๚ *ดd฿ม}>^t‰ซเฤžตG&Bซ“ิSwุ=Jฌ๚, ฏ2์m’าt]@g ตฮ"ณ(‘๏b‹YV=<ุ0๙๐ฅณ'.๏ทu6Š ++ห'Œ[q4่ิล“<hถ™HB์6n๑๙ฝxŽธเข#ษช/๒~O๒ัƒ4•iF8V}v–ดฑ%@Iฮˆ\—•P\0?>เ‹"kื๘]๓›’ึรH™'ำƒjำ4M €๏>]O#“ฐ2๙์M^๗ลšzMH$๋ธศ})>‡jงh˜€“qทฒ€€ าFฒฌ†ฒ๚N%๒Ÿ†žใbฤœv๚•‡ฯ'|ฒgษ‚vgฉZK7 ai)๙p๏ย%g lGะlวฆฦ ‘j๏mZ},อ`๎X[<d-˜3i๒๎ะบฯโา2”t๋Š;?jฮ฿“ะŽMํA๐ทฝ–/ุญ=wœ  !1:อภฦZ@ฅ›ตLBt& …wVLžณ2ธ ๆ๑๎I“็Lšิxะ2F๛ฃืtนI๗Ÿ๋f˜vj…Š Wjฎš`ˆsฉ<๊๚๓4B5ฑ0jศฃ|~_Mไ/c1 คพSŠn–๒ฺืS6sXต ื.ชธป๓เซฦ|*โvเL”+ฏ&NKธ๏๗ ํcงูฎๅ?‚\฿กH\hdาDูp‰ีบC]ว๖%5•ฟ๔๚\žฌ‘"ษจ+‡’๑[๔ษw 9เี๓ศ–๊[kp้ตDY…ญ๙3ม™ฎุ5.z๛ศO/ผ{‚>ะขrฯV๕ ‰U;เใ 31;ตฯ„ะWผ4งุ๋Xใใ‡ฃํถo•เิxK“vE้์! ?eฟŸ}”ปญพ๙เ AžvMB_ปศeฝ บุบžIoีPP5ณ5PR๎fc,ี~T"2BQภ์euฤR2‹^}>ั๓A– 1f]h๊yดฐะจฉ;ะ,ข‚ฺโBถอ!J8 กอ”UTฤ„VRVแิื5M … อ€จuฆj cOWˆ CPิฯ<+1น“๗๒วMB•st›ญ๛ัร†m›ฯ”\:ฮ”€ ˆค™ –ฅ+ืd/œ=จี+Dส~`฿๒ทaโƒwvโƒ๊J6๐ %จคฒ<๐ณ˜z–ฒxฉnr ‰uํฝฉนI!eู%ผฺDZ_B^$ีuyู™ \a]b-•(ฅ4œpปชฌๅQล|I…ๆม9าcฏ ›sˆ>ล]๏jkL๖ๅพ@mOAฑพฦBVมu“สM ท;แ >ƒเมZ |s“ฆUDš์ทนป$=ษฐ\j`ูfฦ฿฿b:ฐ๓mxIปJUOฏWXฮูx๒๔ก5๓๚i}ัฌzไฝ๓vKํX„M )ๅB฿hด๙vQ!๒)‰ฐูZณษful|ฉUw3DยสZ?!:ตZ}k—#"ˆ-Bพ€O ฺs‰๙๒ะค)๓ษr\็แุสไฏ$"ถ(๙—Hศ r‘L ฎ์ภไ;ด"ฃะh๑ใพปWšSN฿Kk‘‹พ+น๊ธบๆ3 BzยหWX—Z™RJึึm๚ก<…ฎ์ฌŠคะ~‘ฃ฿Oศว!8Vํญๅฉ/sๅ‹ง๊ธๆOƒิoำfำซ›O็๑Kลฉ Šฺfsฃ&^œจ‘ป๏Ÿt|๊}Eyำร”ุ{[ฃ' -ๅd๋ฏ…Ažฉ๖ฟศศษxm๏$S "‘จฟ0๘Ct๔‡่่}™:๊jZšถ‡”nฎ1๋%ฐ๖@D‚ๆชƒPH$่ : ๐้ฒยOUxƒn– ษษๅํF4fญสบ์z9#Cฃ.ŒฌิO~ (tคj#๗ษฆP\ํRZสAFP”]Z—O—76f็w๐๛”ฟ4(† …ธๆTยตดฆX”ฐ;6ธอYต2ีd๑<'ลNูl /ฎ ์œŸbl–'ฤิuณ้าีฆkftางhPํภ"เ๓[ฎรทT๑ฟ€ฌืwPW%@๙ฬโ๘ไ:k;“ovGข%gฌ$ูgณอ–sถž3eˆŽF[viŠ5U8ฯ&~ผ•+7ฌy]้_=โึ ค ฬ๘y้อsVZBSˆไะRฉŒ”Dฮึยb๒่xขlำขฌ"ทพฅญ)%e6@ูH ๗uอ_…๙เกฺ๚หžำh™คง_ฆEฌ3•๏๖ฟ้}5ๅัฒB฿V99ูโ˜ฃืส6Œ๗ˆฑ^`vA๏e‹›Gอ0~64MFฆiฝŒ นถถ€‘paูXGc}๋q[“{๚žฃ<>?7`’ƒฝฝƒฝฝฝE—IAลภ็๊Vรแ[W๋ไMงN์ฏ฿๎๔%‘ABBๅ๓›jh€D"aแ_ 5|ฑ[‰ืเ^ง%”ตญะห™3}ฐa๓2lQE€Jฉำี8L@MUU๔งฺšI9๙ฆั]’ŽŽbqq้ืœCู%/^งvตตngS(ฐ๖ฝˆZ฿ตฏƒŠ‚“ึ๏kฏ_TPภหJอํ:tคพฌคคŠ๕ฐ~Yiyอ๚ส]บ*Pr๒ 9๐JฺD‚ศX)่sสš:ูY‰จัXUผบVwQอ%™ศ้)d5$eฤ& ปขHยธ—ด4'gฅ '`Uะฤ( Hg้๔0ฤ#j๒†Zœฺสฮ:ง@ฐุƒ๚6ชUM ชขBอช—พ‚ขnฟYู๋Xj!Z#ฯjฉ)OะซkยึmศŽุiUM9BPฒณทไR๓ฤฅ|็l’5๕”ˆAัฎง;Ÿาdณ$&Fh=i˜en\|ซ5P5•U2f6ๆสฒJZ๊ bG?ส ”mŒd‰*v=-…Tq5$ึ€…3Gt!ใ!iุZ้–—Š^GีŽ๓?…’c๓โฝ็ล{ฯ‹๗นฬเฝงx{•~พ๒ชABNQ‰ˆวใ๑ธ(ƒX”ศ:r %-e‘Ÿ/c3TJJ'oฉฺMQะฒ€Xศx}€0oJฯJฒu–‘!แ{ชuรั2›/VลIาฝ้ำ‰_ำeฤ{wWPSPPSPP๋๚ฯ‡†k3๚ฬโ›N=ฒ{A<เศFฮƒฬ๒๒๒ก๖ลz็i~ฑu€รแ๘‡ห์)ว๘žPbbไFNuP–$้Mr้_K@L๙๎™ีฏ‹‘WSRZ+h|oRRS5๚9“Hๆ๓ฎ.ท—€‚<Šเ1V๊๊]วyญ&๛ษฎ้ขSมง๎™(#.f“jาSซ๚Œ๊๎G IDATŸ Kยแๅ,'Ž๎––š™Œ€ น|~›@ˆขBŽ€฿๖ำ$dท…(*` ๙ฌึ@BึgBกE…| ํ็W E&ˆ‚’ทดTTีฅ๋’€Kพพ!๛'4ญ UH9.:ฒi_Yไขษš๏ย“ฤMvฤซ}ๆ.๏ฉ!-ญึcCิง_ญ0แฅ๕FฑชคR;ทขำซ l6iผLฯ[ƒ !์ะ์€d‘ยืsถนK ่%‰Wฮ?ซ€ช''ฎi-Yvlบœฐ:็฿นwอ“๒๐]Œ๔‹ ฉŸ:|ณEปO๑†“ปฎ^„ใV0>6฿าา„:๒Hี๒s๙ญ€˜าv๚“vซX๔ปsใD7์Iื ต =F„5ฬ๘@jพธJ0‡๖๚†๘ๅ๚’[วฮ{T๐๑ซtI›ถ”7g[ฯฌ ป๒ุ~ลฆใฃŠŸ|=xิๅๆใงฬYใชฅ@ |ผte;ฯณ›ลooฅฬ˜ใ}v$ท<ใ๑‘3้(ภง—.ธBEm๗ลตำDุฒีฬญgW’8eiœmYถJ‰—Ÿ5เT๋œฤŽธ}พ—๛บcร%า/l:๔\tDฬ7็ฮ›z,๕w‘Teฟ๐ L๗„ฐฃƒ/๔Xฯ‘q2ปฎ4๙๖ูGEJ฿๒๐ล;|ฏบ€€Užq็ุฑYฟุฉ_ฮ@ZฝŒU๑ฉXใฦœ+Vžk่แBึ2“Oค2ิZฟฐzฉ0jพบ›๎ยรDAy}D@Yห–ฌ % 5 "—สๆM๓๗‚๙`—ืศSWโ—+"ฬส์7‡<2€ูธEt๎s๙ืBฒๆT๔๙g-Tม๘ฝa?ูนขษฃัy*ผไ’฿วYฒ๊ฬฐํœ-€Nd„บิ“ืRฟ๏~๒ฅpอ+uaท‰_ —ฅ0๏‘ˆ}^Rก‘žz‹6ตEp{Žš=€ชŒ8Jต=าtDA…ž›ํO%,”eRฃ.ปญz(vEK๑wOฝ#G฿x๊สใฎ/[qนZํฟWฑ ทX ๓+หmqP.ฝœ๒แาฒ‘บ”OืD"}ฐX๎>ล/เF็ ฆ}t๋๗ถlฆิ‚'AIy™bึผ๔nใ„!๒€•๖‘KG}วะ–อึ๛ฬถ€'€จาcมบ1^~ฟว๒#ไปC์ใq~Hสย=o!่N๔ฺ"{mันฬ_ํื_…~ื๖๚[รฌ1FFV้่ค2jฆ่}ลDพคข7ฦ_ˆหธw๎ฟ๙ี^``[>+iพฟRŠ“Ž่้ำ™๑W๒ฑฦร๗@ฆ๏“ธะ€๏Zฏฅ6ฅ๚ฌ rณฌงผ บ}ฆh9{Ÿ9,7žๅ{ฟsฟ้bƒ#ชฝฆzํ?xฺ๗คฏืฺu%ูฤi๙๖ง๛๎๖˜h)/nงtƒ้ึำด:QUรm“ฆ’h]™a{-๚จvฺ่ ๊JรWv[~ุvฅท๙ุAdษฏ‡๘eg I]๙ƒ@l๖uตพ๓#>ู4˜~ศ๏ฟ๓็ผฦiถีQไuโภา>าอ฿g๙nฃึa?Iฃ–o๖;u๔”งณŽ8›Dคอฮ๒ษ.jำv[nฒZปฯุษฆ9๛ศส ZmถๆTwฯฝ ฐ๎ัHชOlต๚จํŠ-&ƒบI|๚AšA]ขฆ•ล˜“!•3‘ำรร—ล่o ฮt’กqI๙๓ –บS็k๏(*„t\ใ?Hฮ~๛าU์™{๛๖?ุๆฤO๕ู๛ถk<gํœ‰7sฟd๗ฬ'ใ^Žs3ฝ3ู,vIึœม^ฯBx ฅจ(ฌญตปธŒ–ฃƒ6นต„Q>ืsฐv›ะ๚โืqH_g6ยบย‘Hฟ๑zฒญ…ตก๏S๔tฦTS„!CgดVๅ฿พEื6UnำรหฎN/ฃŸ#ฬช•""า3จL„ˆบบ N์ิผ6ูnbมf\nอธ&๚คc-ทหgฎgฆ อ=ฎ?8๗ๅ่SลP๘xวŠ’†wญ๏M๕ถ์C!ช๓”s„ภษJอEวjศCR-ฃ 1โฺ“ฤยnvzmด%,ฦLะŽพ๒Bka{ฑ"ƒณ่tพ,‹อGQ‹อg1|Ym=๙g๏K™(%"ถฦหBโDQU_ร%›ฏ่rDฟแDยs2ญแ๒e…กฎ:zA5=๚zGJsMAqไB=s~๎๛lั/5"YOŸ‘่รd Š+ใRt๚v‘€.ขข8ฬU\Ÿ(ฌกวศŸลถWqฑLูEืDŸ€r/œ%ิิZธนq ค๋๚Aภzณ#-ฒRคK{ ๆเ q>0žๅ;ฅv๗‡`2ืoB๙ŽOช€dชD`=+ฐ_ีež๕x๙Ao5งL0N>ต6ๅป6=:5)%EูLฝใš๊‹๎ฦ^ย™uhฒํ๑?†เ๔Fํ๕฿6ษV™W๐๎๘๊U~Q4#ฅq>aG็็ฺ๙฿n\_ ซ&|%ฉ– ๐$ผpพ‘>ผ@Q<‘ˆวใAˆA{๔๎ำkธปFm๙ ขฬ")›ูti3HQลŽษลu๋eชZXมŽสภY9vm3ค”๕>ฑdึf&Aqร›œp ๕ึยย†—ัธcบต™—฿๐๔่hถi“ะนนฅ?K(บ "=Al๛แ Hฝ๚F]qฮ  "ฝ่ จธบ‘d฿ม}>^t‰ซเฤžตG&Bซ๓งSwุ=Jฌ๚, ฏ2์m’าt]@g?Ps็u& มหuีgP๋€•™X๒ล[ˆฦจฉถน7g๑ZK5ฦm=p€๏พต‹†่J‚ธเ5O_l็}า๏ภฉmถ‰‡ฏฤp˜ตี\ฝ๎d‚ฒฅ…–Œฌ,ˆ„_รศ‰Zา๒lTMW’ฌ@ฌฏแเ-'hQ๒NญKผ*์9Wณ๙™“์>P2#(ํ์บ๚D #qIB&H๑œๆzN^pโตW\ผๅD}๕œผำ๋/ใu›งฅ4งŠdๅ€>šไ๏Wซ8Aณ  ดไ๔ฒุ ‡,๚๋ฬหb๗/kฌ‹sฉƒมtz9ฃ?Pฺ้KT2c„๐…็Šํ‡Br•- ฅšฺ่U๒๙ั•kฏY ๋บ`๘บอK+—ฮ™wไล็ใJ๊Tฃwo:ฉ?ูช๕lmณ๖ีฮyK—]ฬ~ š3o้œy๛ŸTตc๓K?ฅ\gwษ9ฟn้๚ํ๗9#–8Šต)ีw†ซ~ฦ๙๕ห7์ธIstำ€๚๐kฯ`ไค~ สNฎฅ7BโพŸNzH%•€ าฦ2š ฌาzข๐๊yไ+๕l4น๕ตDYฑฃึ*ƒฆ ข‡์\ฑ|ืราสว‡5ๆhญ$Ÿ์ธโ`œ๚ด‘6œฑRี…dฝ๑ฮ„ะภwhO+uqF8™+ ู"e งฮb–ำ@P_[๖Eป!๕š XrทคฐuฉHฏง๐ไ H†]ุyYTŸลไง์๗ณrที7| ม#ศำฤ Tอl ””ปูK‰ก“5a9ิฬ๔ุว'XIฤx๗›uก Qฒฐะจฉฎ†‰ูฉ}&„พ๊ๆฅ9ล^ูxภˆ๔ฯทCQY™O์ถ|d6ฅ -ิช Q\P%eN}]ำ๐6-<๐Ph>Dญ3USP{บBd‚ส ~ๆY‰ษผ—฿2กYzภา g๙ฬ“|๘vฆ๘~C9G—aผgมQญ"ขฑmร–ฝ[ถ8x%Kk๊๔มbศ๖vชดc็]W*Œ์BฆปD้๊ฑ'ะ๏๎™๊๔JทjธurDe])FT5^WZNฎฑ@Rำแๅฦ29(Jฏกส5ššœิey"Ž$0ถฒ*{W/ไ• yญbcซ"Nธdฦ๗qซoต;Jฟgฐ}/‡ม๚˜ธฝฉ๗มy๚rI3ฝNŠ‰๖V:ป๕|@แ]A=zธ0๔\)ยuฺฑธ๏ู…๕๗๓EzŠFิํ@Dสฑ'๗ศ(ซ๎Žห>ฺ๙์.ฎ A+ฦr3.•—•W–Doฑ๏’ลๆศข๒Šย์เ^/6\่์์นoys7ผ=>'Oึ่=นฒ/0Rไ$a:ัE#< ฐ UŽฯฌฉf6[๕:‚:TO @d?:ษฒŸ]ษ›€์R!@ๅ‹จ1^Žฆwrาะฒ๗็7|ธB" ุ\าะ†›ŠsฑŽ[/#cคƒ/@gอ ๋ กฎ@๐Iปล–@ˆ\nIseH(l‹ …ฎƒห–<กUp‚"EQAฤ6ำฤบิฑเฟˆฑC๏†{‡ซ~yแŽฦ”i[G) สณ?>บ}=ชฌmช๚ูกCด)Pะ๒฿r7•อZฤใ สN+ท๖^’S+ถbว>น$เ MOˆ ๗ลป็1ๅท"ฺtC|?ฟ๖›o’†า๘Uศžผสว#8Vํ ๗Z|O<ส็‰ ŠVf—ฬrh"ปก&๛ยฅ–i…(4๕ง Qดน`๛aศิ”G-6Ÿt‘ฏkขl1คไ3น4r_*า๊•ีžฆณฬแ7 ๐Ž]s็Ÿผ-ˆ{B:ฎ‰๑_$๗เภvึ?žt D"Qa๐‡I< ’™ิXIqB e<ฮ๘ZิฺโยฆUชงo&บ[™Pๅ†=7,าษs๓w>O(k์ุ ่Œqnฝโ๏+7?LูWtm๕๏7ดvLc4#2=E"๊v$ขจเํลำI5|จ ;}3๋ญ}wธX.*t๓ฬฆ๚ซณิฏ‚รไ#vโJgฐ!i:๖์ๆšI~๕aiE'า:ฝlIY๏shจ€Yš”^?ีส"Dij™wSRQู|ldำw“ 7๘TŽ-ฬ็y>ŠˆญODดฑƒPก@$€ฌQ_K‰๔ศ ศษษ3โฺิBnฝ€lฌษ‰(a2ูšชผ๔@…vฬ‰ดั#8€เ๐จ@$Aฆ€EฤKโฦฎ6}ŠาฎผF…hฎ฿#8*lw"7Šขm/๙ซ.ตืƒท่e_ต๕S#E…8\S‚เpอฒ๓รฯ‚ดฆ™ำยฅ3ey!พฬ๙ยๆ7บ†ว ๘อw๓;ูlA T<=ฒ๛มื๋๙ %A๐8ผ@ะ๔„อF๖'ๆ–u5H=๎yห*๏ํg‡‘–ฒฐรพcะQ”]Z—WฏำลRธ๕xyY)ๅน๕โึ๖*9ธvKฺพ์ไณHI›YใŠ" e—ำจt=cHOฅฉ)gจ()ฟึฎWำwู ๚ฅงฏ”ฺดB f2lžใ฿&—ŽSiš5+!+ฯฅทไk))S;infm~•๐+š…ว็็Lx8็ซB7uv๎ฮŒ|N_6๋N8ฌ~rŠ"ภง๊งิ๐ลn%^]f\j•Oวฝ6'sี๘อu ^ฎ}ป w์’ด…C๗ฝ มบพŽจ๔lBฮ|ฌ‹ ใํํWy1ทฃถฆ๘4น•ฯWSญญฉ‘”“—เIGGฑ8ตTŒj (ปไล๋ิscฌIั‰9L์ูh8ฬž<ิHIอสRปฒ\\ล7šyK็ฬ[:gา—ณ9๏ๆx=*eHๆ}๛Y(Hˆ๒ฦŽฝtจq๛1J ้]z๕R–@pRบ๖v:%Eล aๆไ๊:ข‹ฌ„คชํเพ Y้bท?โิัศšธ†2!ฟฌ ฅอญฃปฒ„จgA"4ีF/าะjj=แๅT‰x‘ฑTิใ5”‹ใ1 dm†’ษ8’ฆชmwAQ€SY"adG–"โd-tฌŠบ๖าQร%)่(dิ%ษธv\๊`๐_มสมฆ๐ClซQSYฅjiง+ฏ g๊(›ฦI—ˆ†ำษฬิๅ๐F-ั&tฤfงRV—% xk;3^aAwฑ๙%E…๒fี$$ด.Z1X์ซ(*Tฒ๊m K”Pฒฒ1า๐z#f[g^:x๎ 2l†Cหต๏๎g‡’ฌๆjแ uy#mNMสศŒ“๊1JF†„WฒW๋ŽฏK7ญŠ@ ส)(qx๗ปตq4B’ๅ4];< กช` ษฉื+(Xปoi์พฅฑ~7่ผศœ}ปJšFŸ„ŒทGscฟZฮn ๔์dik'2 ฏhซnงe7ข<ะะeบม”ษŠฤฏib``tJjชF?'cษ|~ภีๅ๖’โ„ฆ‹NŸ ธdb{๛พW๓ไLŸ>HSJ‚คn?๋–๑qษ JJาาถฏขฺ๋ง๙ลึ‡ใs8.ฤ๗จวใทQก€หๅ๓ฺ|ย6žE…\ฟอ‡+D…B›ืๆร#D…| ํ็' E&ˆจ๔lค๋’€Kพพ!๛'Hทs;ุQแ๑ณuW’’ึฒpฒadD’˜ปษŽx๕ฑฯๅ=5คฅีz{,pˆบ๔ซ ผดศ!V•Tj็@trlฝh๙ฎQ2ปฎ,ํม•g%็Z; ฑช่~มw?—&*xยํห๓ๆn๒W$rซฉ/\~U#6๘ำ๏ฬXใ๋&%ค—ฆ ซ€๊oฮs;4”ฤฉฬ}p9Vl‹š__#d60,jJใึฃ HนUจๅฺลc วแไ=ฯฏไ+๕Iภ‰ๆหq*z์Yj‘ุช-'๖Rกโ4ร๙ฮD“MyJ‰ค?ๅVึLฃลร ยFย…‚vW?rใJยฌ 'lUรณ่ฏe'ิˆtฉใมSHvsดสฅ๕0ํํอ็v‹WV๚๊ซธ~NPŸW€w™ถtŠ†žQwใ๊›vZY"lบY;\๖ŸE7ื๏}Xัฒภใ“›6&*p?c๒๔~ส’ผŠฌ็'ฎdขโlŠDคM‘š ๏ฏ่โถฬg‚ Ž]•๒๘rกุื๐ฺต.nnFษ jr_Ÿบ˜Ž *รg๕ฏธป+ƒCฯน1`ูฌb/&ฑ„Ÿ†M{uMe•e_เีฑ)๗ ฃŠ@˜v‰ชฑPgษ1ข ฌฝ_™ุอ[+"๎”ฌ฿8„์สฌลฮ๏ปเิ†‡(ŒYdี› zv~h~L€‘ซอ‡ฦ๙s]6๔ฮ‡lŸ+b:'Zฝดฦ—0๓fžฺL}ท]DAe]dPiห–ฌ eฬZ‘[ภแMฃระ‚7n์ๅw=อK™ภ †]•ย'จฮN* i2’๒DํิLรฃ๋†๕}ซAj(Žป๋น๊\1€‚HOฝE›ฺขu{Žš=fใ๓๛็๒ฏ…dอฉผ้นS๔ไ˜๊ิ‹>ฉ_ŠO๏H๙R่ฟVD]๘๐3[๖ฬˆ๛RธmLฬ—ยฒG"z—_,ก‘้ P•GฉVฃ'Pš๎‘ศ…Aหถ˜๚žูข"(Ž ^ไyKl๕ฏ๘Œปง‘ฃoCฑ}Š_ภฮภ๘#w๑Aป˜ีวc+›R›?‚?ลฯ/!๔t;ั?}ฅO ‚๖ธ5CV^4 ~*ส"v,’R๊่ึทฌšŽžHUU๎(๊/EไKชต’ผ์ง;…!ฃ๎ธŒx็›_๋ ฦฟ็ณโ๗oุ๙ใA๎ๅ`”v๖ปVv›?‚?ลO๐)๑‘ฃ&๔ห (สค>ขjง0000000~X๛ใ›aพ>ผ๕ิๆเO๑S5๑gwฦŸี^```````~‹Eธุ๘ฦ€”ขจฅ^…,:ธHฺ;๕wงeา9ฦภภภภภภภภภภภ่(X๛ใฯงa?cษ’ูuฑ $็ป?6?ท ะŸZ}ๆŒ.ูผีวwืญ ]บห‹ืDTzธฌฑใ่ฑฝ>๛ึ.m"Sฝ5ืึใ{bู๖Gขฺoํแ ํมํล ขฎ9๛`ฯำD์Šั„”ŒใrปๅSๅฟ.@ิ5gํ๏ู$ืำ]tะv„@Tทท็๔’๐ว ใดปวบฃvMŸฝ๚๚ํ่’eY,=`ใพฮศNทฃ›ษ~/H&<Œฬ.ฆๆง<Zb'นะฝfฝ๒4๊lœŽ>”็ห๕: C8ณี๏ช+J†ทฃƒ(;lฯ,ฬI}ธุบ้ภ4ู^W?ค•ๆeGุแฌีNp‚ž๓ž๏3‹ฉิิะ“ณ->eBร…ก™็'+4w๔กTิT—VUR)๑๗๖ั๎ิ…hน?คั*^7>Lึ›hีgว~5i๊ญโัขฦ A[O์y์เtใvCฉZwํCbA5/๕ลล5Žสrใ;ƒ่Žy/:ตธผฐ ๓ฝ}.โj‘zฏiดOŸิฝ}€l๏q*,)ณดขจ(;โั‘IฦDัก๛์Mคต ^A{ฝขฑ๚ฑq๖+oTจ-*ฬx}uu฿ฮพเn=ธใ‰MIMW-i:ucA(š๊DxwlCx„ัศU#ณึงŠึิpk]sะั8^ฅŸ๛ึกvฏณ฿1qsn‘ IDAT๊@ ํM0——๎1o’๊”ปW๊ธY ฟฺŒF–ใ4$jE„ ูmชAOS\9•๛5a#ห1mำล๋™’!ƒ3–ำมCํ๗๘ปยzท7-ขซj8“‰†ฦฅy.6HX่N™งYโ]๔ำ[ฐว๘tว)i|ร้งœ๒Œด฿)โ|*Œ฿•Kd ?ฑ\j๔พภ้๎&ษ ฿s๗ฺจ„‹ญ!žazŽJถ฿|ฦฆwหž‹^คๅเc๙ฬตฬ4กนว•๛็พ}ช1ยยว;V”4ผk}ˆoชท` Qu่ž็ซ<\๗พ“ืc=I'P~ธ“@‡—%}ข4h–ํ=|Qz{'์xญ‰|๐฿Tjโš๙[ฮ”G™ฏ{‡ฺ๘‹ ธd ;๒ไ0ูqซ\—๒|vge˜Xua์ูegK(vf.€‚‹ืป๒ท~ปร•\<]ฎzฒ…ˆปI}|xK‰ ˜Œ2ฎ๖ี ฐ จˆl|งˆ|lสŸุ๑ธqัืญ‡–Š Xl>‹ษไ‰ QUtšฆmฆOฤ1X๓ŸลฐQDYัษU\(ฌกว฿ฬŸอKฯœ—<…พrUO"ฅŽ–ษปŽJvฺญวผTฆ์ขk,ฯงอ}ษFAฦiwW;Y`ฝ๕ฆ•3ใมYน:›7วสญพน6?๏G%฿oNีjช๋H;}yณ$๎๕kั•BœŠีิYฃz่หk๒?สbB๗ฉG๛T฿ไu)๗๑โu—ฑ†i็|ไ๋M๗ฟบ o4&Žณ’gฆ>6ขรi๛<ส@ษmษM‰,้ธlืL‹ๆX91žืEœl‰๑c ˜h;ชWฟz'ๅฌัžšŒูpท)ฝตeI2์Jฎ$t`„ๆง[ฌะqโ้ทeBัร7ผC๘•้Uo_ั*บštัj_@0ัvPฏ~^jDKz1™ฆrสภ4%ำŠุ?ฯ๑ŸŠฌฉ5;ม‹ฮ`ฤ•ง66ั**kฟB๘!ู;ฺE^WมH=ๆ้ึีŽฺPฌ>lKะู=5„E‘Yด็U%hc›gงIจNนปs๙๊›นO'ข9ฦสแ‰šี/vบอ;›มภ้ฺ๋ฟm’ญ2ฏเ๑ีซขhะ$:ฉง&RRฬ‘ažhvAiœOุQgฦ๙๙ƒv~ภ๚Ÿ:…ิภ๕›อno4 ฐhGซ฿ุ1็ฬยห่!วol:?ฦr{B2’บ7"8ง /ฃ…›Œีเyฉจะ’}๗๙xั%ฎ‚ {vื™ญNํMa๗(ฑ๊ณ0ผสฐทIJำuIหตBดง““ย…ahs Pลq๙กnƒป*๒Jโ๏๎๛gำอl. zcผ{O๎ฉๅ-‡ ๋yผNฺn้๛๔—Ž๙ฏึUญฮxใทvๅษhฉั๓S๎๒:๙ŽD๋;฿น[7 x'๒โ1~<๒ฌค‹ลYOรJฌ๔fบZ#5ด๖ิัช์ศศvmYY-Gdhaิญ[ทตๆธฺ@Mญ่ฆ`i๘Eฟp'“ณํjข‚2ฤ=6๕ฉกW/ฅ|T›ฺ๊ฝซ>@gฺฟhมtุ`b๘๓4@Uร๗ูl/c`ฌห** ‹ำฌ ;}ฝaิ&Ÿƒ;|6Xฅ๚฿Œ%Šทœ ฏ‘O=ท)1๐l๊ds)ภ[LิWฯษ ฺ˜x๑>ฯrฎ–.€Hิ]/สำัถว—>Š‚ฎ–r“บู#‘GO๘ี*ปhโ€๑bs์™qญaR@์ฑV$‰แีวึดโo€T๏ษ“๕๓n๎Zฟu้ ญic{J€Tฏษ“uณฏm_ทs฿บ>n#LœกB๕ีiบฃœ//DขถT@ฝOo|่ก๋}“4& ตภ@^๐†u๎'ิทŽˆ๓ปว:wญ'?ึืฤ&ไ๔K๏‚์ว*–>*)J•GนŸK?๚ƒ๋ืm๑-ซ~ๆั๘Fีpp”|qd็฿$ี‰NVฑรŸ‹ <ฉšR!่€!๕ฃX๚ธmz2๊๒y๒๚๒$#5๗๋ ”๊ปึfๅ~k-fฃ๛K‹T Kศข\_ฆ๏ƒ๎j<:(ซ N๕ จฌฬฎฏkz_ /<-วฮaฑมั๎}M‡ฎs=บฆ๎๕ฑ๖t46ฑ›๓ย๐Ž‰rกŒg.ํ๚p`‡%๏-๗ฌ)๒S๖๛ูGน๊›>ะเไiB_ปศeฝ บุบžIou—Uอl ””ปูKฤ๋ภ™ฎุ5.z๛ศ๖OึTาิ†ฒRN๏u—]MJJJ4ตด ๏มž t„จณฟU}ยm€–เส*œ–'„x(4ขึ™ช)(Œ=]!2 AeP?๓ฌฤไN7๙SS2FL7ย&#= Hรv_2^6|๔๙๓ง๔พ๔Žาบ7ฉฑWงTL็™ุE>6€Id9Mk3Mfguฒj๕kฺ$๋^ถ•?”|’H9.8พoซs‡9qš2=งธh%^ฺฟ๏ุก•ฝg5;|BRำโๅ~ค3ธBVAลำ‹UUิตนนฑฬžฐ>ฅถ(ญ&€R๊ฉ\รสหเ๑8<vrhuxล๔R”ค๘ตูฒาึzร๊žฎ/M๒PัึฎKŠขิq๙ ๊ปซ็ฃJPััฉKŽก2xšไค, -9anV—รแ”ฆฅีs8\ก๑ฮUD<Ž.eฃข|TE]๎+๑ษุL˜ั%าญฬฟต‡๖7Dบงฎ-ฟ์MW;L™UUlA@ูภ@ฅY^~DaƒS˜“วSRn๏a๘O Cื–W๖6กmz"Lœพฝ’ป^ฤtง฿ๆปCษg๖ฆ฿Ÿq๓]iผžธIึD„(@x ๕.2Jdก€#ˆmji๕ฯnเ „6๔ฟ?ฒช^๐๊Cถ††:u๋VกŒลฉŽ;ํน่rzำK’zm๛แะŒ’ผะ๏นบzj`leU๖4$ฎ^ศ+ฝ๒ZลฦVŒญญหžŠฉๆ๒๊23จญŠชฬภ%3–ธ[} ซฤu ตiณ}ท†ิ|E$Eโ๑xD-ซ~}Ly\ฎ$‰ิ๔‹์๋ดฺโิcว&n‹7gก๙ ‘›qฉผผจผฒ$z‹ต๘ศ,6G•Wf๗zฑแBgzl) [8dใ๊ฑo฿6ถ ŒํzสCอ››มฏ_žพ „n}ํษ`hูMjž฿ธ๏zbSPf๚ใ‹—/พฬiำ3Q{g…๓ฆ,=p($@_ฏiั Ioฤ*ฟ็I/อะญŽุwเ.ฃำžb|Wส๎osฝ์PดŠ3sŒัJ•Oทฮ™?gฮ9๓=‡Uซ๗วk†zoพ่3žรs๖B๏7๎An&b‚‹Dไc]V>..H<3^n\นห๙%on\ื๎]หŸด.X๏ƒ?เฅี{ฬ^ไ >b่ข4If}ฌหŸษ-Tฟ‰u^ำ๘%SdŽ€ … *SiอB@›„จ@€เ;ถ„Eฟฆ)ซ8| 9๓|ต’ฟ /4=์โไิกฐI(๐ํVัๆั[E๑_Kd+ื้zqgŽd`ญ‡ŸQึั™”z1ง€Uด:ทToฦZ๏๑lV-%๘ZK9ิ๚#ธฮ”x!DY‡คดห"าณ"“ฎ4_ฝแe‹๐gฦ ์ZnSŽฌฉH/RWำs|ๅใปๆ๎†ผ-ๅ‹Ÿ}๚ ,wŸา๘OQฑˆฅwขัึร:‡ …2v ๛ฬถ ๒ธ8yx๘#‘Hไ๓š|ฃง††6โ๓›}>‡ร5j๊/ 0‰D2“+ DกEณ-ดŒวมŸฆ ธŒ๘mW๚Ÿโฮ3มฆอฆW็ออPo_•รๆ๚Ywๆนœๆืqลฉ —ˆ &SŽ_Dฦฬ๖‘๒-OHีY๊Wมa๒~;M๙ด}๛P’ึจcฯnฎ™ิ์exW€ฯฬฌfwใ๎๎FB,@ะเ๎๎R Hฉ|X[hา"ฅล …โ\‚{H FŒธ{ฒ’M6๋3฿ ์†B‚ฬ๛์ณg๎=Wfๆs-QU˜—ิฏ/๎z๒รปขฏๆ฿zฤ3€Fฃ่N<”9\tฐู, Rฉ E3ๆv*u|&ญ\ืIAัะจF ธฏผ~yUZQDศ๚๏๗์ฟ˜TAตฎจฉ ีaW3เชจำ‚ษsว:ปฑฆ๏Iื3ืS”Vิ>ฐ@eฮ3 x๔๚ย07ื)H|๋RBRx๛~โมม^Œ-งRš๕ลmบ`%๖bยล/Dท๓๛M™Lภ;ฟDezผ†wo6‹Ž้xนข‚ดBตกถ>’็ObปLสวPƒกใ2eFpEฤณB Pจ,%ฦ~“{š‰Œmlต่d&&š๕ืษ˜Aๅ8L>๘ภ8]uf&&w๋cว`ธฬฺ}|ฑrณ2-ƒ{9 ]u฿_็๎=นw๗ฅญฃุmฯ†˜๕ฺ†ฺฺ†ฺฺ†N฿†UŸ˜ฌ]ำypšฟ๛ศŽ!›Gึ๎๓M<พvm๚’ฮFlMa ฦPฎ^IP8Ž๚หl_m P–mpO็ฌฌl5Iž{ึi๚โŽฦ† gw‰ธtใญ\Lรr@/ฯฒœœ–บMh44๋ฮ‘ำแEtzอ6ฑั‘ ำฑooท.3ถ^ฝฒgŽ ๓๒pะด๗ท์]ุก๖R–หภฉ“ง๖ถวดฝO:น‡5‚P((ะดอฌบ๐ืช’p:ฯ^dขงซ ะ๓Ÿนxแโล /^8#ะค…v’ด’ง"˜ผอk–|ฝํภŒฬ#/_S €แๆ]ณgฐไEB6Cฃ๋๕฿ฬ›ทqู""า !6VŽ“ื๔๕าํ+0ก2*ชฉอท^GUตฉ๙Gำcเิ้ณึ|ฌxVV^‹ีใ˜•นyqัซๅƒา๘K!๎ำ็ญ๊หBคยาไ๋g๎ฉั„์ะ"ฆŒ^ดy2ฏ*Iบp๎‘สrEโน\“๑ึ36R1‰$๋ZNผฐVh6ัvn_ ฮฏz๑_vnS+1ซaฮ‹ฆก๒ฒสศs๒ €W๛/ฌ๑ํี๗|๙Œ‡ฺ๘h1 aา†_ฺKีแgBฌ'[ณE —&]9VQ+ด2ๅง,œ—๘เษิฆ2™้ Avแ฿†e™ะ*าno\~คX]˜‚“?เฟ๓Tาj=JUฮํKคPvb_C\ˆ]ผsฦŸก3Wิksำโr&UqYไjซPžษ5ฌŒอฌหOัล๏xฝๅqฒฑ<ใฮ๖iฤโขหVุ{,fฑ"*K{๐๛ฒษ๊ย+8ฐ`™ๅึํ–™SJขO-Zrด์ฟ]บ^ฌ๑์ป3ึE—ฎ#d•%™aGRuk3h4Hno” ณื7œ..Žปฒ๕s1Hฯoฺ6ๆภฯ.—&m8hืฝ oฌHวdภท€KณN>ธผuํ ง๏๎ู{jีเgึ๚~DGญ˜๖[ฒพ๎ฬŒขQ‘๛/ต…Gฟšc๛ว†ฯ๙_wey๊ล ?ญปYำํ,xt5Š๋เ*yp+ฒฆ*ง๏_ดาq๓โห~๎#+M=ำบ5กีG–,p!3่คไฅ_ผ~ํี–lpฏฒฺˆŒ๚๓g?นˆ›vd๙ส#-๓`!๕/๛–Qเ/vŸ_,ซถ'…—ตท!Ÿ36ใ7 ็ฑํ™ษŸ>”“๏’๒ร฿ฯล€PL|๕5๋า๗gพ˜ฎt›`a฿Fž๋ผ๔wฅส—๙ๆ"๙˜1ด9qˆไ3เต'ํด๓ ษB‘ูoศฯ›ƒJ‚ Dyก‡๓฿~ ษ'ูPIีํUIํmรgOึษ๏ทตท $ญ?๎่ๆธฃํm IะN็ว‘|‚ใ$$$$Ÿb~๓ฌ!!!!!!๙ภใ$$$$$$$$$$$อ…์?4—w™ฟ„0-ฬ™าฝ๔์๗'Sk%,๋~ใvฑีTrำ๏พจ@ฺ"!อฬo˜@g#&^U๚๒ฮ•SแE๕G> FWฌ่ฅ}ผ&. ›ฎc‡8าeผˆ‹—BS+[uqอ^?Xv'Fท๊มจ_š‹—฿ุp)Ui9rภŠฟ๗)๛E๏ัวf ฐ๓sฟ๒ํ๛๎ฉ>˜ญmaฒปฮr๒)หุyชๆ`๗Z๋โฅQw“Iสฯ˜ฒfพุAซ\<ไาน๕ูyšVมu ด0B")Œศฝ~[(Uฉii1{Aฮก˜[)Pu‡ฌตcŒ;๙่ำ9$@ƒ0าฺรšฆไVD_ฬzQจ.jพf[ม๔œพ๋ฯฅฝt•ๅIทถฎ\r0^@ทฑqวร}Lจ‚ิ[W,+ต๘๔ฺnฌโำ_๎ๆวpฃ’|ft๙=5d† F(•$ฑ๏Žฌฺช8ฌƒพ"7ศ–oธ[ŒU‘ไฃกฅ€qร‚œ(yู BขบํZ๒ว๑"บ๓€๙S{dmบ™O4_ศ ึW3เ†ฟสPใฮ3พ H:๘ค๖(b–ฮt~}\งt&ฎ^รง˜Lา฿๗ณ๑Ÿฮ{๖3FืวS7๎vฺ‡o|ˆˆฺฬ๘บ๛X›ŽŽhIฮkw”8lkBDi๛ุ๔้ ~บ=แYฃ“L4<๚้ o&„ฤหQ]ฃกหLŸใล*5ฬา)Uจญ–Ÿ”๛ตdoS’qโŒˆ๊h5bœiั๖ผRีNๆkถFS7h|yจWp ๆผเ่๕_&_บฟุb๖ฎŸMNŒ๑•E๑๎|ศท#ฮN :ำ๑็จ๙ฉำ‚V฿ ‘SG็๓ษwIk๖ฃษ7ฐ%uSapะถฺ“7อg๏ฺh}aŒ฿่LFวoNZ๋='‘ฌŠ$ -ํ?TผŒนt?นะqข‡Yฝะฦำฝ๔้ฯYB @lXt๐8“›๙…อjsY‘ฯ‹ช๙)้|}]!อ!(ุ(ยร ฦภ26ๅไ>Š,น1๑‚…๖fฏ๚Œ[Nฯ๏ฌD!EบมV6šŠผiืŸ‰qDGท็H 3 .จŒฟœ‘ฅD[ง๛ Gs"”)่สX€WB3*ฮฦ\ฮŠฮUจŒ†๔:๚ฒฃฯdฟj hนŽ›>คƒ–(๙ฺ้รOKqTฯuไุพ–,œ—๓ไ๙้ีเ:|SGyนs_อ˜“ฯ [&š‹#บ.รว๖๕1ืP๒ณ„\ผ—-Qห!hสpE•r…hัํ‡žŽ\7Px"ฬhhฐป–8๕๚ฉยJq5ฉ55่ณ~๒O๕ภ#!๚~"vb๋ฅ [už4บ›ฃU\’๔ฦํปI<ช๏6rLo/ **~qํยูฎ๊ด บ.รว๖๑ฑิ„Š ]๖ Nจ.ํR๛๛ก({Y๐>ฟิษั๔]ฎoฅโ๘lPˆซqฆDฉ$—(•…ธ‰jHdฏฅ U VEธํll4ํ\ฤ๑ฟ ER€๘โ”vฦyฅชธmพf›aaจ๙่ไฑ8พ ๖๚ฃผYถVภว‚“8@๘๚๎ๆA€5A`T*†a€@1๔ห?+dฎ S{’ผ?Œ€ภŽวล๓ไ ษป่ dU$๙hh้๚I~\lRIใบชกฉ•rหพำF๘M-ญ–!๏ฺึแBDระXณZ$ฤ ็ืœซ๗3ๅu‰+rS'' ำvp0bฑ›:•้๊‹Eˆ9pˆงlfƒๆ4ะฦ +ใศฦ˜S7ๅฮcออ0งAถFน™G๚๏x ฏ๖9 ฒ5ฮอ๘๏—่S๗•cLZ˜M_&žพ”๘จ๚฿z Ž์r"tXw >ร†šežด๖๗mW…'ู!ˆ•/ไFŠY๏žุรใฯ /†๏๐แVู!ฟฌ๙m-y๗I=,ิFคำyฐๅ๕ฟึญดๅN)๗๎Cฯkชฅa@฿[ึํIิาร S‘:ใ฿@š–˜aโไฤะตsbค&ๅ€V—a๑วื๘็๋น:ๆL†๏ฐกๆ9—ถฌ๋แ4ใQ;0ิฅแ;|˜eึ…Mk6z่Yqmญk2ํP๛{ข,‰/ฯ,}ณ‘ห X์๓ีOๆ~๋Yƒช๖๒V*ŽOฆW> ึv˜ณยฅงš\’ลอ’๖๖ZธฆรยEบูณำe๊4ช*ršVZ +ivF;๛ไ[† ฒ*วo‚ญซพฌJHekพทfนพ”Š]WWc—  ฃงง บ/>ž–™›๚ื8*@๖นฯzˆู์@Hๅา3GฆฌNถุH>4:zzaEm๛GXQกงฏOVE’ˆึุฟ•Jก*•JŠฆ™ฝ%]CYฎคะจ-Pt์=;๙บ{ปV==ด €ำฑo ๑๖ุj่Zžv๓\ฌ)+6โโŠฌุL.ะ›2KœxปดL )ด4ู Yึอ*ฑ ™W0ฺLŸ•LCSYึอ*ฑ L,ฌ๕โ2 LdูทD2d‰ผQฆ†,(ตBV}–X๙zสฃŽพ๐Ÿ_}X P’”ก่ญร่™™ “ฎไUษ’’าฉ=M9@dฅงษd.า’ไ”J™ท ำฤ๔ฬL+_^+ ‰‹O›ะอ‚y"•‰น\ฉ1Š ชaeฉ|( ฟผ@ P•ฃฐำๅจŽH๑o"ILฬๆhƒ=ษpดำMฯ$ALC“ร@xลษแง’k4๕LM„IWฒ…r€ผˆณวKTฅ]จon&Lบ’'R””ึจJปfowีo`Mๆฅ๛ยUฦ!…‰ะ a2‰ IDAT ๚Mต๖LIŠR=็ถuŠใำD๔๔ฏธ(€f`ะwฒตGJR4Ÿ๊8ิJ/1dผ 36๊3ฦดdg^‘R•& า์T,ภW.ฉx,7ดjืฤด JQ8F3ดแ˜„@b๊^)อืlS่cฆM>ขฟs้ฟ_J0EfืŽฒ‘=ฟbu๔ฑ๎>œwaaฯ L็Iป๖~]ฐaา๘[EŸ฿xษG‚ ฏ ศชH๒ัะp…Bขจ$แะšFL!WดD งณง:๓#=?r=5_จ ฺ๗7x~ไ€๓*&ข,2dSิE:—ส้]็wณmฺ0โีรขึมJเJรAัza=(†1<'{:*กสค%ลซ๎ฃฑ๔ํ Žปแ„nว๋ฟ ( †ี •8ŽQิๆ'†aฺ]g,๊€F“๒s๊=ฏGD๐ฒJ,Fตj€T"ศ9W?ํUฉDM์-2^•‰)ล์ltM'“”˜,@๐$ไฆมเAK{i)หณc๏ผSฆ ร”สฺบ$-LJฎKั›iGQด^ุdฺKŸุ฿ฐ}-ฏช Tล! $iญs‹_’\`lh บะล๑ฉBH*ไRกฑ@ต–ซซ8แD%เงนปX็eจิ(K๊L7ชพ—(ฆถW2ฎDTสฝ๚+€โJu้šฏูvh๖๚-๔`฿์#{ฮ๚๙Vlฑ € ๅรรฤ๑ภป๛ฯ™ิ‡~pธ„b>เงƒ฿้Xฌวช+ ›๒O,Ÿถม'ตP…ไ“ƒ ˆืะช8bh6ฑ’ไณโฅอWnvqueสัbH@SKK(ดDHu ์,ผด๎XDรyฟฦvฮฺ::‹ื๔ฌmฝีฆ฿Ÿ3|จ้ฑB`s8u3š ใRื‚APว฿"๕šโุร ฯ?ะ&BŸ˜ƒ—๗ลoูวqด.oQล•j[ป8Žs๎฿}๛&๋i๛ wJูถ๖ฤ๛ ช6žaไ้e*IOๅึ5p*R…NๆV›ผค“ตรษาศS{"OaLC๛.ฆ้œ๑๏caรd"t6 WI”*ำHX๗EeฺลrโUลกฝเิ่‹k—Oˆอึ(ŽOmฝรฉ1‡^ๅ‚`^๛'กPีhึหO.คW'K๗ถ6ฝจ–UกT@ Tถฆฌชพ2˜v๎ly&7—‡ฟEณฝ`๖›7ณpตฤ# [_|hะํ…B:ƒทŸ˜–ฒtุชŠูwพy8; j~าœ›„ศ฿ “„คตเ๓x ‡ Žฆ&ห%ซ"ษGDk๘‰ฌ„DใN=ญ8t†พgg_๔e|QK„,…ฐโต6Rํ๕฿ธ›—๓ใบ๓ูฒศใหฟ_ TปnCGtทbSiบn|4ณา Zdจคผ˜fํมbRPถฃฎ^].in้สา`3ํ๛˜Zำ_iš90(#ฃพMŒษ๑ี`ฮพฮ…Q ok p‹Šด\ผอXชถ‹ซฒคPํๅEEš๖ฮzTชฑฤฌ(j"ย0 ‡ฃIAQEี5j฿ษxฃภ‘ำว ›7ƒ๖JฦOLT8๕๑s(LyYณัbะmฬ€;}EY]!ฌฎmpp‹Šด|ญ4ฉรภw๊wc;ฒิฅ_^ฎํไaยแxwsก7๖7P๛@Dะ์ h eY8šTซ›้ี ล๑ษRMะ์ \ํi ีฐ4p0ฎ*.จ—‹8žt ‚ะ๕lMฤๅ%j4kภ+Ÿ๎K{Qาž้x'*3“5ปq4่˜–›ฑสห(ฎCท“ a6ร้Q฿ฆูnh๋๊สŠŠ^sJ"ลt™:ืC—ฉakฮ›๐งqภฟ]๐๘Q€ขจB*•สdฏz$$ษ๓ฐุNgป้04LบNi๖$žฌŠ$-n;~ฎ?&nํ’gGw:ล…sfใฏ\หQ”ง฿=0ŸYณ…4๏นฟ{ืG{๘วรq*#<นn9v๔ชnt77โ่ล๘–y;ษืณMFุO คโ• g2๓ไ/oูqžY}ช(หฯดN3วdธำฬT&อy”UCํ%4งŽ.‘: $~~๑Šีธ1๋ฅ ๒ž;Ÿฎถฝ+y~๑šีุษkƒY˜”Ÿr๏bํQ oFฤนY2๗๛MA€KนูทŸผ“ำ ฦW•”‹ุ’|nร2/JLั่•แjuV^ึ่คมLTๅJxeM2/[Žถ๒gMŠธ<๙ฦฅกบด‹"CŸxNšพ*ฐ๔ั'I]บ7•vจŒ}ฑํ3าฟfช”รr_>K๛,?์‚VŸQn 4QE…(๕\vœบ)๏_Ÿ.2ำ‹ZฝGบอใ Š Q๊…์๘ จzvบฌ๏`—9ฃ0B$ฮ อ‰ใ€*Mญฦ?ฑถ€2jฆมH๋‰+i8Wuฒฐ~KVq™HPM•Joำl7ัwV0ฎ^pnšแฬ‹y๛ญq๑oไ}eAไษนหฮ๒ vจ;ใาม์!ฉำสฮ,๛YึNV“|Žt–y~†.D—ฎƒฤŸ|‚ถeๆ์]ธึ~๛ั๋๔ไนวๆ-ป$ฒ*’|< ฃวโcw๎>Žึ|Z0}ฦฯ=aแ„z3"Š็่ ?๎‘‚๗™5uใง -hฑถ™๑_๏_$oE_Oซm"*็Vผ]ฉP๙’"฿\$3#†๖hัด๒ึŠดc$๙ hบขพ๖ค%็ๅผ3LฏŽ–/Ÿ„|๘๖ทŠˆนIัA๗c/ฅ’ ˆ๊‚;'›Eฉa’ผ3๏]$$$$$$$Ÿ dไ‡๏๛-ผฝ"$‘๔.ว63หเ}‹ƒ„„„„„„ไ“แ๓O‘„„„„„„„„„„ไC@Ž?|ะุmuTทโ!!!๙@ดŠ ’/ r„„„„„„„„„„คน’ๆ๒Nฆi฿นหึŽดซPM:Œ›ฟ`๕šๅซ–Oำัˆข^4,zMš๙ชฏWฮฺษ„ึD˜t I_}ตfอาํ๏ฤiBSœภe>:*ะ้ๆ1ญGล$ญงรœoƒํ00๒ํ๔๎บชtt}็oษxO†ช1Lƒำฟ`Ž6“4†fn2`ฎฯœ๏;ฮ˜๏ู๖๖ Hš‚๘uภk?หlฬภฬr๊:ู!Tฝเ๏Fะูฬ–ย`ฬ๐›3T๛-jš~ใ<งฏ์8uถฝ‡1ึ&–‘|t–yo™ํ›฿฿-จ[‹-[v ำs๚ม๛ฑนEนY๑ก๛fx0ถค–๒ธEšOๆ๏๑G"“ฒ^Oๅ๋œคล่t๚๊๐ƒุขฬไ๐ใซ‚ŒjŽแ๘/<–_”•q๚งเšCษั๋๒ษG)y้‰๖อ๓b7&ล2๘ืsOR rrC๗Lu}๕:ฑ™š›rhLƒบ๋ถฬRทจผ,'3ๆโฆมf-5พฅ๋t|Gwณงๆ5<ด—ํ; ''้๘a\ิฐใฤYฝ}SŽGTชิคบ๊Tzๅ๏ณลtว>ำวuษqฟPฉฉipg,๒ศๆ็T‹๎3'fmผ–Šซิ$๙Hั๑tืIผŸฉlRIz๋bฅ,ปน6+L’Vƒแl†E'Š–Rฬ-†ณ(๘=#ท๚ด?฿๕ฺ3ทeCF%jฉeŠ‚บ3๚>J.Clฝํฒ|้4Q~๖Ve้g.ˆจ๖ึCF™๏ส-#๋ I๛c4uำฦ—‡zง`ฮ Ž^e๒๕ก๛‹ ec็ภ-ฉฏ๔l†ฮtำ4ศำฌQ#W\p/ r6ืl$ฬฟœด1oไ{ๆŸ,ช6qิkไG‘p_ๆ‚ํ'!Lๅพ๕iX‡฿๗เFy†ไะๆoภNsฏVYฯ}๕`วƒ9,ฟU—N๏ฑ๕ข[Jๆ M๛๚ฟ\ะcNป฿ฏ}แ๛cฌ๊qฆ3wosป9)pr๎ฒ๐ุฅ-ำ๏ ฺ[yื~ZRXธแ&qฝ_ะถLชA๏_oํ[z๙สส'อต ๅ‡๊ขิ๘ะวiE๖ฃ]L๊…šFNlL‰XP˜žUแฃซPฉRำาีฅ๙–œJ)Tฦ?{ัk„ซัยb•šHYสฃœXž YNfจวชิTฆnะXŽ<็vฺอX1a`>qž™6€๋Bจ;>šˆŽnเ`K{S QQ™š๙<[ภ \f]}ฑHงฏ•5[žs;๕๖ ๙ฆk!:^ฌ๓๊๓ ัt11ุ“#JนqT4๓!฿N `@้อํฉ…ตว@›๙ถOๅน็มฝœ9โŒ;N>+ว›ฆaืฅ‹บ๊Lะน&ไCy€๊8 ัรรLไG\นv7ซบqDี)ก็ฯฤ๐ศ"~~Z~QผDŽƒ๚•B![SS]˜คปัูRภ4ฬญL%ลE๊ยT รูž~&ไก~?SK ,๘†ˆ๗ซEฯ’vmˆุต!>š˜c?[ƒ๔DŸฝ#saV;VLg$๚`ิกฃ<~fHหฒ‰ŒผจI/ ๊๋v่คโ฿!น&:; ๙ท฿Vฏ=Q๕ฺ•๚>พดวฺ|(Eฏgฌ%a–>ูพ๖ทwJ…Oฏ^๛๊ต‡๒€๎50ุ$๛ส๖M๏พY้=ฆซu]Dผะต้`Šแ€NไR H2Ja˜iHEe"ušฺ~|Dท๗oฺดc็รrฃฃ'bj๎Sฅ‰Zh .฿K7้ั{Cธ9๊ตMb>˜พ3:ฮZ๎;uพ[o_ตF&ชศUjYp˜V’ผœOซซ,{YžSŒA&EศซœŽc์œ๕dUB‹œFJBาf37-U๎ๆๆ0rC„E_Mญฑ›w๚E,่`ๅ๔[๕ยห|j…;|ย๙[w˜tเeƒŽ‚sk]=wo;fSEฎ๏6ๅฟbDืีี˜วญ uXq7=7'ๅeิต=ณ=5ฒฯํ~ึ๓@ไฯfB*—ž92ญ`๕p•’fย/ศ“x๗๊ฅ‹ะฬ{๗pึำื€ฌหฟ๎ซ@จz=…ฑ/สtMฬ ธHฐ๒่_“ MLMี„ฉซง/VิžŒ+xด๏๗ะlˆX้hจญ=ไŸR•ืP๔{vsI}฿ยฒlญ[)ฺ6ฎฝ]<œ๔ซž_}ฎn๛? …ชฤ•วฤฺ‚ฮฤนJ •ฺT  ฿1ซ‡ู(JB฿ศn๑”i๊ฝข<_H˜kฑT๛M™๚FฒœUb@ฏ€bฎฯยJฟ|Tฦ“”K›tป’จฤUาภ…!ˆฝ‘ฮเฆfืŽ&ฉป”u;ฆH ฮอSX๋ฐ*3L]cใส”…"9@JJต› ฒ+€}?พT Pœ—“พh่œg าR––9žUคvœ@ฬ็K”iaฎQ5ƒคo”&ž›•!“9ศสาาซคr ๛ห™ _๕์`l,Mฯ ็(ืŒ„€H๓21_/=šค"\f๘yฎกขœภ1šพ‡ส$*”(ฅษ‡? ษŠข4mc#-$๛ๅญ}‹nีํ<=‹o-ฤAx1ไž%๔!บฮหซ๘ๆบHฎ %9งA+0e฿‰นnUแืึ~ก[Ž™6a๘ˆฮฅ~u(b~ ๒‰ฦvœ๔ื‘-3n๕;็ยยž˜ฮ“vํบ`รค๑ทิฟHšƒ๒ฮ–ๅฯŽŠ/P žžฯ:WตึิS9I’N.๕อS9ƒษหๅTSฯnุ:๒ กnั(‚ิ„ก9๑Hฺถ @ั?๘ญกFuUx๗€ัˆไ=ใ'ผlก๙ญา š2As๊vFaฅ๚–พB!GQT๚๒ฤฦ— TฉP?ข’จ3ซฃ0ฆพศ‰C/ฤฝ๎จnว๋ฟ จฺ& ‚bj4๋€ัฤๅ$ช@ฬ;xHb4์Gโ 2ลšr๖Qฅ๎Vxฏ01 Vฏ‰ใJรŒจi“พhค1ษปbบž~ฏ1ศ‘ิ4ีC/งฬtุฌ}ฅาŠผK—s๊ๅชK๓ … ฅตใงลi%ฦ๚๚b€๒Œ ํqฦโ' ฬฐ= p(p% จ”๚;€โŽแM?฿™ฉ/Š>Hธ$$-ไฐWsฆYืPœl๘3oฒํืoพฝิ\žv~บugSe@ฅRญๆœ -*K”E*…ขP}C ’ฏL~[์šฝ~ =ุ7๛ศžƒณ~พ[\ใป–๑ ๒๘5็sๆลO€Š๙€Ÿ~งs`ฑซฎ$lส?ฑ|ฺ๚ŸิŠญ <ไำKYtฅHฬž}yI็บjPqxœ๖ชถรุฟ๎CO‘Jค ฅ๒๋๓ฺณจ2ฉบ‰8uUIx|Šัq่ฒ9~ซBฆ€ค_:mหDฆผyfล่ภ-oญ, hFีพณ_ๅ๕ฝgCรS›๊<@u•ekึ.6akjVVTจัdบ{[p”โ๒๔Œ*;‡/ ฏAQฏณ‹ ˆฦW‚ชะTy9ษ๋0 \}=์uuD1[77~b_ๅ(Šแส–็g๓ร|ฃกชTโ(๚ชˆqๅ๋>“w4้๓‡กa็ษaRฎ ฟZR˜ฉ–็ ๛๔wฑใภ_‡nฦqIท”*ด๔{31จI P_O xiลยิtษ็ำลขkุv0ฐะฉ{ลTหE(U๛๐งฒ829GBR‹@ `ณk็ัณู,>ŸP๛฿ข!]ํฌผ†ฎ๏ธใiฦ W(2v๎โ็ืลฯฯฯี~๔P(”X_ฌฑ/Lห1xจ@ซ&ง/1๛อ›Yธ:hโ๊ฝW๋:cvŸ^ไU๛ฃถMช3x๛‰™ล฿[้5๏แ์€ŸŠ็ฮ้MŽ#พ๚พใฦw5”Šฤ C—  ๅ>|Bgc ไ‚ิะ‡ๅ}๚๘๐Š 1cใฺ9Ÿฦ&&…j‚ไ๓xtMญฺฝๆๆ:ouฉ’ย๗:x5{'Lh“กกจ6kี_๎หCฟnl:]ฯอฯ MMRท~ื๓า;ภŒBำตท7๐x-5 ใ่RQaู๋š)Deuฃwข BวD“สาch  แ•า-]ู สถื5UVsk5)Z†4 A4์uMๅฏ.'y ƒNƒ'0m Kƒญ=1o‡โุ—๓ŒฎญวยŒใ่d#/)jq~ถ Lก@ศดฒณึาเ่๋ฐQเ—”pM4(T-G'kผฌคถแยะ3โPŒใ่h#+.$‹๘Mpฆำ@kwS @ีัถ0Tจ๎ฟ`…ลึค (ŠขŸM ธีฉ&hVN64 †j˜ฺV•ึ?๑สgGSสฺำบึEว฿.xํเzuอ aVช†kgŽ ำr1q@๙™ชgโ’|dFFjืEฮฐ="0?:J€8ฮ๑๋”n๖†T9ฏฐˆฏฌ™‘™˜hญ€แ2k๗๑ล~tศอสด ์idไ4t๕ื}ฌ,rœป๗ไ—ถŽjjฟOm]]YQัkฃ\นf๗ zš0i #ฟ)รbขใ๛ปเ๑;ฃ*EQ…T*•ษUใ๑ p™Bั่ฃฤ —*?ตBIรŽฎP*>a สูu๎ึอ_uึgฐฌฬc๒๘Q€ยqึ_f๛jc€ฒlƒ{:geeฏ]w›พคณ[ำvุ‚1”ซWี)yz๏Yง้‹;kh,œ%โาทa–zy–ๅไดlD‹็/9 ๛zšoiิoDูpAh๎ำ~vฏื‰?๕ฉDUšณฏ^1ัo๑7l7๓ัฉฐBBM˜Sn฿p=q~7&"q3^+Sง™ฅสLq๊ฃŠN}gja พ0\f}K2‰ณ€…F˜D๘ไ`JR…"ๅf–ั๛I]ฉDEeโ…ŒบNfmๆLฮพษ$Gฤี!*-โVณค…Wcง4;o‡ขุซี ดสcd๗0ํ-ช‚—๗๔๔๕lxตภาo๛Aq่ึรีี๓ๆ† K||uศฤ%พi๎๕}gž $1ืnZŒบ’:ญ์ฬฒŸUOŽฉHsBE ๗—ห o W‹{SXx5๗MแฝODุl๒๖-[ๅ๓ืุ9QNฤั™KฏTภๅ ซ์=ณX•ฅ=๘}ู๎d]nว฿['ห3๎lŸ๖‡šอ[ เภ‚e–[ท?XfN)‰>ตhษัhฐ@t้:xฑฦณ๏ฮ\p[]บŽU–d†Y๔CxหฌG Va,^0v็๎ำ-ฯ‚ฯNเ2kักš šHZรkฤr็—ฟŸJnbฮGฆ๙o๛T์ฏู ‰ไ}กธ ŸOึoGj๖oภ {Nšกqw๓ต๖ถ๋ณยิชv,*ฬ๙xใTพค ษ๕$ ๕๋F ํqาƒ๖5†„ไyํ๑Z๛/‘ิภt๗2O}vน;&L’ึD‘Ÿื-hูwJ%Aโข็TํNBBBBBB๒้C๖TR๙h›ส“9HŠ8๒๐ฮศO ฬหฟjๅ ฟd*R.์MนะVดไฆ•$$$$$$$$$$$อ… !!!๙ ”Ÿุา๊vก%›๎“ผ#ไ๘ Is!๛$$$$$$$$$$$อฅm๛ฏi฿-กมgธีศ}๘ดฉหWฬ]:๔Po} ขํ}สผ™฿|3o๙ข๑ใบ™ื์2‹้:Oœดt๙ผๅ ว๗5lz๖•v€็ฤžญฝใกถษะฏz;ฟใผฏbาว}๒ข ๋ึญMฏย4้ทhlgU:ฺžS–ฮแJoy˜-CฏหุEฝฮ‹PoR๓ ›yš9}ลŠ9_ฯdืิู>ฏ๘™<=๓‘ห:ฯ~qpบฬ๋"ฆั#tืVI/OŸ— †Fšค$งšZฑ!ซ5ื6F‰Šv2๗`8๕ท๓ดFห ฿Z=P๋ G‹๒ด๓ืDT๋ƒอKๆ”ท้r้›ปuู๔ฒ-cR™ญ IDAT$yl&๏ฺพค=๖Ys“Iูุ9pKjC‰฿๗เFy†ไะๆoภNsฏVฉผึtๆ๎mn7'NNย]ปดe๚A{kN“อป๖ำ’ย๊F‡›&ฎ๗ ฺ–I5่๋ญ}K/_Y๙ไ]“ื€๖ซŸ%Gวป^ฆี|g๕๘=tVlํ๖“ฏ็งอะ™Ž็ว8GอOด๚fˆ˜::8Ÿฏ๊g›vํbฦj(ฉ*x’€v 2kไ-F:[4VไGบ ณlไjๅ็†>FzŒตาj(ไๆ\พ‹๔žbHXž}.๋?^ป‘0๔Uส 9ฮœฅษว.Q†อwkิ*MวDฯ{!DSทs?+;c*^Q'#ฎPLoท๑ฦๅ๗F]]าŒฬ๋ืสซlํgธJย”บXฅ˜]4๓ฎวEฑปฮwwีจ W^oแtoS}ฝHป‡ต[^๐$๕ฮ‹j€icู+ศศขย’'ืs ชี›คฅืฅฟฅฏ&ษˆฮ“ซ6้CIซ ๅๆฎ‘xฝๆ0q“~‹+~สณเ%]๘‰จšฉื`]Šค<7๖QxxF…€ๅ3|I๊e…[W-I๚ร“—S…ชรถํภ=]9โŒ{กโ๘˜๔[4ย—ๅ๗๗eืžLmาoQ`ีีX nI๖ระ๓1<\ฝ5š๖qฦ๋—โi์ทฬ=็"+@ทวœกิ๋‡nKๆฮ๔ำ๑Cวš่jRWo’$๓a่…€h๕ุูล˜I ฃn}œ+Vg7#"/Q วAžŸ[บlศxห™]oฯไลายWฏiฌFOฆิ˜ึร๚ธjะ˜T™  - ;v.^OEฺํz}ใ!ผฅฐํสJบงณปIึๅ3 ฟKืP8&F•ฉงชฅ@aฮ๙ฟ@ D$ถิึ†JบGX"ig#[†œ›U๑œวตvฑ6lZSหฦพ:yoEต ฅ0ฝ‹“ต~NyYฉฃนb:œ›/๒๛[มตoGฮ ษ@-nk่z๒ว/_บ3Bj„ ;tํมU‡f๕9Œ๔*}ธ 7Žฏูq=พื๑มž-ฟZ฿อร(bฯ‰u๒rย๎žp5L•&ฝsPงg‡GD—สข๐สขBƒS{๒น๚ขตkไewฦ้Nฐ`|˜ปถ๊งRT^Xsฎ4โ๒Žท6ฯฮTญHFฅb8ณAฟณBถaเš0ฉg่9{7j——K"3PwGฝ†ยRID2ู๊ีษ กฐH$้ะำนัฅ ๚A,๊ืฯีจก0ฏ๚ฮs4`ฐ{ฃ=ฒซo„ับ๓6m(ฬ]{D๋>าฯผก0ณ๒โZะุ. …้ยc"sk“F]šJYF4Wจบ`aจ๙่ไฑ8พ ๖๚ฃผYถV*๛ ภว‚“8@๘๚๎ๆA@sหH ค&ทำ๚ฬ2ภ—‘-(~p๐ZlM™ฉgภ‹ลP๙ยi—)ห—ฬ\1อ.ใ๔ฝ9“มTข†มsฯYพp๔ wตึ—็๚๔ฬ‘(:แŸญOู๗B๛^๖†Eiง~~!B้>ะฌพสRฬต(ั‰วษเ˜ู๋ &๔สู๙–hมDยฦ† P๙dฯำถ&$Uฟ™†“w:๒่YฎfsK ั๔ํซ]{do\Œิ0ฐ#ป)“‚์๔๓ำO๏Žผ๐Pๆ8ศยXฝI/N๎XjbSงพฒ}๚๘Qy์ิร"Mkฃ๚:ลยœya็๎{ev&๓๕0ต=}ต^^8ตJao[Šnตkใๆ๓Qขืโา๕๒คE?๘็ษ ^ํฑ&ยิ๕pCรŽy"Cฟทฏ- อIห3ดตฆhZุ0ฒำ สž๏ผk฿ฃ๒สศ๓7๏ฺธนฎ๓ฺ^~บi—NธZ`ุหฯบ{๏ ฃ๛_ฏ๛๏ฺC้jดavํ(:ะำฃ๋ขg>6Nh0ๆาธŒŸ๗ชษํา2Eญ์,นฉแu.h6}Gทญx™p๑aNq•€fๅแศ}qฑ€KTผxูyœ‡๙ำAy/ขหฤ8ˆณโyใฬŒเE q ฃป ๗ถวก(คฅฏง^š’ะ2วXอ่Rอ—š‡fเํ่กโ8BงCNำ&xm‘ภ•(๚z?ฅฮคฤฤE’pŒ฿คRe๔0 ๎S;qp~แหงO๎ฝไ7๖XV>?าd˜๘ซ\ย฿ฬฅ†ผj๒ื‡บ0jึ†Y™žอ๏biŽไฒl 2๓›lี74ฉถ1ฌ^ˆใx}รXตI’W6พ@zNƒF๔EN„&51ัฌLP4;vaฆ^Iฉx›๛Šไsƒ',์.•VธYP/ฅัฐ8>piฅดv[X”QjขงP @RbERค9E้‹Œญ๙’_P๒ๆฟ็/Udl้ัฤ๒ผ=#•Jตšs2lดจ,QN]ษืN&ื‡2bhVII ็/=hถฎŒ_W๛ˆฬ็ฬ‹ž.9x๚ษง—ฒ่J‘˜=๛๒’ฮ„๊2:ผ๖5.<>ล่8tูฟU!SWา/‚ถe" ำ<ณbt`บใ๛—{[ิฯ&กt๏฿+ํ๊/yต?Uๆ'ล|ภOฟำ9ฐXUW6ๅŸX>mฺ I^กู๋ทะƒ}ณ์98๋็[ฑล๊kAส‡‡‰ใ)€w๗Ÿ3ฉ<เpํSํต2z^ฏษ[šYYjฌi53Z€•ฅ4;ชฎ๛@ต๎่]uw็ี ‡N0ŒBxm' FKฤDฃ d๛ŽxๅSจำWJโฯฝˆะอ0ถa'_ๅ๓crคำmBƒฉyชLBะZ‚ขxำ)๚Aญœœฉพš|OZ—ฤWi•'^;‘]ฯา{ะ๐žy็ฃิ/้x#ฬFขจRูŒ้๏ฆ ;M4ุึฤDรฌ ํ๊ซhšั๘ลqUฺ›*Mบพณ-?กฐ p 7;งบ‡ญ $ฉ๓F4;“[=msƒ=กSฤcอ9F๙gหS๑บเธ๖ฑษ>ดในศบMƒฝจ‰ k&š QH?มˆš‚๑าKโL โะฦ~่ึŽly^yหD(EMƒ#ตชว~็๎ำM๏์ไ Eฦ๎ั=Hซดƒƒ=Dแืๅˆกeํ]’๗Cำeศ๏ช‡็๎eI,ฦ์รhฯุฟ^4p๊้๛Ž๋รxp๒I1๐ธ\8DU1 xtMญฺ๚ษ07ื)x๛lQBRx๛~โมม^Œ-งš*๗VํUพWlฏภ@มƒ}uYU๙ฉ3x๛‰i)K‡ญช˜}็›‡ณขๆ'อ้ฝ้Aศ็:hฺš0๛อ›Yธฺ~โ‘7_Ÿฏีd>ื่5กhเji\Fญฦซš ษ-˜ริ๓—8ฦfฌาข๚ฉ SYU๙šอbniต‰ณ ‡‚ tGnY9€ข(ทุฬหWŸIฅjฺxธiๆฉ๐4ฝขZ(ฅ›้sจ: & ^9อิ†A ่๗f๖กถD”‚Q‚ยโ8Yัไ,†&ฝถ ส$บ…›AAY6z&x5๏ใ^(˜ปMibZซ++*4m๕Yl=ื Žต^฿เ@/Km†‹ซD’F๗Fsยบ–Ž† l;;+EyI‹sIu˜:๚l ‚ฒํl-ๅeลต๑ำำq›.ž–ลู™ ŠU• s+ “ญซลR{ำJหุv.†L Eำฮฮ็–ชk!:๎ป๙šะ@h:ึึ๚~Sœff๒ $๗ฤึงl}๚ฯึงG๏ Iษจ์<†RXl Šข่—4ศ 1Nณ0tฐคQ0”ibdซ_UV –h9u`ั)(สฤ^KX\ฤ…Qg’“ิอˆั๎เะทฏ€ :•0'CรูO“Iร4M์^๖๋k๘>2ป๕ฑc0\fํ>พุฎNเ8w๏ษฝป/mีผ=˜IZ ง๙ป์ุฒyคFอoฎ\ณ๛„ =M˜4†‘฿”แn1ั๑ภ์:w๋ๆฏ:๋3XVๆŽ1y(NMp’ง๗žušพธฃฑ††aภยู]".xซ[ำฐะหณ,'ง-—|ฐ๚iๆ็o]ฟซชไ฿.xฮจ @QT!•Je2P๗ผ'pน\ั๘ƒธR&Sศ}”5ยFน’ p™Tั่#ร —Jไ>R5Bฅ๒uกD‰ใJฉX&i๘‘( ฅR๒†'p…Rู๘ƒอชฬm]]YQ‘ช:๕zM–D<Š้2uฎ‡.Sรผืœ16แO๋+ํkeิjผcMn‡๑ิฤะˆห-}ๅEช๓ธ๏œ๋ฟผฐ๋BJqุีคฝF-@ลลฌb* 2ฺ๊เเy™Deq•๛IM๖จๅฉyแ๖}gcRa๘‰—ษBEฺ,ร~ฎบPPน4yFsV5€Sทภฬฮ Šุงr๖Ÿฐ42N7pถg‘0แV๒7งaรแยฉยJี&e๖w็Oล+…ษืา [dQปCตrท-MธีฐD/๎ว8 ฑภ—๚"ีฃT— z ๎ฉหยฤๅฉ๗ผhbฎŽŠ0y‰ay=z๙Z“ชF^ผ›ฏ๖_˜ปฐ'”ฃ~"aร&hิืCฉr~มณ‹๗๊w,Jฯfu๒(น~ปแ๘ข,ๅูวพ#็zRคw_‰U=๋Sšp็ู€๓;1paq์ๅ;jgฎษ2ต2rjd"A๖ำ๛‘Mดฅš›ษํŠ ๙q๙˜น+— รฎ\Z๐–‹>gไผจ{:๚xMfฃŠสชฬ;้ษ• Mบ™ญืql*^U•š‘๑ๆใ๚S๋}™๗๓เ^ใ‰qžใ ฒ„—€„[%Se%โบงฌ2๋^š^Qsiธเ์w|TU๖ภฯ{ำg’I&“{'!4าฝIQA๛OXQl๋บvัืuEQฑฎ(J้Ez(I€๔๛d’Lฆ๗๖๏2 ม๛ฬ3็r๎}o๎;็Viัแึปy๋๐‘ํ|๕๘อปส฿ไSUMg6ญ/ี[ˆkŠ›enชโ4๒v‹˜ตน๖๗Gธ๐ซ์APl[้ฝ๎ tUๆื‹•…๕=5ฏ9๒แซ36}~ฎฮ•ฉไ๏qOh๙๎ล7bฟถ๐i[uำๅ_ŸXุ๊จ—เว5/zwSๆ‹žิŽ]ฯ=k๔ต ฟ๓(z+j๖ๆfˆx'ฟ๓า ์จฯฺ๖๋9ทถrซžOZ์ไศš๒ฒพืžๅ๚Twฟบ๋ิธco๕jัž฿ท<G\๖หgeƒล฿ฟga>๖—ฏX๐๊>}ถpฐ๐_ๅพณ(wฐ๐ตููƒ…/คZ&z6๎ไ`a๋‘ๆมยณรZร0๖ฟห่ฑฺ๙‰ƒŸdh๙แนท‚?_๎[ŽfA๎ฮg^ฝw๐๋๏ัธ%O2ฦd^;ลbš7F ฎมŒ˜lPอW๛kวp๘๒vฅู ิ>p จ\9หk~;^9>,‚[Q!c%dฮ‹Q-›๗T่(Žษหd]ฺ|๊๖ou7ใๆษฝ= [ว๏ชH‹/)๔ๆBŒg–-NGwืตดใ{gฤธ†แV—rLํฺ;š&#hูsำ}4…'OŒ็แึTศุcnซ+K˜๖์บ๘๎e$คฎ#๋ศ@ ฤญ๙ˆ›FWธ๛†'Fšย_๊ฐิWiีg>ZnE…”uว~ฉ;vงต@ qธC็ว!@ ˆ @ ˆ 9ั6wF ฤ @ @ ร๙@ 5๎กgŸ}4ี M A Ÿ1lFœ5r๎Œ/;ชI!*ฟt๑bฃฆ็รiฺโน1าฬฏN 8Zsˆ~่ก๛สำ_jpษxr~ซw฿o}อ฿gตำ5qVโ$6!ไฮ*ญ„ฤธA ๓’œlจค^ูVz๙ุeกลmrงวGu/ํดฦฮcษ|ฮKวp๓S๏+*ฑvt@?(๖Ž๑้>ฮt\งi-ชฯ.VtWปฉัs™ ป/ไ๖ˆฃŒ~ แ„ฎXษฯ๙้R๓Nฑธ–ฆSฺc blรไYฟ๎ฟาวUปฐ+'ซฯqคบ๛Apษx2A๕๛มซึ๎ๆuzาฆฬž6ล›Kำwe8–/ถ˜ๆฑ˜ๆHน z‚๊์2}ž‡'ŸJj4-9 ™Ej3€mˆ_F฿ั't๚Žขฦ3—ไใecช๑ีั5%รำG%ตA~ฅ2ต€ๆ๊žš๎แf‡›•สฺ์ฺFtท!ำฝ}้ธ^š_wฑDev๑]qŸ‹เศ•KM$Pg<ฬบœwคpโT3“;y†ˆ;ƒKKฯีUˆฌชรM|,2ไZ“yโuใa_ฬ~๊›ฟพฆๆ๗5'z$iฏ}๕๑ใษnฆ๚3_<าทE*ฬๅ/ป฿Nแด๏~แืNH†N๗5‡ห?Š/|/q๚g๕Faๆ ^<ษโะะฑ˜ํK\๘]'ธ,}๛๋ Pษฝœ๘๏๑ถใย2Kพ“ผดฟ@ธๅžฐื/[ ๋2ีMz8ู฿,ฎน๐ฟw^๔R๗;฿>ํใ3๗oœณมฺ!r‰_ใ6@T๘Aิ๔/š?6๓6w์|€คAูQ{แปืื7{†๐5F๊?ุNžM)=}ฉ’ๆ:ๅพ{ฆด~wก‘ไFฬJžโM้>ŒžAW๔—หฒh50=Or~๛ 17แ๙ัmr;I‹!ํ'%๚*ฒ๗๏ญัแva‹Ž.–X:/Oฅิณ8t€^๓žCg)ีฃ>ู™6ำŸ[_~เจ†เ:ง- ž$ฬฯG{T7$€[›ื2ฆ๓ณ๛ฅ):ฟ๕็๓เ’๑dา๕”อ—NkŒ‚แ[ื้I๕›”ยฌๅวrFฃ๖?ย4ฏรrš#ไ6่9Z่ vuูŽ\-ฦw›๓ oHmYนš–สW](:Riฤ์ๆ=้แŸ'ฏธgญN ่A)>ฌ๚าฝ…Zฬม}ฦ2ฟ †าJ 3,อ‹RVผซ\Gu๑™ปะG๘c€d„ฮ๐eW•๏=ครผๆใๅWSQ $๎๎e M ฬ'Gิ‚฿ip๏ิOI๕กSjช฿9^ลV†ำ๎,,’Zปz๛๑{๘๋Mฯฯ`^iํ'd-๘Š5้Oฬ๙ืญฏ\ž๒ฎ|๑ม๛–‡ๆ=[ฝ:ใอ{ภโ๑ฉtโ๘xˆqF๔œY.Ÿ}g7g–/ภศŽฑแฤdySZ+jว\3ฤ-ข๊ะฦ5_™ั๗ฟ0฿O&ทาาำาแี๙Xึ—๏ษบ๏ๅ'฿๚ฑใrุซ5ำ‹‡ฐU72*šŽ~๚V› -~๋ัXู้ฏฟ<ำ 9ฎลวฆใุฟ฿;ชH~ๆญUo็ูcษWŒ L#๕0Icพ Rn$ภุึ*$cylhT๋D5๒›Eณฆ๎“ไPŸYl?วaˆ4]e%ช  ฎ.ญL˜่˜iู.7juห`4IŒfฝNkๅŸงV๊Ytภ™ฯ่_นฬค“J‰ณuˆŸแ๋็D#•๒ฒฬฺา๖ž[q๘ษ๓8ฦึฌสฬ ญๅืลึลYQฝOฅ%ฤํ•>“ าc\~ย ?gฉTTžฏ-ปว44ง์“}ฝ8ฆถหU็J5คƒืฒ•^v‘E€:๏ทขนE•F}|ภ aUi'Žธฮ|:Nถ๋Pž่ฎsgL๒ฑง่$‚’œผFฅ€5๏q็๚?อ!3Bธบ†์}ึ+-งi—Œ'็Gณ@r้—ฆฮง3๘ฬ^8-ฤFืp๑ฬัryฟ๚ฅiพ๒๑xW๏ี7@|แ็Cy หiZิใzงฯœโฬ$ยs—๒„+iฦ๕อ˜5%ุ…I(:Š3/ๆด๊X๗,‘+วbพว๖โo็๋๕ฃีst0X yuฉZo่ด)]์์ิf–`๊อfฬ`6๋:๋๏:–Wฬด G6I5ศีธ๘๊‡+xO&จO–9คฤ๙šณฯ-‘พ) Sž3๛$ฐซO–''บ48”>ก—3Xty]ฅZoI„JW[.€ไอีZ&กTDzฑA ใบ:+k๗i $@{ำม๏ภ@คึzฺƒ‚๎eฃM,ฬฮวOSณ\cจิล‡๚๐ลCฆ>พ—นญฯ•ฬุพ(ชO˜rฯขสŸB/ด+๖~ต๛Ÿ[Eผ๛+IRh4 … T…~ฒแƒoeMฌ[…7ไิYณ์ูฯ'{฿OŽษ๋๓แ!7V( ์๗dnะ.ิ'ผ๚๋#m๏ฝูึๆ๋lนฒํว{Z \ฟg[ูW–~‘œฤอRVZ9m๎๒ล๖“++ชรB€9๛รํo-ฺ้นๆมฎ๛๊-฿ถฮุิถ่ƒ๏žIUœไำดykื{๐ฤgผย1์Oึ๔k]๙ไ?๗๒N|๒vฆ๗c๏?ฐ๑ฟ%ฆmjธCeC s๖๚biํ๛|Gป•M[ˆู @wŸ@ศdJจz~์ื3ถ\ฎภhLื-:ิ ˆš๊บ‘ฅz3๋(ณืฬ๐0‰kOศX๏7d‡ฦล˜KvT๋เZืNW๖ฎฝy8`t^ะ์I“š็*Aถณง‹ŒAศ •j%ค‚œ–ศฏ;ทณVMแ‡อšฑ+WhฑCTฉWฑ้vNMU'ห‘รQัT"=วมัะšฃ2`จ๋ฮ๔pdA—tuWm2™ธƒ๔ๆฒฯรlภ/าDLG}kถRghทSฝ8ะกmMNปD ’‹ฬ๖ถlหL+* 3๚ธภ5ิ฿Tyjศ>G รp‡ลภ”โฆ๒“Mื.u#@W[‡‰ฺ๏aFšึPVไ”6ษdอˆแฑ ฑ๗nŽ"อมzrœ4 Y]z๔ต๕-ณฃ\Xะay€๋ไคiธ$าš@ะุJ์ฤ@V~ฎทฅ# =8Œง‡‹ลธ#๔AดถŠ5ziK‹&ษืช,๚น>6ถๅN้๙ํบฅ๐—ƒสธ้ฌ‚Cฅฒn{BงQแlภŽFฅฐ ˜;8$NกqอกPญmค^Eุx:่‹ล*ัำฯฮุ ‚ tๅ‡ ‹ญ6๛Ž“fk=Kz“žJฅใ€WFBdWแฑb‚ ฎYE๘5_ยŠ^ื;7Ti่่w3 HQ๗5;€$I ๋qขฎีŒกณ๊ไพ* 0<"f/˜)8Vdqวrš7ฉŽ›๛ฌ™1Jณ‚ \น๑#ขฏBp'ˆ•(žฑ!ิv™Ol˜}]i_2cญ็ฐก๑"'rพชฌ์?-ƒ‚ใ$yํGเVq6A้-;พ?mธีzŽCจแ๚ซ?Uิ๔Ÿ„ฦเ๘๚R:ซ R‰P๋๏้ -&=9 'ขงนภ:ฤ๕"†ฎIทW๙QขำkpvO๋Mgs šพž2:'ะฦ(่j“ถNฉi๔๒#‚ ษฦ[Kึ‹คฝโ๊j  W7ท6x‹6ํX]ต~ษ๒งNฟrฉ„ผgหŸžน1s๏H๗฿Ce้ณ๊ืผ @งฐv]‘๚T๋œU`0$๛^Jpต;˜AึA@ฃQ€Jฅ ‘8๓žื7ฏŽ>๕า{<ฑ็ุK^rDŒฐ๘”(.\*พ&cอ”ฝ๓1wcูว3“?-€„Uฯฦp:w<|W“ZbํŽ™”ํ"nศd g8ธ„๘š:๕:ฉ„แhรคเพ กฑดJ=็bCc3Y๘* 3๚‡โ๊-ชl่Wh•Bม๕๖w`sx!ษ“่Bป่ vlœะช5:rะ`ฮ าt[{ร9พพž&‰H=&iF%f{๚pฉT~ุ…“ฌ8E—ุฦ7ศ‘Eกฺ๚๚x˜ฅ]j)*รWxv๙3รk[zlบฏp'-x๔ฑ'฿zaˆ†‹๓yฌ2ย๑cSึEŸน —OabFผ๙๊ฅ €๏ฬ‡–†w›Š3ื‡พไ–ำ‹ัณฯyฬœฑไ8“ชซ๚์ฅk2ฯ;อš๖๐ใ,B.ธz์J'i-d็•“ีณS>=“FjeMYูลVปij%ฉำซ4๚N5ฉึซLต๋2ยV$ะ0ฃพ-ฟVjM]ฎlJr๔J[ŠY.ฏ8Qg}ษฎฎโt7=xษ:ฎื ๒ชK:ปำฌsสน7–Jจ”ี'kฌ-‰้Qซถ๙ช_pฦCnƒโ๊๒jฅE•†}ศฬn4ฯ0฿ฎŠ๓ญNMYV‰๙GหJฮ”ื‡G€ฎS„'ฆฮNฑgแ:Iฅ์R‹sฌฆ้”๘ยx๘ฑi น๔หมซ๒พ=ˆ},นgc"iๅีถiฉ๗วmๆœง˜Qีœwษ๊ฎ๗ ฏ8Ÿๅ6k๚cS˜„ฒณไฤ…ษำCไ—ดตย๓5 ฆ๚ึ]h4 =‡ †อiซN}‚บƒ9งซ”G;ำgD<<Jh5ญ็สญ๕ศkr$๗<ฺ๓’# ๒๖ซ'ฮ^๚ฯpื€ะœgฏu๎4™•Y'ฮฯrH]0%‚&V˜WW.}ๅ™Fป้!๗ฦำHตฒ๖T]ƒภ๚/ฎšhVฉน้BรŒ€%ัอ2i้Ÿญ}›ท๊%J…Žf๕nูeœทOš>y%7ฉ”™uUใ`Mืฌอตฟ?ย€_e‚bJ๏ugผถfาWŸ\ฌt5ึด๚ำB@ง๎v้๋ิธco๕jัž฿+ต!ฦ&“ู…N๏ถ›t'น๒]๊Om๘y)C^|๘ฟ\ี‚~฿ฦฯ–ธ&jnุมU_9/z>?ใ๏_๔lคใ6๏_ฬ‡ƒO๎ฬ<๔฿ท ymํ7Ÿ๎zcั=ถcูTวMgวร๙*ˆ~ะcbBฤee7\8’' ืežฬํ๎„ย0pŸ๓†9=!„[๒~บเฐโw๏ํ๎ฆtHYป!Eฑญ๒ป3ร6๗->6j—นฏ|1วจทfm{้ีmCmY3ฌ๏A€ukVlฒ{D๑e!3๗o๘๑˜๕]y๎4oEฯมPำŸ o๛แ`๗ ?~ฝฬซ฿ŸYc„Ww๎ํษจฝmฎK่มโK ฝนใ™e‹ำัl"ฤ]ภu--:qำ0‚BŠ3วิุ(i &Šž0ท7Uลฦ=๖TL๗‚R/บrr|NOA 1Z€ธi๔ฅv–EำผL=-กj<ตป๑ิึ@ ฤm`\,ยE @ 4€@ “~ข-ฎF ฤ] @ @ ร๙@ bธิ%?nn๚$yฮ2z$Lง)iฑaฎlBั^|๑ji—i๔BŠwRJคฟ ื+ZŠ๓2ห$&ภlc2ฆz;rจ„AีQQp&ฟCoYล›ร.A?ๅกยŠqฐ1๙ƒธx/oวUแ˜ผ*V}่Dแ-ฺ๒ZFใ;อเœ๚Hด|ษโ;~š0l'ฯ“W๏ศ”@ˆธบm๔์ศPyีฎ‹j ณ๗šฟฤวถฎ|ืE 7๎จ f๏ †Ž3;j–-tžสษi%๊˜๖`(ซ ๗ฯาž2n`ฺE%บาI…ฌ<ซฆJl›แ‡D ZL๛O๕ว๙€S(คูLB้๛SgŒภe}๚’GSsฮถพ๔ม™vฬๅ/ป฿Nแด๏~แืN q'ฉ`’ํI้๊่ล7)ษ[š๓วY)อ+vแŒˆ๖=E]ไ(…œˆ๔ษœ๊ฬ]วU˜cฤยyuชuฐ)^ชใG๊๕7haec๊@ n†โถ[o฿ŠŒn›๒ใf`ZPธ'&เ’["ฎƒ๎‹;ือ?ฮƒฆ๊/ื๏ฯ/ฝ๎>wuท…Vๆยsมษ๑{๘‚pฏ๘wYีฑ๓jšงŒ้ข?$–O—~HโฏFึ+มnฏ@ย'ีๆe|V฿-๔|๊๋|๗/ปฟž9๕•[7N~บl๑ม๛–‡ๆ=[ฝ:ใอ{ภโ๑ฉตฯˆ;ภHฝธฅ!งX ๖L๕ๅ๗ |ไ;5F€๚สฺ)ษ~E]โั eŽ๎ŽขชCr= ะQผ๗็๎ŒŒ:=ม4˜ฬ@bฃู ืYํภโฦ= ฝ เฦ๙yrLํ๙*5$f๋—์๋ใH#ิŠ๊์๊’v#`6)ษพพN ะ่อ4s%@ฏะฯื‘Jจไู5ฆ‘ึ์_ ›  fํั5c€ใ™>{j[฿’›uบBN`ถžษiQNLB%*ฟt%Oจ๏๘'‚TYfVCf57~Šc๋นSนf๋‘”่ศ Tล—ฎwฌeฤ๔ˆ˜‘ไฯgัฃRƒK žฌถK^ซ9WลKœ์ร6rณNUศ +YU:hs์:]ช๛๘ฉ๘นC9@sฮH ๓ดฃ่ฅํ๙ลEอ*3ฦ๕JNไ๏ฤยuฒ๚ซW.ิ)I‹eภl=’Rฃู ึ˜iฆ€^กตฒTสR๎ฃร(m้ศ+K=รฝ๘C -3Fทc"b’ถvไ—Hคแ^.P|ข์Dy•์$๛!ซt๎<;Pะ=l•bํญTuฬฑ๗๒ัิ๎’k m4ฦ„y๑$–{E‡@0Rง^ma‰ฤpแ{[NคN‚R’คะh จ ?eร สš8ใ•ˆป‡‘ฎ0v546หžpล`s@ซ6;ฦฮŠฑำชิ,{ิB&IเIษหW๛ุƒณาƒlqMษฉ+†ุ…=ฒ๔๑ฅž-วs†ฒู๊ม”ŠcW๘ณห6ฮช_| ฏฃ๊เŽ+วs๕้ฮTฟ„ ~g๕กํูOทษ{ฬช_Bฐcgีํ—™Cำnh;ตq๐ ข4ื\;‘64’x๚ฯ฿3;๙‰แ>8ะ‚’โ/๏๚๕เพ+ฺ ‘n€9ณ•‹Zฃข๐๒s5เ็e @ JŠw้ศูนํภพำคŒp'ซqยโƒtนวทm๗{‘BY|๊du๗ciJ->|pฑnBธ7n-#kสย(lฺ{zาl]<้mอ"`‡'…“ๅgถv๔XžศึO %Mu๊ผ๚๛ฏ๛wž๒’ฃ่ึสN JŠw๎ธฒ๛—};OึH{žบ!ห>‹นณธกS 3Ch‘1บ“คฑS ิa์ฐ8วฎผfั€๚cE.J\๑Pโฝ๗FO ต้้ฟัIฬ๖nlถ›ซNุ>ก๚ไt6iะ˜น‘มvz†ฮf:$ŸฏSศ{ฌ-…\ฮwt„ฦ?ถ\™c๎๛?๎Uฎ฿ณmตเอฅศy@!ฦbV*…Jฮๆป9ั„œ PจฃTggโก]—ฉ.‘๓fวทfVjIฑผฦ์ jŠCPZzธh_Q‡ีŽKMmพPjหบฬ๖6,5‹็`ไ*๕fะทtuP}xl่ิ๔ นฆท—ลs0๒”FŒข๖O&ˆัิ ฮAฆฺ“พUีWห›dฒึ6๓$[6€ส–ฯื4_๋Lอ-BJ$Ÿ Bฒฃ]`2ye-ญ:c€‰ยขุ๒๙ฺๆซ ††fAzจD:‹ # ร่ฮNถPฉyๅีบ.=€พณำ์สeXฮศš๒ƒ165‹“<\๐๊Vบ‡ซmKM;ู)ฮ`ฑ่ –ดิdถt‡ดแ;h›.‹4&Qอ…sฮ–สฎแ๖ ™Bู๓ิY*;;ลก~ฺsŽซด˜๛elnว3ภ7ฤrผมa}2Uัแผr €f็’˜ิZT  (‘AŽ4ƒดะ่๊z‡พ(8… œแเฦUาIฅงX{ฅ ?$ รฎด์_;}?+tีื฿พ ๘`ีส“ย =t‹˜ะŒEn6›q 76Ÿึ @ว ณyิB ์จ,—๊AMญlฎ3*;‚}ๅ•g:e$€ฒช.z^kQG ๕’ฤ วIฒงw$ วฏ๖แ8#xๆ_0ชI'พ;-œฑs ๒7ิ๎?g›$zš4ฒทๆqฟ&$HทZŸ8ŽDฬ™@F3ฉ;๛B^Ÿฉ์;ฅฬpชม ]ผิ18-บs‘๒ะ6ตIc\\Aศ๖ไตึu{ฌ๊ฒ‹Ev๑ฑKฃ9„ขณพจ(งNAŽใDo1’fAo‰—๋'ฒ์ฒฺใ4๗%4๋ zKน฿YฦโvMP์ขcุ๕็*TฌkRย ึ๕LJS %<€@*qgy่Š ๔๘Dr€ รข๓Eิ žึ{t!Gวฯงžป%้"#d๕ฌ/GaB’@๕œOฏ๑~๐[๚‡K7ถ๎xi๕†Lูเุหง*wฤ_’}3‡x,Vฑุ4#ฐ8Z=zกAG\๛๗$ €Sp’$ศ> N™YODŸGแI@ไ5a๏’ ด•' ส&ิJฦ;๎๎๋ฏlฺ{ƒฝƒิ<†ƒL็!•%ว,_แ๚Œ8ำ<๖mปhu‰ภ0ฐฌ<ฮฯ฿มุึช่5pิ‚&อtO''ถKWSfะุU—yดpบฝ{ศ๔™Sร„gส4ŠIc10ฝฮ@X,;I๖UvƒJaกˆ–rEEŒžฑธw<ž‡ษY˜;๖`ทสฑ๙ะ)]D"ฝ๊Tซ€ฒ๗ฮcโF1Sืข฿ ๅc้ Œฮ๊iฝ้lถAฃ๎ฝD็x๙ฺ˜„"ก’ธAH1ฉDยดตฅ˜ภ–ห•ˆลภ[ดiว๊ช๕K?u๚•๓O%ไ=[๔ฬ™{7L kฦไ‡ฮฦf๛ฐ('6ฦ๕ ฤ ’Q อ]m]Nก๖L*ีฦ#(+v่ๅฃฟ?‡Šat_นฤ‚ื=Z™Œแ๎kห เlOGgB-ี€Nฅ`ธyฐXl๏XOฺต.ž, …็–4รำ?X๗ ๔ื6฿ศvUJ$l/&…bใๅ้Nศ%VMฅDยr๓ดฅPyำg‡:SฌdDม)L&›‚แ๘ Qั)o‘0;%n~’w?฿Zิl๖œ่.ik้iงน)1กnถ, กSk{}]ฅDย๖ rbSqบฌ๛ง1ญ•]-Wp<}ylืojจ7}่ฒฦb๎w”1ธw]๛ท^m๋ล฿ถ^ใฒT[f…Ž นน๘ปำฉ8ฮrr๕ๆ)ล}3็Hyั๑๒ช‘5hใyk '0าŽEฃฺ๚z๘โ]-าž vaมiำ‚2œจ7 ‰@ , ปšU˜๘ะS<&-๙ฑ{ฝณ.•€๔ิk๓Vnฮ“Žใ&ฝ^o0ŽZ\ฤaฤใ^ฉหๆ‡t[ู)ฯก๊ึ ํ Y9Ž้S๎{ˆEศ……งหบH0Nจ.;_hŸ:mลT&ฉืœปZง€ฎ‚ฬ๚๔ฤ™งQ ข๕j^๙ศถฬ7ี_ฎuL YE#UŠš๓5ฦ๚WฺคลแšŠฬึึฏuŽษหbhธI',ฉึ าฟ T๗ oIM๖ 73ิไไนค%ญŒf๊ฎŠณWฌO:3ิไไปคฆ=4•UญEนณ•Œ yฒู+าจ์,8{ฉฐs ”ืษ$ หะฅ์ฯ%MFL˜*;ฏ7ดN$มง&ฆล1qฌ๑J^ฅถง˜ฮ)q๗?ฬข”-๙นUkeืีไU๚edฌŒ”Ÿฉl ช์ฐ˜๛hqOMœาํฒp cU๙ฮ R‹B ‘G;&2๎ษ‰Ami๘ช@0ึ”ํพdฉ–Lโโ^ยดุ๛XธIญlฮฎฉQ \F<ัLs๓ๅ*^Jภ‚tB!-?าท%ซNฆT๊่Fฑึ|ฃฤ_žไฯ๊๗=ฝ{[~็;P๖^lฦg๕M฿ฎ};pำฯ๙๏๐อ—๛ฟ*@๙Vw๐งฦ{ซW‹๖ผ๘>๕E0&“ู๗cš›ท์พƒฺ &๔ภไ•>อOท๊mgD๑KZ๋Ÿ œ3c!ณ่ื์!๖Qบqšˆ›f๔ทqC๙vท'ฃ.๑ ้ƒใ‹/ฉBด1N่[ฐlq๚ˆฆ• hโ&๚Aฝฎ๙E[` nบ cKEฮญทฟ-dd๎lฉšผrUค™ ๕’‚‘Ž|”K0๊@ bย€ฤMcจ<~ ๒Neคn= ๕ุฆ‰ธiF{;@Lฦd4@ ๘K€ฦโ๎k4๖ฃtธ+ธ+.5ะ๘@ .ศ@ @ รๅN๘tไน๓Lt๎ูxGฮ]<๛ม•๓W›>s’c๗iZ '๔y3Wฎ˜{ยธษฎ ๋ัญc๋>๋คd฿ั ณgไ‚ะœฝk'ย IDATหƒ\†Nw๚ฦ๊ถฦ3/ฑบฤx$๙ณ๚ณ/๚~sI\็=ข( ŸTwJฤBq๗ง?i`ฟv{Viซฐกๆ๒๎๗ๆนๆฟr[nyCล™็ํ ๕-`p}Z๗Y๖๑๑‚ชถŽึ–๊ ฟ#ี~$ันo๏พRYฯ=ญ฿4ฝ็š฿ำว›ซถ.ท๏ ›Y}งD,์5ีุธศcค%บอF''01* —t๕?๏ส&(ฺM]tT“ณ๕อX่SีUcเEฅ๘“E—hาเ๖พi)แ^G ZŒฃ[G%.ส1˜:FตE'วฯูฆฉก“fPœ7^Sp ZGu๒อศ๐ํ]%$- G“แศ•‹b"–`๙ล‡ธโR๑ D #&ฬM^y2GEu HŸๆำuด^J€บไh^ฅ cธฮL๔nmญ™8gะฆ๚ฑš‹Uh0;ิ9ญล5V›gM้กผ2ล๐ฆ2lุl #ทช’R?ฉ๎/๑}ๆ?/ำ~šS'๎ƒปyั๗นฺลO๏[š๗l๕๊Œ7O์5‹ว#คRKo–{F”‡M‰Vpถห๕ไถjฤ๘yฺ๗๊[w เ^o~กก๙ว์a'งBSำ็i;Ÿๆฆ้•`€žธขoฐฺโ๛าB}žด|Dl่๊7—ดlH]ฒฏ‹โ๗๔ฎห/.๖ยV้pฃ+~}ˆ+$|Rฝฑm^ฦg๕ฎต}๏๙6อEY?Qู†ธŒฯ๊iN3u๒ป๕‡ฟzษขFVธอƒ^ฺึ’W.u๗บ๖ผ˜๔z‚a0™ฤ &ยhะ .)ฉlPHqkณ&อ•-ฃ[„;ๅ่ &จ‹tIu=RfHิ"~็eณ?–กฅ๖ฅN ฐ&'๚๙931ฝV,h+สo—]3ลYพ~๔ฆ9 €)ขzญ‰Sงด‹๔ตePcQhMฅ@ํฅVป)๎lSGa๙ฅj IuN]๎ึฑฟจZ œ่%‘xึๅ‘eๅ1?&ษฯว‘=A3W QLwฟiqฎ|จEยKํ: ฺ รภ(ถUŠeฎ‘ผe'.uhปDx'๘r๔ญฅงณjฬฦ->1ิวNช%UนEลฐ(ด ^ฒ0ˆ ๔H( ](ู้๒{OOM™ึะฺ๎aW/ฝึ˜“๚vฉŒแสฆL˜๏™LšผฑNe0Hฤw€ฑ8 @ุฤญ๙๎๓u,Yๅ™ญm๘xฃ๗^๐ั—๏ร76_๊ฅ๕›/ห G๘๖Sฐ6Fuo ‹?;ณižj๋“ำ฿ฯa#V}ฃ์ตhฒO_%เ 5$Iกั( $P=~๘ห†ผ•eมฤ`๐':๖—ศtูXœ๏ภG…๖ดO๑ ะ๕ญา๊ภgน„Dัjwwa yaf๔šŸd๘}6A…Fอืx๚บ ๐^”†:แํZ๖,ิ็Iก…p ฑX๏จP้IW(๕ ‰X?ข่I๘ค๚ะำฮP๖^์‘ขฎ๋ฎEgฮ;<่ล‰นx›{wLโๆVโบวX[qกศ8iฦส๛ๆฌœ็&8[l0hีf{wW:€sœ์่L†ต่Qไ~a็ฏE5ƒ๊‚๊lOฉ,>๐Gตรำืจ>q!.๒บใ{ฒ’nงJฝณ/ฅณQฃgkQ›ศรัžgTJuึ„ึ`๛R*O\>pชหfŠท`’:l\ฉž+M,่ฒฆ<ี'.˜/ช>บ;๋Hf›œฐ^Lฬ.2ษพ++w฿‚rƒK\ธํ0ช ฐˆIฺา!ึ?€๊โHญฬ๙}ฑฬ฿ฯh~Sข: ๎=uดP์V„๒๊,Vhชฒทm?ฒm๛]้<ะ,ะk ป๐ไ?[ฝVห`ณ๛_ฦฎ๖v •lย8 (>RVืํ008v,ฃ~จ‘*V๘ค๛V$-Ylƒ&\"Cโ๑ฤฦ๕ๆo—D%๛มeฏ๔)\ปoŽปผ&ฦ',ใ฿šต?ผ#<6็นx฿ภ˜U?V๔kฐBc|๘‘“X7ศ+่ๅ3ตอMUyGฟy*Š ะp่_?d)0jj”ขฐจ ุre๚น๏{ธWน~ฯถี‚7—ZtฐPŸVh๒่s๒ฟ็ทิWตžป็ไ}/าŒ(บE.ฟ์loฯ๗ฏRงง„U•Œ๐^Ž‡6œ๎35ยพ5Xณท๓MJ ฏข’ซา้)3W’FจตSTll23uv6สอ*‘˜ R€ๅภ7ดสดfฅF3๐ออ๗w67”๕์กF›ศ3ห:.ŸฎV„๖๓ๆy๖wIEyW3k@S_(”$2ฑู—รP›ฺZ1n๖x]อวiˆฌฮ}b๑ m๙ = Wซ†ฐ0Hyมb0š 0ถwjใ{–“ ทSGkฝย ๋”˜ฉเ8๐ดญR@ lง๓Xะกต(ผำช฿(8… œn๏lGฅ“*ง๔,เLšŸ š๊ %รœเ3nภ9.ฮN^žl]uUUํU%Gs+1ชkBZ`@[a•jp0*“ร ƒ 8ลแpHฃNc˜Hn1zpงปบุa'ฟ{๎dท0 *ชฯ๗๒(์=๗อ๓1Ž฿~โ\ฑ ชฒฉŸX๕ณ5GจrŽู!S๐ฏŒธอ ุฏ๚r'Ÿœ๛U€ฃปšพศะ•๏\{฿+ูF€–kง๏g…ฎ๚๚ฌZyRH •,โzฎฏOห8๛๏รŽ<9s+=ฉ/ถผTร๐ฃˆ๐7rZ:Y๙อส+Fy๘4็OUํEฑœPี7Fฆ๙;WˆฺIECมมFœJ!M&jศฬ็1YTp ]๕้Bภpœ$, 0ฎฏฏฉ๑ฤ€ูH†ฺาต๋?=N”7๋, m็ˆ๚์˜u=ฝ… I๋vˆtญE”ฝ#HXn6ํ2๋ฅฤpœ$†U ‡ธ@N#แB ฦmๅ™,ภqœ${Z’ pท&k@†aFQึ>5#ฬ=6ฑบไX^ฅ (,วฉณขยฮ็–ห๏ฌขร‡๊7yšปถพR˜](‘h‡0'ƒFg่ชnk’zุ ๖pŸวvน1นgŽtศK ^Rฐ็มดฟฅวบ5+บฟด :nช ฤคฏI์ณๅ‡฿ ๐๑ฉ๕žฦ๚ฌ}Ÿฝ๓ฮ๏ี ัh>O๏ฬบ฿4Žบ)4*ีdฒ8N,ซ<บณ๒Fนค‚i๗ืๆ๏๗ญ‰ h๒€6š}ะŠฏ~[๔ุNช็๗~z๗ใ†฿า฿8\บฑuวKซ7dส†JัA๕i)อฌV๒๘ฅj3@ำ–}/gฎLz๏JๆฐฃŒ๒3>ซว˜๎ พ8ฑ็ๅ๛S?นแราqเ?เ8ˆ^ห˜$I บฃฏ3ฅฃตC &ำ0ไฐ๘h Iร{70ฌ฿(๎๊โฅ๊๘ณ๏ G็xyRป๊ๅZ qง.ะš;- [Mๅฐงjฤํ$WพหY!ศโํK’`–๔ผถkLจน๘`ฎภ@2Cข;Z‰@Zบํๅ๎๏ŽaM@’0ิƒ} 7hq:‹`‹ญื \+eึJ:dแ๖8ศ'Hฟี!8X_ธงฌ0่ใ้cc๊ต+ Žsb<ฝ๊lซ งลโฝ&๊พyไ้ˆำ๑๋ษI“๗ส—†v`๓–ฃ(q Yถ8FAd2™MฯคŽT*P=?>8uํWฟ|บ๚โ=฿ทMฆบ-๗งZ?บษdฆ๔fโ”=2vม๓ๆMR็ฝะd}ืk๙–O]พY๑eภ5Oฦ.r้œูํคQV}|ืวณbแ uำŽีU๋—ผ!๊๔+็ŸJศ{ถ้™3๗ŽMW๘ฅ๚{ธa๗,›ฌ:วู=ฮ Mฆž7€ูlf2™CFH]ฉse?-ŠfBๅๆ0ƒฎ?ฝRชs๐๑aQ0Œf๏แeฏษ€โ๊ภคPm7—;i|ำ๛eฉญ๙y2,๘™ฯ๕HJ 3อ(iJอ๊หส\Sf0˜aOnูพ.Žอ ๕‹ข\\Bฟ๙ย์~kƒŸ๙v็ท[๗>k9€ุศM{๐ม้n,:ำ%๎‘ฅ๙%ฆเ๛แSS์)€s็Mmhh้ฉืๆญœ'วMzฝ`JŸILฆ3A’„l๘้๊๚‚$อ:ยคํ1› ดื ‚BC~‚$Lf๓ภA6กล ฑTŸ„<ปe็Ÿ๏๘žีp’Šฒฎฤ%๗z1q 7โพ…‘ๅeCE (l๏๙3ขDMM#[qปวๆฮ ่ฮ4๎0ึ]ูyYT’2-6yy•ะ+ Kซี ญผRฦOŒYL5ฉคต—Š›Vฃ[สงoc"€%ฉั *WPฉถจ‘ฑฑจล+eาข uล…VAP๏Šชƒฏ‡ฒ1ทŸEo๊*ษใ'NฅƒQงํ(ญฉ–€Eแศทˆ“ผ4นตฝoa‹ส‹ZฝRข๎ SW^ำำbศŽ’~ฒiฑZy๕ๅฒ\๐ูำแฤ‰VหฅG †ฤ5nZš๗?.r…/๋K๖]พ+oฌห+qLŒ]A'ี’๊ฌขvซBSsužWฬ๔{|)Fq๎ŸWj๎ยGึš_i4w PJ+ฒ๊ค=ฏNิยด( ŒZmWCUมศฦiจ.้_Rฅ๙…ฌfฝ\ฉาำmฯ-SWษU^\b์2ลฌQ6_ฎฎตผO€ฑ๊ปG>ณkน่ฃGž?<ƒ๔ฤ๘Fw์็Sฟูtตมัุtแ›ฟ}U ะYPB๛วฟvพ่B“”y๛•m ๙๚๋๑›w•ฟษงชšฮlZ_ชัŽ _๓ใย5•›โ๘/๗ฅ+ฎ)n–นฉŠ†rม5G>|uฦฆฯฯีน25‚/ฎI‡>xsทฟฌใajQMๆ^R ๊๎Vน๎เO;๖Vฏํy๑}Kฝ๒ฒov” xจtฐ๐ๅณลƒ…O\),\ZY0X˜ึ’7XX{คyฐ๐์ํZ@mฑ>บ*๓๋ลฮสย๚{t๕ำgทm่h๕—ถ&qี™wฟfฐr;†O฿K๙๏@ั[Qณ77@ฤ;๙๏eG}ึถ็^ฯQš€1™ฬพ๋ึฌ๘kM]๎ฏ:ZPฉบ_๘B/ัก๓"tช8๒ํFvgQgวxX~A Lšฌศฮฝฮ{ฐ๘’๚หฟนใše‹ำ๗ฬผำZ ฃๅบ–vฬ_ะผนยz1rโN`ชไ< bœ0ึO#ไน{บGวŒuงs๊๎ฐ2@ ฤธ? @ ˆแrcกo_ํป‹ล‡eŸ(zŽ’;[ฬ ]ษEOฤH้หG๓้์๎ง/ว;๛,ก'qwเ้แrใ@ฤD? @ ˆแrณร'˜ล`Lฎทฟงฏ#๓/X‰R๖;ซ็Dฉ%@ ˆ›ใฆŒ้—05“16*pV๎•uสบ?ฟ,ปฉ$^ฝุ)ทp8a™ฉ5^OŸๅ๒n*#`บ๛O‰ ˆ™ไ:ิi,€ฑ๘‘Iq ฆ.žŸ˜เ=Šบฒ๗š6อ‡?ฒ8ฌ้้ห๎ sป๙\-0ฒ฿•p—คล้หR<™ƒฎ\ฏ'ีuฺโ๔eŸ8gB8Œฎ–qห๔D F 3`ูgีดึUdos–ๅบซ พn‘]x5คOเ๔ะฮ™ฌSv๕๕0๐^{ฎฏ—uสde%Z"bs๛/แa‘Qฮlœข,ฌ’๚จTๅ/ื>ฟ—?ใ–z฿8๔่กฺ`4ึอŸhJOˆ™˜VญบQH‡€  'ชคพฆNB–Xt6Ÿำo>˜1ฒ฿Yฎืำ,ฏ-จjฅ๓ย"œู}, oE๎ฃไ–้‰@Œ ,๔ๅ_ฟyย.๓๓yK_xๅื/[&฿๗s฿แภ^ธrMมงปซz~;ณaร<.IBฆ–ศ๛฿s?€ฎช€eIˆ@ ˆqฯˆฆ{HB Šmx|ฐ<ณฒŠm์”๖า=ž๊ฯV6—žฝ้ƒฯฮ pL^๗ŸŸศแ ๖o๛?๗ิL gท7€ทร3 !ง=๗ษOLsฤฤๅ~๚๊ ?•่ฆาผ5`้oฒฅŠŸ–พx๎&ชโFฐฝ2f๙€ข*๗t•ภnšฅก๔Šมsj -&kษษi’๒‚Ns๏ถ๘CกซDฺฉ20๘^ัฮถTRฏjซฎ)nV›ošเผ(ษเœธุภิ}ฉP}น:ฅ ฒฆD !€;?สG฿œSอtbล…ูๅ ๏ธสโrzH ฉด@๎3ีช๓/ด;ท์fฮ7$6ุม–…ดฆคชNj‰J77dสŒVGม•lฑ‹=Img‹ุด€&ธEแH`8๚ฤDบ;qpฃF-jm.ฏ•hY–žภธม1มŽ๖l*@’€‰ชUฒfณ๊ฌ่i!w๒ฆŠ@ “ˆฅ๗…aW๙โ{_ วqฮฉต๗/r๙‡ณฒํ>0—™๓ฮM?mา฿๗ฝฐั๔&ปjrrฒuา๖vฉžoKย!AำโŽp]๓;`’Nง็r9CDฦmฝbœฏอaนL๊icฑEวR฿๚๙ผผž?ๅูNณ%˜ณ?ึ ฏ=๘ไ—๕aOm๙vm•œ,†dฮ๚`๛ห<~y_ป[๘๏ท๋#*๗๙ˆ‚๏Ÿ้๙็_฿5ฒcฝ‡ARYT]Poaภ…๎แ๋‡I…r’ษ๗ rม@ีQ\T]'! ยช๊‚ข๊š.เ‘q,MCE“ะhใ;9"ไ†‡ษb7๕ฒTv5ตคฒพจบ จถE €๓'ล๛{ะคลWสkีุฐภพ้5lg?žฆI ŽS  €bฯgอ,งฆึHutถฃ ฟ์Lท่IฮtykiนุศuŠŠ๒เ„J#‚แ`CJ›Š[ Cฃฑฦ>|ชฏMQžWYึค ฺshค•'ใ‡Fนฺ๋3KT&Ymษ‰‚ฮnฟqXU7ˆ[Šงง'yิๆซพโฺุเๅๅีwัiูŠ”K;๗ €‘๔ฦฟWqNฝ๑’iPๆ~”Ÿตผกฑโุห ์ก„แr9ญ~ฐ†o.@Œ†มอ๏€๑‡๒สฦดไ˜‚Š๖vฑล๘l!จจPนกNegi“’‚อ•fPPš=ฯภฤฑcซ3๘xฯ7z€€ุฉv ูปg็น ๗ผwgฯNŠใlชQ[ศษbHZ์T{nโ-™X–‚X๎Ha@๛•ฟˆผžycกkำน_~=bต์8ฃPรวจŒFา8ฉE&ตฐI ฮIืFa}nฅ”โล๕wเ34ะ)ZšF‡€“ผMุจ.ื†ฆ–ฒz)ีd๏3ูมGนัz~t๗˜I>โฒlํ0๕๋E'on2ฐ˜ฺฮ&กฐ[ศตๅัภ ่lIฉLE„3Ÿฯฃ@๗ จผคYฦ"<ธtBึ\งd:iš›ฤ~ž^Žฟ์†ฮ‚‹jL-S˜4/—p6“  J#’ม(ฮกž.MUqซ†บGc NฃSH b [๊ ฐ–;ฉ๎่ินเตZซ7Sy^Œ ‰š0ฬช~๎ฤ-…Aงa23ํ๘0šบ=ธ๗@ช๙๔๚"Zิ๚ฯž๑,๘xํYาc&@a;ธุ3ป|{u จจUฏฟ<ใ๏o>ดํž฿, ฐ|๊ด;+#พขชq๐ฅพนqำXl~๘—ฏ–&ฤE.š—ยbY^๏ซ๊ิvะB8i}}ปUsฯp_/์๐x็พืHิ5ž๚๘ษGฟสฃำ้mญ_jll8–m$‹! €ัh๒ูป๏ธฆฎทเOBaฦฆ,AมฤญHฑโชRขˆX๊๖ญชUซhตZ[ตZ*?[QPฉญซ"ZT,*".P2d„„@Bน๏กm€„ไ๙~๘ใๆษ9๗ vvv„๊ไ[ B๘A~O„/3๒Qะ๏7๚Ÿ !ํย>ตj ป฿๗ฦIMโ?vะชฟˆZโฝฺฆ5ปถ๖ํส ฟN{*”Ÿ[>tหY!งLqm‘ข’„B*ภพ$zฮร› ฤ555d*๕ฝ๏Ÿเ*หfLสฟ฿สˆทaฅฟ<์;xFK]?ฉT @!“เ฿›฿640ฑ๋ีษD ืฐฝ€จ๛‡ช\žAศdQืบจเีฺtD"๙#R‰X?cู๋:๗q2}๛ไQโ[=—} UMฉ–ฒ›ƒ[๔J`้fี•Y๐„ฅฑŸแ•hเๆฟ;?ƒfFท๋นงญK็๖…I๙Šv> ว>เลตY‚FF8๕ฏ:ีZo๖=ตM@ฒตต(;;{€7od๏tžะป๊๒Žหตท `]vr†์: ๎ Žฏ๗ๅฑl๑มคฑ‡฿์๙pำ  ‡ L&ˆDbฺคร™๛> พkP๙=YฃนB5ฎ ๗_R}๒oqฅั็_–ƒค€[R"€ฌ”ไ ˜า๗S฿๊พ_ฎ›dtf๑ิ๏“l}งฒ3๗`€ใเ™3+ž\ฉ๓ร(z๑ข z [ดs‘M>ไœ5OQJาๅฅ‰.ึC† ๊tู•"Uฮ–กฺ™˜’๔้œฬxฅEฅสW็Urฤ`oใเ^iฌo฿@ศๆิๆฏ4ปฤพwปช๔ง…5 dื[T!aee ะu๊แ@ซ^A~qU%[ ๖ ฆ•™ด†ัพ›^ใ'้๕ŒP~ูI$๔ ifๆfๆิš*น“yefyตฒ)ฉ8๐ณžๅYwq๎f—u;Ÿง0ฯjCkวv†TS}0lืมIO\QZPAUไH”m—joจต0ฟดฌR   คŠืRMM ะ,ญE|ฉˆ_Yฦ(ํฎบฌjณๆษc*hกf๕ฯุŒฅ_฿ฎ ไ;ํ&ู ูuQ๖ปFทฉสฯoน.จ-(ฬOนž/›”L๐r“ฎ?ฮ๎๔,‡ๆ?x๎–•ค๛ฬ๑ฃs๏^† SAP;K‡BHzŠ๊C=SงNL#๋eAUฝฟฉRฤ@๏=zr@pศ”!Œ7Wv-]'ds็0xย—sƒ>๋ฉŸdืฏX๚~?^฿ณhxg:ุ๔=ฺฏ{ูน#7’”f฿Ku๐๒™0iฌงูฤckึFdTH3S_าป๗ๆ7f„‡SQ\DยลIIฅoฏŠŒœ 3xชkOณ๑ิษ™A#PLฺฺู0)์ผ1ฃ“ฬy›Q" ›Yuถ5โ—ผษใิ€‰ญฃฝฆ,งฐL6L ชห9`bnngฯ4%x/^>/ีฅOย)โlญซsŸๅsซชDJฑญUลแ้ำ้–ึึํh‚’ยR~u[jฤดtqฑioFๆ•ผฬฉ†ถฎึํj*^ฟๆผป(†fa็l.z“-bv2ไW3m U™ฑ‡rหž๓ฆJB7ทณณฑ2ฌ~yU™กฅ#SR˜[!T6%ฅ—dโเfaRอฮฬ,d๋[whฯ0ฌ*.[*ุF|fฏข@ IDATก;YS€fjkรค Kณ9f ‚eJ฿f—LลิึฮบCkKช 8ใีำ7‚…{KŒ๖ฌฺZดoo้เdืž\ž]eฌ์ช{C้฿<ห… ZWe๗@HeDษฝ[นVƒฦLัQ|x๑’}ฉ•ฉ๏ขK;\๘fอีผ๖gNc–๔โ%EนSV4ฅฌฝ๛@๏ ใ?้Jy}uฯาต'ฒ๙ ƒZX6„Bช!ัh}Wcศ†–ถฆnซฑs2tน“WXฌ๘=Bฅิˆฟฃ!าa&nžŸvัฯ{๘8-ฒq็;๐^™Tฌ๊€!Dฒ3๕โ่๓#zlHn… B5M“ฮ_’V—จzW !อ7^Jˆล nUˆZ~Qแ[ง๖}ผษD ฒ์ษ‹R< uhเD›ฌ฿bp๐€BmJ“Ž? „B!„ฺคn!ŠB!„B๏ม๑B!„BHY8~@!„B) ว!„B!eแ๘!„B!ค,? „B!„”…ใ„B!„ฒp€B!„RŽB!„Bสขผ๗‚ข7h@ฯ.;่Sต•B!„BHขฌ์7ทI$5๏‚$๖๎ลเฝ,˜๔›ทrน<฿[thว ำ๑Kƒๆธ์ฺน%7๊-nู–-ฃฬH ฬำไำ๏ฃ6OัK‰–:bvเฆcOz,ั|๊๕ย๑B!„ฮs\๘๗“Mฝ }๛ฐ_ผ๘s๛๖?HฮKใ—’ท๚ขyeIIุลลlกJU/~ก จ‰‚๊C‡y3 —5 6?วJฏ'›ผG คœ8/iฦตะ ัซŸ?\๐๊ฏร7 {:ฮ๊E*็ิ_ุฤ{๓!6๒๒'มc˜gฏOFX@/๋พ๚๎!้|^๕พo๕™ฒwจf6ŽŽ`i\;`†\สฺ9ธฎfอ™ น—ิ]&? „B้<ึอs-บNน@มJดO—.๑ ๏็่โ†ๆก็๗}Š฿๗5o๙qๆคŸ๎๑ช^ะQQus —U๊s—^๕FCK๛y{s๗ฺ›.หโž<๎U){'‡~—R_Qƒ๋~2พพ`อ๙ม๗ƒš'ำœ ฯ*'™X;๓๎๎}ท†[}:ฬz2Wฎdีฝ‹—Ÿ’๘u+F023s4ฐL8~@!„าyผ๔หวำa„็vใำ ณท'๒ŽบLณ|จ‘๙ฑa[n๕mH>(f=ƒึฎ๘ไ๋๕ำ#?;Zข บยy–*ช^*ืมษ~”ช๙ฅX_ุ”e฿็‹M+#~ษ๑๔ฟ,โฟeจ=—๎žkhวย›„/ @ฯศบญ„#๘oYRํัฃ๑ปR| ศ@วKEฑ฿ฎŒษ…ž_Fฌ ฬ๘๋x€กืท—vZU\๒ำs ,ŽB!„ZŽžูฝซ‹ฃƒ5•ฺ๘ืฐsŸ#อgœฏ!ไ_<ˆฐ๑˜0ูL๎gปท\ฮธu>K๖๒ุF"‘ธฐจ์ษณฬš)4ว!„B-งk็ฆ&†7๒๘‚†K*๙œิoศเN|"{๗*วvซ>(C›t8s฿ศ‡›M8\d2 @$+ฎฎ(จธ:›ร07gผ‡™ั)a/ฬk?๓ปoจJ ~>F๒Ž6)"๏๐˜” }G( ‘ษ$RํัรO๗sjV{๑๓พƒzภบ๘ํไŒvะ}ม๑๕พœ?–->xSแ>Rฮ.07gิไ฿ฟ๔bๆA€ื…E๕%C๋ฝ2j฿xใคอV๘๏•๒ศุˆๆังKืฮžฅe7ผ€8~@!„j9๖vV‰IO<|ศธ๋˜Iž];้ด๋5nๆฬพนทN&ไะฉ__ภGฉ5๕ื<~–C๓ตั๖I4ํ‹ฏ์;xFล%@!„Bส๚|ผท’'๖(_Rต๊ไีิZ–]až ƒŒ๐9!„B!eแ๘!„B!ค,? „B!„”…ใ„B!]ิ*ฮกฏOซN^Mญeู›œ'ŽB!„Bสย๑B!„BHY8~@!„าห‹"ฎ?ศ,ฬหMปu:ฬฯž 0j฿[N ‡Sยแผyy;fหh‡ƒึwฑป๐4RฉS๛m/ผ"vด’K`drฺ๋๔;Fšk;ฏฆ#OŠŠ‰น•'s์ฏgc’ๅถ ๗y'2๓3ำโw๛;ศ} 4ืIป.&eไๆ<‹;:฿รTลv๑๙q!„BZBป3jฃฟใ่CฟWyอYr˜œแ5ฅ  ,แะฯ๑œฃ็|๙ีแž๗˜ฦQzž4fW7ฆ|DภJฯ—ึ|ลR๕kŠP‡ญฑฆŠd/:Œu;7ฅหร๙ฏB|ึ_;+CCสfkข–C๒™qiYํ+vฒนIตฯ~3่นz๋จฏจ~‹7˜œึ-’ฑโ๒ฑน}b7ค8ฮ9ธญใ…iƒา$ฮำย _–ไต9U…†q€B!ค%=‡y3 —5 6?วJฏ'›ผG คœ`?8ณo๏3ธฯwu^เถา๓คšฺwฐ5‘TŠฒŠ 51~ะh7นSyไ รyฎA่Qฉzzz %€b7v๋‘ข๏ฦlธ+PปกC๋1uพรํŸฎ8nrฉ€อ’ฅO๊8eLGงื˜Y0๙Oฒ+ซh้ฏ-†[ะผ{$“R"xkฤ_฿.lฉส7็/!„Bi‰9ƒภb•ไG…๚Œ๔š๘^‘X @ฅ๊k%ป™6v-#๓ว‚—Dr8xxD๒fปˆณ•Kc"C ึ๛ทชม์‚C<;q&U๔Ÿทจฝ‚ว๊ŸMฎ.ซศฅซƒ‘ก›ซ#‹ล`0™nEmEโ๚2๗qU<ŽB!„tมษ~”๚(ฃL‹๖vฮG๖ณ(,,ิrnญ฿มOX}QRส]8ำ3่Œ๓ฒ%๔A{SธฺKฏ ฬ‡ฯ ว|ง๒ฟo๕๓๕-ŽฟW๛R|u๏~P\Z๊ษaษ๋ฅH$น๒_$Uญu< !„BHธXUณrภy™ด๙ี™'8‘ž๑~iโรชอtาRร[K2K่uQŠ่ฐcซ[Nzฏป๘l๛›่ๅ![”ฟสDซ๔ปฯด๛sืฮๆ‡๏้y๕ํ{?ช่]@๘,<ุ'\พศ๛ป‰L&คช p€B!ค%lภœ๐fFง„uฟ0ฏ}@แ฿,?UYš“๖ไ5[ภ*/0gš“ -, สสส›;WzO[‹3}วิพ6=ัฃp๋ต‡C^.ฐฎbvส[ณ๛?œŸ6วw{ยYฑV3U–Cฏึถขgิพ๎–1f๒า39๛บWฟ\Te6›M3ฃ๋ˆ€ไ๗หซ%OผGRแ&? „Biษ“ฤ;Yใflห็๕ ๊ ย„›๗ฤ๐ ๐ฒ“ฎ๕ฌฎd๚;์…SถO˜d6๊‘u็n‰โyRIMD>R#%hลAลหฉดงo–บพ‘Mาƒป์๊^ๅjะVบยใี€™, …"฿;ซGงelาIู$stXlง C๗=ฌ}หยญgปฌศื VฦŠ‹„W. [_Xh๋ัเฉถSmล„ษ{JH$ำžฆ*๙‰,ศ๙ใเศˆไฯDlฉ\้usฅxดrHvAมžE-ylบR.jลถ฿‚คRท๐มๅˆสฎเฒส\บ:ฅ0\Y,ƒษp+Dฒ*ฤ๕e๎7D|•ว๑B!„ 8ูRฺาฤb1ต}ฯ!Lโ,‘ญu0ฎ“Œ:ฺj&~Y~84๏ฅ ?vแ๐Xร.Aย—|W$ีv†*1๗ž Ž Mฌ„Q๏bY‡ื,:Iฒ‘๏บsญ.๑ีฝ[&๏‹K[%~ua]h ‰D’›•D ฺเp€B!คŒm\ฌŒชYนBBกTž ๎p —T‘PจํิZ?™ฌ™1$cg๓ู;‚^'•Q์G‡[อˆุrา{ลg฿D/ู’ภัvšสั๏>wชฅ; ˜uQ1—Uส•M–^พ–3ฮี @๘,<ุ'\พ:Aศ?๊šD&RีFOxาU†ทn๘i๏0m็B56‡`nฮp˜r๏_ryqกžMํ=qllm ด™cซgfุoขI; ^vE‹ณ'0ฦํ‰-^3aarฏู^ทf๗+ž;ว—ชํL•ๅะkำz๚wัIgb.…v3๔^“๔S€“ๅฐoืN่\[‚ ˆ๗2ผ‡อfำฬ่๚ฒ$ฟ_^]™ื? ลฒww๓†ฺฮ!„j6O๏pg›ฑu/?žื/จ7n—ฏ์^ดx`ฯฯ}Lก\ yฎํ<[5 mP˜ตcfฦOj๔่๎ฎยืyภ~ณzิฏศd‰P(‰€\n]“uา?เคl’9*์๗Ž|๖?ƒAฦ}ฦ๖ธ›^e์<ยื1๓ZN=ีSทอZไq;๛*ค4fูf‘v๓T“๐แˆ>kๆx…ก/`e8rเซพข9แ ฟqูu๐ŸUถ๖ซ๘ŸๆํJ!๊+ช‰&wIฮW ๖<ำ๔ผา ZŸeก~ฦŽ~๗ ฌ๑ย!„P+๑๙x๏sšต ๆศ๖“|kn‡ฝM—ป2ึะึน›MMำผ* ็nถ5yO๓J%u%‹N!•UQXฝŽ‘ษธLฺ๕ย฿ใฤ ƒ ซ+lจแ”ทฎ 6งฯ้หฟ›ื#p~?มๅˆุ‡‚f ๊…๛็cผ้*ชรoฟฑT}$"B!ิึปำ‡L4ณ}yh๚t G† จtฆlBพคqืv๏ช(ฌ^ว€ึsขนgWฝ๚‚ ซ+lจแ”t‡™sฑ}œจ`ฺกŸlข™‚ญ@บŠddmaFโ—๓$ฺN!„า˜8@1ฃถ3…ช"ฑ@๎ฤ'2ี€F%Dี")EŸFQตHBิ•›PVQX]nFdบ-…T)ๆp …A…ี6ิpJŠ[ืชฑน…‘ดขŒ#2bXe>ั,A] ฬ๑ผ้*‚ถTgŽ\"„Bญ‡„+.ใ~”Š…|ู Gb_Ÿ’rUV—›‘ดขเ?W ศVWุP#)้ 1ฏผHvต];ั<มึฯ_B!„B) ว!„B!eแ๘้*ฃ‹v๏z>?!„BH‡เ๘้*รฮcพ๙ผw;m็B5#ห‹"ฎ?ศ,ฬหMปu:ฬฯ฿ฏfคv}7\ฯ)<8Rซู}$ ๛X-ฝุ๐ำ^ฟ\ํ4ี‡ $—ภศไดื้7vŒ4ืvvMGถŸy*ๆๆ"O่ฒ๒HฬSงk"ๆ๕•2pŸw"!3?3-~ทฟCํ#๒hฎ“v]Lส(ศอywtพ‡ช7ปฤ๋ง‘ฎโฤฮ๋wW•ฃํ<BกfCป3jฃฟใ่CฟWyอYr˜œแ5ๅ„๑Œ{bzถ๓๛8ŒุdC9๕๒ซh‘AŸ๖kŽดO๏›[9>ิํ”.็ฟ ๑Yํฌ  )›-ิvช*ก ฬจT1Y๙GV,?V๐^!ช฿โ &ง†u‹dฌธ|lnŸุ )Žsn๋xaฺเ€4‰๓ด๐?ร—%ymNUกa<€tU ฏฌ ๐m%>!„ะวซ็0oไ_ณ`๓ŽU‹ฅ‚ก๗ˆ`=๛+jร„€Mpด฿Gข่fัŸฑBa มMๆfJ l-€ =*UOOคP์ฦ๎8{vน'ญ๑9้Zฉsํo๏ฟVาp13 &?ใIveี๓๔ื4ฏมIวฅ”๐ๅฯ๘หbศ`;•šฦใHW1ƒฮfํ4฿>lเ๖ฺN!„jๆ @.ซ ?*ิ็.ฝ๊ 7๕ih‰–ณ๛X“๗”Hฆ=M;T๒Y๓วม๛‘ษŸฝ‰ุRน4&า๋ๆJฝ)บ๑hๅ์‚‚<‹Z๒ุtฅ\ิ‹mฟIฅnแƒห?•] ภe•นtu0Jaธ:ฒX,“)เVิn—ธพฬ†Hต;ๆใ๘้*ั›๛ล™fUj;„BจEœ์GชœD‚Taะ๑ะV3๑ห๒รกy/%๙ฑ ‡วv :พคเป ภธ"yZRฬฝgˆcC+aิปXึแ5‹N’€ld็ปnลGkฃK@|u๏–ษ๛โาV‰_]Xš@"‘ไf%จธ-? ]U65^I „B-ฦุฦลสจš•[ฤล“w5Ž&kf ษุู|๖มค ืIe๛ัaวV3"ถœ๔^w๑ู๖7ัหCถ$ด’ฦ๔ปฯjwi๗ฮf]Tฬe•ึ>yฏ๔๒ตœqฎ%ยgแม>แ๒ี BQื$2™ช6zย๋ฎ2น๕๏{ดB!ิlุ€น9ภaftสฝ{;|๑ห™†™๖›hา‚—]‘ฦข๗์ Œq{ขC‹ืLX˜kถืญูรŠ็ฮ๑ฅj;Se9๔ภดž]tา™˜Kก ฝื$เd9์ต:ื– โฝƒ ๏aณู43บพ์ษ๏—WWๆใ๕่ใ o{˜๙?ฦฺฮ!„j6O๏pg›ฑu/?žื/จ7nk;ฉ„6(ฬฺ13ใ'5๚NtwWแ๋<`ฟY=๊ WndฒD(ŠD@ฎ ทฎษ:้pR6ษ๖{ว >๛‚ม ใ๎>c{ฮMฏ2vแ๋˜y-งž๊‚‰ฉf-๒ธž&v ๘bTลฝฃ…*ตใคซXวว[œฉDy „Bอ†s~eฐKอฆใ/ฆprใ๗ฏ_Y#๖el'8ำ€่๘ี ํfฺŠ๑9gฟงฯ;ิ} e‚็๒ฎeYŽๅDŸ}RณlณHปyชIxpDŸ5๓~ผยะฐ2o9pŽU_ัœ๐…฿ธ์:๘ฯ*[ ๛UO๓vฅ๕UˆDฃีซ๊ซ๛žizi๑e?N5พธํปKEฺN!„า˜ฯว{ŸปะฌM0GถŸไ[s;์m:_Aฐxฐํ”า#“q™ด๋…ฟว‰ mปูิไ=อซฒp๎f[“๗4ฏTขxž —”oจแ ย<ำUพฌทนุ๔Ÿ>ง/rDl^ภ๙—#b š%จ ๎ŸŒ๐;คซhGL›:ถ]y „BญŒฑ;}ศD3[ลAใฎํ๛.ะzN4๗์ช๚t G† จtฆlขพy6\Rพก†ƒ&ฏ]fฮวz๗qข‚i‡~ฒ‰f ถx้*ฒ‰ต=ƒTQ\\'‚"„๚xดภ๑Šต)T‰RAฑ •๑ŸwLฆRH•b— S hTBT-’R๔iTU‹$„โy6\Rพก†ƒ ๓่ฬUฉฦๆFาŠ2ŽศˆaiDT”q๘Dณu2ว๐๚คซคUo๓ชดB!ิ๚Hธโ2nAE๏‚TZQP{ฟT,ไห~ป‹๘โT—ฏิpIน*K^ปฤผ๒"ูี!„ะว‹>vgิฦInœธC๛ฯdต๓[rx๗t+๋™7ู9ณ—ณซW๐Uวm[gุh;ฯV๛่ค“ftNšั7๛9@‡๑กn็ฆtY๖<0ฤ‡ `ศ`่า-c•B™qiYรAช฿โ &งFv๋|s๓>เ8็เถŽืvํ์15Šu๘ฒช5Œใคซj์"VYeถ๓@}L๔hฦ4•คํ4๚Wฯa ศ?พfมๆซJC๏)เ`ev๛ิษ'lฐ,๕สํ|g'm็๙ั!BJีำำ)ปฑ;ฮž]๎ูบŽ๓ะฆร`‡ IDATบOcw{\IรA3 &?ใIveี๓๔ื4ฏมIวฅ”๐ๅฯ๘หbศ`;•šฦ๑าUๆพ‡ฒ"O/ฑืvกv,Hื˜3,V9@~TจฯHฟญ‰ษ[†V @2๏ึอฆœลาn–CsŽฆxํฟ}Aฑ@ฮ๏HlqถriLdHมz wuใะส!ูM๐<๊ฬq#A.ซศฅซƒ‘ก›ซ#Kถ'1˜Lทข๖nฝฤ๕e๎ใจิ8>้*q้ใ๋)ฦูีฺฮ!๔มŽ้2‚“(๕฿Cง„L๓ฏKษšฉอผZ?๏Ÿ?บค$š‹ี.พ O/็ว.kุ%่@๘’‚๏‚ใŠtๆiuJ1๗ž9E๛ๅJีHP|u๏–ษ๛โาV‰_]Xš@"ษ„•๘ชถŽใคซ*ํž๑HI „>.ุฑ flใbeTอส-๏ฎ๛4'๒ะฑ/7วฅ‹ดXk'ญ*ึ>’๖Mั4['7€7๛ัaวV3"ถœ๔^w๑ู๖7ัหCถ$pด›จฒ๔ปฯ ฐปผgg!ณแ Ÿ…๛„หGBQื$2™ช6zย๓—ฎ2๕:ๆฐKp˜บ0"&ฤ[ีป „ะไ:„t›ร07g8ฬŒNนwo‡/ูpไผะย๕>ำื‡_ยมƒุY.8ฺ๙฿WA"0ฦํ‰-^3aarฏู^ทf๗+ž;ว—ชอ,Ua฿ซ?ำzฺ–่ปงcข›ก๗šป?8) *ฌฮfณift}ู ’฿/ฏฎฬWํ๚<€t•ูmhฦ=;w0”sญี|ฌBบJฎcAH'nTบน•™”Sภแตฎ;„i ูะยฮ„ฬ-/ฉจมU‡า นŽEอ9aฟ„š์๓๑็.$4k3}†QY(›่››•…bด.(*[R>Hฆะจ„จZ$ฅ่ำจ ชIชซ9Oํข›[I+ส8"#†ฅQQฦแอิ ๗ฯฦxCหW”Th;‰VDZ]–_{v\u!อ๋Xิ„าeฎจTvJสป ๙ ๒%ๅ‚Rฑ/{*™Xฤซ\]อyj—˜W^$ปZ‚วฎhž`k็/!„B!„”…ใ„B!„ฒp ‹O๛.ึณ{S๏ f๕ถ†้๋๙nuตตU'ฟ์! าเ‡ซญ๕K!๔ŽT@๏ีilPงฆ`Kอ๊miฯŽ๏VW[[u๒หŽา ~ธฺZฟ„šๅภEืdๆๅฆ:ๆgO0ํท0๊๎ณ7Eฏ3๎ ี^9~$Hฺo{แฑฃ\#“ำ^ง฿ุ1R7tึฒค฿ขcโz64pŸw"!3?3-~ทฟCํ#๒hฎ“v]Lส(ศอywtพ‡ฉชํชŸz‘๗ฟKณ?น‘ะิ ๆิฌึผ๙ํสปีีึVฒ#„4Hƒฎถึ/กๆBป3jใ$7Nกgฒฺ๙-9ผ{บ@‡น?ฎ ๓wspด4mไ‘o>ีำvž๊ฐ5ึดยฺgฤu๊vnJ—eฯC|จ† †)V5๔1มŸ—–5ค๚-`rjdทมท=7ฯํŽsn๋xmแ`ืฮSฃ่_‡/๋ญZร8~PคฒบฌXPญสMHTŠก1EฏฉีฒนีีึV]ฮ,ฏŒฦ5aSsŸิเ‡ซญ๕Kญ‘š{K u€=‡y3 ๘š›wฌZt( ฝG ค้ีี๏wŸสไKฤฅฤ?v์hีy|๔ฺM๎T~*J({I„•ชงงR(vcwœ=ปณuPคuŸ:ว๎๖ธ’†ƒfL~ฦ“์สช็้ฏ-,,h^ƒ=’ŽJ)แ สŸ๑—ลมv*5ใธ,™›6f”*‡นœoโป*Mจ–ตๅU'ฟ์ฺีึึB๒บ&‘ษ„TตPํ”แฃ๖7๋Iฒ ๕ƒส7ิ„”–lฑ%าเ<›5จๆฉมM๐b*ฟ‡จูPำ๖%…ZlOnยฉ™งSออกฉLw’ื‘ 7qบตFK*lฑญฉš]ฅš)5asิas8ๆๆ ‡™ั)๗๎ํ๐%ำป๛Oh„˜๓๊๊ญฒ#<›j€+ฝงญม˜3}Odxํึิ`ข๋‰หv]วํ‰-^3aarฏู^ทf๗+ž;ว—ชํL•e฿ซ?ำzฺ–่ปงcข›ก๗šป?8) *ฌฮfณift}ู ’฿/ฏฎฬว๋š‘“MŸม–๚`่h-›P?จ|CMHIaษ[" ฮณYƒ ้`žฤ /ฆ๒{ˆš 5m_Rจล๖ไ&,‘šyjp1ีš๊มt'y jp7ก[kดค๒มš ฉูUช™R6G'‰wธเ8c๋ต+ฟ฿;ท7oKฆ๎ฺ:ณ]F ๏๒๚uNc๓A x๚fฉ๋ƒฎfธ>XดนR๘GฦŒ1้ืW ๗ฐศdฒD(ŠD@~๏ฌ–}rโิ)ƒฆN4uสgวาชถZy&WaPauมƒฤิAณyXั]ƒฟUq๏~กJํ“hดบkอฟZฐ๏เต–็ใF&้‘A*!ˆw๊•oจ )),ูbKคมy6kฐแซ;yjp7ผ˜j๎`^4ๅ๓lŽึีF-Vฝน?›สoŽๆุtไcุŸโ๋ึ-ฉ|ฐลถfร97ญซT3%7ว็ใฝฯ]Hx๗าฦ{ูŽM3†vฑคpr๏ฑ}ลฦKนช๛—ยWpexฅ ึ.>\๙Ÿ๙ & wูีฝ๘หีu็)้užy2zํใา?–MZ~นT‹น5 sTุ— พ6”G๋2eวฎ•ใzRุฏโฌYบ?๙ๅ์Ÿ2Œ๔(”บK ๚{น฿O~ฎ๖‚|\ŒOื‹Tšš%ถ๒๋?ž%/ฑธฦง฿‚๙VผฤโทbP78ช‚VผฤโšO๚-\จก’๏‚ K*_]อ%าเ<›5(ฟBZu๒สoโ†SอLƒ;ƒย๊M๘ 4G๋jnฃซŸอ&๔`บ“ผŽ›cOVพ[kดคฆ>อQ]ƒ ›u“kHฆk็/^ึ.\•›๛แŸฺฝ{ฑ372*ค -}๔็~๙๙ว๗| ๒ƒBUฏโfŽดŸ9ืธ๚n•dธ]ศ<“๊ปUฅโบ`ฉยซฑL?๛ฮฎ‰Ÿ–]ฃ|๕†ƒ ซหn]qž๊>)ปpฝ,ฌวฟ‡๏฿๓หฑฟ2๘๕ีฒ๎7}ู„ŽUO_H๚.๗๏T๕๔E‘คY‚MP๙๗๑EสๅIสาฎž<บ๗ง{? P(๗ึ๛งฬc<ฉ1ํ๚N๎<จ›˜vwtฒƒฝ˜t๋ ›ภ 1ˆA bƒT2ุbLC'าm ภธkํ„|P1รž-<ป๊ฉTฝแ ย๊๒ม†[ืfฮวx๗qข‚i‡~ฒ‰f ถxRcศTF{™หcqฅ3cฆม-ไ‹Mj'ชฅ€A bƒฤ 1จLPFแ๙!šE1ำg˜•Ebฑ ี*‹ฤi]P ๐^;d=บ-…\)bs ๅซ7TX]>ุp๋Š๓ิชฑน…‘ดขŒ#2bXe>ั,A] ฬ๙K8~@!„j9-0~@จษ”?เ๙K!„B!eแ๘!„B!ค,ผRcŒl&†๕๎eO_‹->๕˜=‚๗OIอฐ>sๆX๒))1ˆA bƒฤ 2A…๗ทAHGเ—4ฦิลปงะ{uไ่Dำž.ฒ bƒฤ 1ˆA%ƒ Y\qAfa^nฺญำa~๖r_อศ]–฿a•YoeคำYIOพpB๖—์โ@r ŒLN{~cวHsmงืtd๛I‘งbn.๒€.+ฤ=uบ๖/b^_Y!๗y'2๓3ำโw๛;ิ>"ๆ:iืลคŒ‚œgqG็{˜ชุ.^?=}ซFd6ทธ\J57ตaๅ9UBบฉ-ƒ(ฯฉโี1ˆA bƒฤ 2A™๗ฎOฅ5๕˜ฟใ่ฃืซผ‚ๆ ฅวŸื”%`1#ๆ๎JWžี?ซ/ธฆ•/A ำYI.ำŸหฎ 9/ฝvสxูฐ‡๓_)่ฌ  )›-ฌ&:ˆฺูŸgตฏ6qิgC€.+ฬemZ~ฌเฝBิ๑แฏCS‡G2V\>ฆทด็†วฏฎวธ0mฮั4‰๓ด๐?>่ต9ตถผ2ืOS5ฌFT’U๛ุIeu™D5 wB ธผ2ฟMจ]๒]ฐFQI…มๆX"’ๆๆูฌA๙าช“W~7ผ˜ส๏!j6ิด}ฉ  ๎ษMX"5?qภ6ว๎„Lƒ;ƒŽ| ›ใSbZฃ%5๕AhŽAƒ ›u“oHžรผหš›‚cฅื“M#RNœ—zฏ^ืๅ5‡ป์VuิTA่Qฉzzz %€b7v๋‘ข๏ฦlธ+hผชฎ ๕˜:ื๖๎ซŽ*ffมไg<ษฎฌขฅฟถn@๓์‘t|LJ‰เ๙ฏ}ป|ฐค44—๗แ๙K*pY๒๙น4ฟQๆเ๔d๊•oจ )),ูbKคมy6kP!ฬSƒ›ธแลT~QณกฆํK ตุž„%R3O .ฆš›CS=˜๎$ฏ#A nโ&tk–T>ุb[S!5ปJ5Sjยๆจcฮ`ฐXๅ๙Qก>#ถ&7มฆ’Zืโบหะ\ฟฃ)^๛ฏw_dl๓วม๛ร#’7Eœญ\RฐฟU €d<เYิ™ว๏=ฅ‹mฟ]?v์โฯ[7๚น—Unไาีมศะอี‘ลb0˜Lทข๖็qโ๚2๗qU<P /ซ๐ Q‰๘ูE๗oˆKD*฿PRRXฒล–Hƒ๓lึ B:˜ง7qร‹ฉขfCM—jฑ=น Kคfž\L57‡ฆz0I^G‚ฤM่ึ-ฉ|ฐลถฆBjv•jฆิ„อกมษ~T{‰Uเฦy‚Ÿ?9[sU™RŒ๗๛็.้‰ๆb5wฟ‹oยำห๙ฑ ‡วv :พคเป ภธ"yZRฬฝgˆcC+aิปXึแ5‹N’€ld็ปnลGkฃK@|u๏–ษ๛โาV‰_]Xš@"‘ไf%๐Umฏ@!„j9๏_>แ0็7ิฐรwฟ0ถqฑ2ชfๅฒ{๔pwีƒึ฿[ฯ}ิ็^ 9ิัง=œย๏บAฑvl5#โป๋Vz›ฝ‰^ฒ%ฃํ๔”ฃ฿}อฯ๓๙ป—๎}%aŽ ๛ฝใŸ฿/ั.pหืุ้[*ชn;7๎aํฟบ$2™ึž๐๙qf;eุ๖จMTจb=i่ป*Mจ–ตๅU'ฟ์ฺีึึc{ฮMฏ2vแ๋˜y-งž๊‚‰ฉf-๒ธž&v ๘bTลฝฃ…*ต็/ฉ‚Lา#ƒTBMซา„๊mY[^uบณผบ“ ๚(ฉูฉถL‹-0+ิLtgoy฿็‡ุx/ฑiฦะ.–N๎?ถฏุx)WRWวš@r˜าq๖B†ฃ5YXTuowึ๑‹‚๏ฆ zgžŒ^;ภธ๔e“–_.ีfšM"wฅใ'๓ึL๔์ฤะฐ2oœ฿•XTSO-Z—);vญื–ย~`อาษ฿Rๆ%?จภj”W๐งข๋฿>~ฬำB๕ถ†้ืwึHฑluตตU'ฟ์! าเ‡ซญ๕KHƒ~?ำ, ?วษพ5ท6v๘TzkSA_`#ณ๑›ฌhqygโD W—ฏฅๆ<ตหฆ๔9}๙—#b๓zฮ๏'ธ๛Pะ,A]€ื?h˜i๗ŸNถท7ะN๕ถฦด›ำปีีึVฒ#„4Hƒฎถึ/กึลุ|ุฤvํ ภธkํ„๚ม:†ฝ&Z๖ํJiดzฃ))?Oํ2s๎?ึปL;๔“M4Sฐตภใ* ˜3อคย๊๊&โKอ๊m ลฬˆiFศVW[[u๒หŽา ~ธฺZฟ„4จŽ?Pฬ๔fDeกXlขonFTŠRuƒuศzํฺSH\›K4\]พ–š๓ิ.ชฑน…‘ดขŒ#2bXe>ั,A]€ฯŸึ0 —๗–xฑfชึHธwซซญญ:๙eGi?\mญ_Bญ‹„+*•ํŸ๏&ิึ‘ึpิ(Uฝฑ””Ÿงv‰yๅEฒ3y์"^3[ < !„B!ค,? „B!„”…ใ‡–cํ7๙ฦzi;ึยจKศณ็ส\u!M‘๋Xิ„Bจอย๑Cหa๔0ำณ#ญ๑’€f๏3ำwT/ภU‡านŽEMุ/!Mฑธ(โ๚ƒฬยผด[งร์ษะ็ซ’rVK๖—ใ0m'ฺู้wc.๚ฃหม'๎nvœhH นF&งฝNฟฑcคนถณk:ฒคศS17y@—•Gb๎ž:]๛1ฏฏฌ๛ผ ™๙™i๑ปj‘Gsด๋bRFAnฮณธฃ๓=LUlฏŸn9ู‡w|๖ปดฌByดwืI#——ฎ:„ฆศu,jย~ i}์ฮจzฃ^ๅ4gษar†ื”๐๒๛Cwพาvz Š๗:๚ต์•ำdWห%'m‡ลggu;7ฅหร๙ฏB|ึ_;+CCสf ตชJ่cƒ?3*-“‹ไYฑXม{…จ~‹7˜œึ-’ฑโ๒ฑน}b7ค8ฮ9ธญใ…iƒา$ฮำย _–ไต9U…†๑๘Cห•—ผฮ,ซฌ๏I€่5ย๒ขrู๚’TVผ-โ๒qี!„ิ$ืฑจ ปtค=‡y3 ๘š›wฌZt( ฝG ฤw5MŸnZu๗jžจ|ฦM/2ฐv‚ ๔จT===@ฑปใ์ูๅžญ๋€"ญวิน๖ท๗_kไ3 &?ใIveี๓๔ื4ฏมIวฅ”๐ๅฯ๘หbศ`;•šฦ๑าUๆ>แYวN/ฑท๎gญ™ิŠ0"„tƒ\ว‚N0g0Xฌr€จPŸ‘~[ภuลฬผ—้/š/ดQ๗๑น—ฺุYJ*ห!็ƒ๗‡G$oถ‹8[น4&2ค`ฝ†ปบ๑hๅ์‚‚<‹:๓X,ตboืป๘๓ึ~.†ภe•นtu02tsudฑX &Sภญษชื—น;Xชภ!.าUโฒิ๋Lฒซ 23ํึu^‘ธั:!ิ นŽ!CpฒษN"แn๓๑ฺงz&nAฟD๎"ฮoฎv“kํH๔>ดŠ่ฟs vแ๐Xร.Aย—|Wคํ‡ิฉฦ{f€864ฑFฝ‹e^ณ่$ศFvพ๋Vฬ๑ด6บฤW๗n™ผ/.m•๘ี…uก)$InV_ีึq€tUe๊žต็โฑ๐wํfƒ๚(ศu,้c+ฃjVn—]ฯ–ล๒Žฤ<^ะณ+ŽšNฏ๛ท %ฦ:๐SeNฉ์9ฯ๛ัaวV3"ถœ๔^w๑ู๖7ัหCถ$pดœฉ’๔ปฯjwi๗ฮf]Tฬe๛ภฝาหืrฦน:”Ÿ…๛„หW'๙G]“ศdBชฺ่ ฯ_BบสิcUฬบฐKm็๚ˆ`ว‚t ›ร07g8ฬŒNนwo‡/ูaสม3ืซถฤ๛฿๕PะLGNGOฬ9ษw๐Œq{ขC‹ืLX˜kถืญูรŠ็ฮ๑ฅj7Oๅ9๔ภดž]tา™˜Kก ฝื$เd9์ต:ื– โฝƒ ๏aณู43บพ์ษ๏—WWๆซv@บŠj๎>ด{ป{ญ๋Z&„nรŽ้š'‰wธณฦอุบ—ฯ๋ิ„ 7๏‰Yฬ†M›6์ซปlณ^ม๎ฮ>ีvžญb"ณน๏ลุืWบยใี€™, …"๋ยญkฒN๚œ”M2G…๑‚ฯ‡`0ศธปฯุทsำซŒG๘:f^หฉงบเAb๊ถY‹๏}๎BBณ6มi3ัทๆNXi๑ ๋ษŸJ๏„•ฆ๓๋‚้|eK6ฌcd4KP(??#เ๕HWุ ๖‰ปฑถ๓@!„Zcwณ!Ÿ›ฺ€qืฺ ๙ ๒% ึ10่๑9รณซž๚๓T˜งv™9๗๋ว‰ ฆ๚ษ&š)ุZเ๑คซศ4 ;S2ทผคฯ4@!๔๑hใ3j;SขชH"6ก2L‰ช"‰@ZH•-ูhฐ™Lทฅ*ล.กๆ<ๆฉ]Tcs #iEGdฤฐ4"*ส8|ขY‚บ@™ใxาURAYพnษC!„Z W\&ป\๘„|P๙’๋Hฅ"ฬSažฺ%ๆ•ษฎ–เฑk'š'ุZเ๙K!„B!eแ๘!„B!ค,? ]e4`ั๎_ฒัv!„BจŽฎ2์<ๆ‹ฯ{ทำv!„P3ฒธ(โ๚ƒฬยผด[งร์ษ>฿u้~vQ~~zๆ๕ฦGชลฦak–ฯiนฟ%ฃไ™œ๖:ฦŽ‘ๆฺฮฏ้ศ๖“+์ิ6 IDAT~‹Ž‰_ู่Pะภ}‰„ฬฬด๘ตศฃนNฺu1)ฃ 7็Yั๙ฆชถซ~๊5 N์ผ~ƒdi;„Bจูะว๎Œฺ8ษwh™ฌv~K๏žnเ0๛ภf฿gz8w๊๓E‚๋ท_ฮิvžญZiแŽมwส>}‘ฬฎ|ฦ‡บ›าeู๓ภ*€!ƒกKทŒU }L๐gฦฅe ฉ~‹7˜œูญw๐mฯอs๛€ใœƒ:^[8ุตณวิ(๚ืแหzซึ0Žฎชแ•พญฤ›ท"„๚x๕ๆอ€ใklฑjักT0๔1B๋7ดฯฝจ฿^pยฒค-ร์งGื๛ aค„šnฑU,d ฦฺป๓W.กGฅ๊้้”Šุgฯ.๗l]วyhงฮฑปฝ?ฎคแ ™“Ÿ๑$ปฒ๊y๚k šื`คใ‡RJ๘‚๒็ฟFe1dฐJMใ๘้*fะู‚ื7—ปi;„Bจู˜3,V9@~TจฯHฟญ‰ภ`2%ิ๎_š”‘—v๕—ฉฎญู๊b:L฿ณr‘2!@ฮ๏HlqถriLdHมz w[ำmใIvำƒ<:๓DHห*7r้๊`d่ๆ๊ศbฑLฆ€[Q{ป]โ๚2๗q TjวHW‰+.1ซRy „B-‚เd?J}”Q&!‘H†ƒ๛Švู้c๐๗ุ4km็๖Q0ด€ผขฟ_@~์ยแžžAgœ—-ก ›ขcฯœh„น๗ฬ)โุ_๎V6_ป…—–zrX๒บC)$Iฎ€Dภฉ๘จ>? ]U65heŒjb„Bจี2ถqqvฑ๖๎3*Šณ ๐พฐ๔"ฝ+*M@Š‚€–ˆ%๖ปFฑGฟDป11˜จ{oฑล. ADŠHU๛Rท๏~?อ" ภขนฯแวฮw{‡ใมน;M$‰NIชf5<8r9รฮRฺฅ} ๆรTŠC**šษบ#ถtพท๕œ๊๗7Sโฏ๛ป}>lกZ,˜คs๛๔ํโ6ƒภI94ำฝŸa_หแ๋‚ E"QหW]ˆnฐ@=•๐ํืฏ์ข'ํ:Bก.Sรdจจ(่อบณหƒXS]-x{ˆว็๓ฅVเD|?9Š%^P๛…นฅ|—ฦ ˜ohพใๆา… <>›๋ฤt8ชjLz!๊ฏห7พ1“qต{’ฤ ฤอkjj่ ŠT๑ม{ฦลปฉ;€PกjYปนชD3ค]B!ิe’"ือ=c๛ฆฐF‡้ึภ รc“"žm›ตะ2โd–์เž์I’v_-ESตบiอK5ก๋}๎46 ภ”Hไs8.ˆ๏\ีำฃeŸ?๙œ๘ฃชฯๆKฦมโ@bPvldโŽ9฿ฺFJใL๚ฦง6ๆ่๛'-> ๛ิSUฃv„๘• Bก/๓๚ฺ™ฦ‚M3F๛๙‘™yan\sฆŽ.๓7ใxœฟš (๎โยUWชฅ]็็d%oๆฦbvc#dŸศฝp5cvลๅU[ธRซฎ›ๅZ๚ฝq@`๔:-rMFุo‹Dmoิ^ฟ„z*†ณ฿พ=ก%ํ:Bก.Tพgถ๛@c-}._p+ภ~yูฯวXจDป…ผปิผ—j`.+9จโ๕vm๛ƒoษ*๛ฺฒ dดŒฺ่ซ“AFณ๙Ckู%n1ู?–เ^ฺŒนš]๐๒๔†}]W฿ฎฐh8Lธtฌ-ิํงˆ?tQ๐#T้฿็$[bฟธผbคฃ‰ถพน็?ใ:z๏8๖จงข›xN<สRQฺu „BŸ9suท๑*ฺ4ษA†™ฺ›ตํพE“ฑฏioFชขšพžฒ(Šชโญe—ธ๙วd—#ว‘n67t่ขเ็‚@งฟํw–/™ด/๐’ซA่-ขœ†ฎ2กถดด–ื๖`„B่31nŒ[Ppx—ฆ +ะ”D ล\–PB+GSyฝถมทˆ$%m กŽSS'"RhtŠˆหโ ษT:ธ,._$9ปฤอ?&ป4P*jฒยฺJ&WVY]VT[ษluIฐ'๘๏๓ฝ๏@=•ฐก,ฟAฺE „BŸ~งโ_—คผ ถXเ[BณPะ‘วiหวใ6๑ตนD-6˜์าภkฌ.฿-ัXำกk‚Ÿ ผ~ !„B!ิ^ุ? „B!„ฺ ๛ิSัฌพ]ด๖;;5iืB!„ย๕T4ฃ‘รวŒ3‘—v!„PRํฑะุWล๙yiฺ์ญKะ^ส,gถ๘9๎+ํ*?s#๕y็ํ$;ด๑›%G O9—–“`ืpiW๗๑ˆบN]ธถtเ‡‚4๓Egร_ผJ 3Vฏ๙y๔>n>ษ,สหM 9บุถฃ[ุ? žช!l‘฿Œ)w ฅ]B!ิeGzง ฆฬƒ^สR๒^qxฯด^PvvŠ™ต™๘ว~ลํชคฤdiื๙yฃลX๙F๊Jป่•~Lํตƒ”มpฬ\ำ ‰VฅN™ํNQV๎OŠํล‘3ฟbTT~8H๑๖๓—ป8ฬzfฤภ- m@Aเ“๛K๛๔ต|^๑ปCซฌ;–๛ิS Y•UeM๘i„B_.+W7e(8ฝaษ–]๋พ=˜2nžƒษ‚ฦสbฑล๑ ํBvอ–vŸ5š‚™eฃฟš9ยบ๘œ H}T"‘ˆDกH$Š€ฌ3jืีซซ~์;คƒn1yNฤŸ!ๅ*จฉ6e&eื7คฆ็จฉฉะํmŸœ>˜PฤฎN=y์žฺgฅฦ๕T ฃฏžป๗p‚กด๋@!„บŒŠฒ2@UU5@ม๙น๎รฝทGพ]Ks๗[D;ฑ๗n“ดส๛2(Qไy๙fฟฦ8{lฝpฌ, ๗๏ภงCลmั9vต~ๅๅ3ณ‹6Ž๕bKปา ่L›9(๕ฅ$^มบชjYใzฒ2ฆ}๔ซชช”UUูuต\๑zQ่*๓ัEJŽ๏@=ฏ์i|ด|1อD!๔฿ bf?Kl57็œcšด ๚R€ ฃุ›—ผy่K๚@ƒ๏M\'?,ธถt่5™~ำZQดm๚”iฟคฎcTfMไ]›U>myw๗nz_Hฺ:^F๐sB‹ฉ๘์kแ๙ิSฑžlฑ~mD™ด๋@!„บCำุศXKิผHv๕–y๋NTk๚ˆ@$`><ะภT>.Žฬ–๏ำศบ#ถtพท๕œ๊๗7Sโฏ๛ป)IปะvฃZ,˜คs๛๔ํโ6ƒภI94ำฝŸa_หแ๋‚ E"QหW]ˆn๐B!„”ิ0™**ส9 7๋Bยf‹เEฺณ‚\\˜แ‡๑ึ‡Oฦไ5ด<^‘Pสฃฟ0๛ๅJ฿j็‡ญ}4฿1~qฺŸรฏ๒Z›คGัเจชกน๕ยิๆeณ(ใหSP$ื^ส๛๗ๆ555tE*๛3V$น8ุK˜ฐ@!„’’คศวusFฯุพท)ฌัaบ5pยฦ4ยุ๊;๔J‡O^๚tœบิc๗YrฉY๔ฺฮ๚uมฉPร^๏sงฑQฆD"Ÿรแpน@|็ชž-๛๘ษ็ฤU}6_2๖8ƒฐc#wฬ๙ึ6โPฯ`า7>ต1G฿?i๑aุ? „BI ๓๚ฺ™ฦ‚M3F๛๙‘™yan\sฆ๙HŽbkm‘™–ส•n}_๖๕ู:;๚๏YE–ึ=Z“ษ€ฦFศ >‘{แjฦ์Šหซถg~ูน‡–~oฝN‹\“๖ข€Qต@ ำ฿>ซj๙’I๛/uv‰!„Bจูธ1nAมแ]šBอpข‡เัฆ‚gรษ^‚G› R›>&˜ฺิฦœ2ZFfš‚ไ5#3-A~r~ฟำฒท J—†รดvMท_+ฐœฒศž}๛๘ตv—{‰>฿๋๐i„Bก/ ร\อuผฒ Uล>.ุๆœTE5}=e9"PUล:1{ห t)9Žtณ1 €ผกƒ๘C?x!„Bจ๛tร๙ฒUY๊‹น<9ชŠิsูย ฒ…mฬIคะ่—ล’ฉt pY\พจำฒท J…กข&+ฌญdre•ีeEต•ฬ&Q—{‚๖œภ๛B!„พ(:nEผ๙๐qมถๆ๒8Mโฝy&‡F~bPบxี%โป%kš?tM๐sื/!„B!„ฺ ๛„B!„P{a€B!„j/์B!„คFcแตฒร#:c&็=ู!ห๕?8Ds=f๎ก‘T๑’โดsท็ซฟ^ูoฃฬY฿gว฿‘/‹๒๒R๏œeึฅ@"(ู๙‡ๆ๐0Z๏qทžf—ค‡_dM Œu๗ูหโฒย‚Œˆ+\”บท$‚ชำ†‹/ ^ฅ†^4@ฎ๕:?นI‰$ะ^ส,gถ๘9๎ ๏ฐ๔|TJaINfฬฅอ>ฺQ๖!„B Šร”3ฝ‰jรยโบบษŠWชช๗ ๔‰ด็๎1_๎าง๏ภY๗v:Gง‹ส1šqเzฬ“mzล…mิ›`‹ึ•YถFฝmพ ๏๓ใwใT ฿์พ[]Œ4๕๛๚œฅญY5Vน;K’๕๓a๏๔๏ฬ๚๎ๅ-?นึšุZŸHb"IสฮN1ณ6ุฏธ]•”˜ † wฏกœkชg๊ด2m๘‘๏ฝHŸ^๖!„B= ษ๐ซ฿nลๆ”ไdฦœ_๏า|ชแๅใYfIษหุ ๏_Ÿ5 ๊$ซ8/;๎WŸึฟ›ฺ0/“ฐอiฎึโ@YX่K็กฮ$†๋ะCรy@์>่้้ภ„๒&ve๑m›ๆฝ~5ส˜=‰ู้t๊ควwVฅ;๏๏;iS4ณt›˜๓ง^0ูœส'[]uง]จ€บช*ซฎ#ฒ๋๊9uีUœn, †|5๚ล‰฿#J๋k_]๓’pไh๓ึ๊D’I$hฌ,+Qฟะ.d๗ัl dน็โซ&>ฏ":,Vhbา๋ำKย!„BจgQœธsีใ%๖Fๆร~*™zlฝ€่ด~ฏ{์’ม&ฆ^ฟีN}นญxไค]ุ>Yๆ`ุf๚ฑtg%9yYG‡Hnิt฿œsgำFgลฌ)JซนwยOัผึทl7์B!„z …ย็7ŸLเ๓x ไl๙Ob\\lิตถoF’ษoFถมาหรเซ๙e…O7ฐ๕๒PQlX˜Ž๋P๕>C‡ฒBC๓D"๑{๋ฮฯิะะwผJภo>ฬท/^}”ห๊คl7‘H$xt๚HR5ซฑเม‘หv๖–ržSGฝ8ณ?2#//ๅN`PใŒ)ƒปฑ$›C&“๋ƒfฺ๔”Bกp9œV๊์ŠDBv๕–y๋NA‹Pํ้ษJส:ๆฤL8{x^ฟ„B!๔ลแ๑๙$R๓}ฎ$2™ฯใhOบดaซ›ฃฝำˆ ฏG๒๙‚7#‰คึxy5nจซกกซก9๕ข™ว0ขB1s›่ใฎ*ฦบฆบšฆ ุ]>]WWนจจคyESŸษ\ :้๒ฅP่ี์ฉ๎FฏŸTS]-ฝYอ็๓จTšˆฯŠ#€ๆ๓YRui1ISS^ผ ฉฅU\TิJŸHb"‰%5เโย ฯn^Rด;uฐ&ˆxฬŒป*==mแำa€B!ิฃdงฆ๊xŽทUฅห่ ส™—šZ @&S๒rD]ำ~ฦPFM#cE ๒sฒ๕G[ih๔ณq…—|๋Sjxxชว>อa|L’ณงซ๘โ|ฮรุ!kพ5 {/ษŽ~๘tะœๅvšฒฒฝ—ฮwŠ พื|3ฑ้ยCLhใ>ํOึwqเ™?ธบk|๓ฃกุ1ฯœf-ดT‘‘ีถ`ขั“่$€๊๔ิสAพใ๕่D’‚๙„Qiฉ้X’่๑ํ;ๆskศ)๛.™Hพu3ต•:?‘ฤDKำฑw่•˜z‘o:9`๛J$ 2Œ}†๖หษษไ’ฐ@!„’.ฺคSฏŸูp•10/o]†๛‘„œ๔G ‚!ศฟธใธ๒ๆคฌิ›ซHN_]83๔โ<]จธฐuฟpตฤˆ=ญm5…‚‡‡u\์ณๆฅ๚˜˜ฏAโ๛˜aaชŒวกQอ_ๅCัฑ%ซ’ฯH‹>0$nูŠณeอ+ช2“๒™ี้I9๐ #๐๗Šษ,O้ ;๕,“Yžฟo˜8^๙"!ปช291๛uข‚ฃห‹|วeฅ>ี/tแ†+ี๛โ3Škoge%ๅ[ฒ้ปใ๙YRใ๕๕Kู๚๘Eยอี๔?g–(lญฮO$1‘ฤ’(ถึ™iฉ7[฿ุถ1ห็ณโฒ์ไเ9์ซ_|zI@hyฒg๙’I๛/uยฌ!„BH’qc‚‚รฅ]B’I๗๙^€็B!„Bํ…B!„Bจฝฐ@!„Bต๖!„Bก๖ย!„B!ิ^ุ? „B!„ฺ‹ฝ้z ›?ยJๆ๕{๙8™WGี๛z{XจะDฌšุ่”๊w฿ึง้ฑะŽy๑f|]+ณสh ๖dฉ#+dว=ˆJ,็ต–H"Iู Š}}œ ีๅศ"N}q๒ำ;1%์Nุ}„B!„>o?3๚์๕˜š– W;Fึใ—™Uณ1_;˜็}ุ ษฝ]Œช"ฮซข:L1 ไt\™Hb"‰$fWฒlX}J›จุ฿wฆUŸ็%ษุ@ „BกผŽ๖ฝ†อwฌฟ|#ถZœ่5lพcใTc;็๑ƒ;iuข6gzKŽA+IOซb ส ๊๛+)4AAจ็ภพฒ„ฦF>…Ÿะ๊ๆšฝM˜IวJนะ˜‘š>ศD-ฎฌขีั๔Nำ†้qS9U&l5;ลศrx น\‡อt`B!„๚,m้ฌ๓Jfˆม— Q0ๅk+ƒ๔วนญ6Š“ง‰xฌบ‚ฤ˜ฐค*TDžะผ’ฎฌฦ`—ฒ€ฺ฿อYฃ8๔ิ๕*กข้จษฝ[อL—•‡ฆ~/วQฆ Qฑ ฒ € ‰‰dUิ้t่ฅH†2.Hฮ๐์๖c—‘_๋ ^ๅใ๋แฏx๐;B!„โry Yzc^ุ€z†,รๆถ9ฌณ๚‡ฺิงฏชธ•eฅ"meไ6HVu๑๏8"จส}ผF ฒฬฝ•P$]c‹F} •“'3@A]ฝ)็qKPอฌภืd2Y(’ฝt5จtA€D& T?\งย-ษo๑ป๙wvบฉ›ฃj๖?2Ij<ฝฌส.ฦ—เ)„B}ฒผ‚RK‹™๙ี5ญู‰ศหหด๎—_Pฺๆศฮ๊D"ั›DbซOuฐšํบ๔—f๊ชuTท‘ฃ ๋S_Ž*,kงIDกPุŽฬŸ@$rsnส Z‘Ak‰€รฬzมlฑฝค์T]sf๒าj@]j†ฏ™v|Ik๗_#„Bต[๚‹ 9Xะhiื‚ะ[\.ฏ ฐ<%-ปอ‘๎Zดข„๋ฃˆ$ขPฺุW๕๒&๎2ฯ‚Sส›ง"um,› Kแผ“G(pขืXM D€ ฒrŒฆ๚†V‰ัTyล๙uVณ‰$‘H๘ถ#"‘Hญ€B!ิn0%5;%ตํฃ4„zฆŽพกกถN^฿X…มP๎;d€๕Mœฆฌ*K&†:ผช๒ึžžฤะt{›้ษ’I$†fSตสา :.hjเผ7ดY+งoขสU๊3ุา*q:ฑ’ฌl+[ •ชิผ1/ซฒ•D bๅ๊;ๅk๗ืตKฬฮfVฒz™šส‘ ššฑ‰ZMeu~G!„B}ฉ:zก)52ลฤ็kfRXZ–™ล๋8UศจE>^mษณ;QEญmอห ื๑๔ณ˜AโืWf<ˆLn#(&ใLŒzy๛ิํWฌด่”sญ™๑w’ณ-ด^?3Iห‡บ"„B!„พ๏๕ฝ~ !„B!๔฿ี)ฯ_*p๔FgฬƒB!„๊ั๐B!„Bจฝ>ฒXพdR็ึัE‰>—:Bจ{|ต`6;Bตำไธ๎ฃwฯ? „B!„ฺ ๛„B!„P{u^@49ฃปด@Eฟำ&D!ิลzนฌ9–๐"'+-๎?'•ืqE็QEลลQ?˜psš‘๏Ž+I/œY๏ฎIฝ%w‹[zพลกซw!„z ก๋.D=ฯ/อหI =ฝฦY่&ใv฿Œส,ฬJ>ฟัS‹ิม`ิIล๊Žฆกฐs&C!ิศ.๋ฌ๑าศ9ฟ—๋%ฃ6^ใD€^CWํ บ๏?ลoksBฟวฬ2*ผ๐Gh“Šใ{งh4ฏ>;ฑช™Pv๏B๕ืGืะศ9ฝ้็ฟ‹ ว๘0„„~kฮœk\x๖็=๗ํืž?C:์9kบŽ‰ะIำuV ฌ>V๕ฯEม;15งe'$ไ”ไ็ฆ=๔%l“™ๅฟŽ๙หŒ’ฌ็—™Q€>๙“Y~kaฏฮฉ๊]–Šำj๕<หษิ๑žBทบฅ;๗–ผจ9/?๙ฯณผ’W๑Aป'๖กพญำiCPzqN๚ญ5้W'Bumc๕๚ด‹[Žฺ|๊ €Šน™ศ๖wXwxํ๏ษผ๗‡๗๙ๆฏ็ูฏž์ฃ&^๎?fl_Bยก5;๘๎วs%ด!cG4ฏUฝŠ‰y๒่ตห?ซ์ฮ]B!้ั6๎UŸ›rv๗ฦƒ?‹Pฑฐะ๓ฑ๚b๗ฏฺผส ็Š้._Vkะrcณxโ…W2าŽMq]x3๋ๅอล& ๎บ๚BdraIVzฬ๕ภ5๎:>ข'๕ฃ—๏F๚ว๖ฟืyผ3›อQP`|ฬฌ‚ย+œ&Qหs๙ว้ๆœฒใRก๑ไ€C+_ŸW3ฯง๒ฺ•gฏ~ž{f† ;˜ฤโL6หห•้Cdดd้^ฯ๛๛สGฌŸ:ov๙‡–๖y]็๘๏ๆ’Lๆk9ฏYๆC้ึ:BจไŸšๅไไน-(Zรœ๛kk 7pœำ์c)์&š;Qงห๊ป2ttt@TTk๕[ฤํชEEบบบโ5$ฯํQQั๑iฏ‚Vูษvใ!„ๅœlใ0ไงว@ี๖r52™๕ ซซ ขขZซ}ฑ๗ึช่้้u ฒ.ƒ๔*9ฺ_mZฌ]Rซ<ฤs,มeใษ #”ใทอ๛๖ว๑๒ึๅป๒" F‹ำ2๒ฮ๛ใา^ไบ:ฤ=K/-ญ๊เฬD:L‰A ฒDBกฑญิœ๛S`8!ชN8ั0—Dญพฑำ๏—วฒC–: ืัQ†าOูฃ]จ/ำT่฿-o=ˆ[;Eจพz๙โ? ํ๘M^^ƒํฟงิบp?2ำ8zฉซ+A^7ึ‰Bƒฎ๏9o๕Š๙ใjซcvhh}จ0๊ย๛J6ฌะซษโJก@HSTS‘>€FฅBๅฝญ ”€$o1eฝŸฺ๕“ฮMะ 'ื|†ฯๅ >m_1๖yT0B่s”หืีH@6_tํปิฒธฟ๑๐ษ›้u" ฃ(9'ฌล2—ว"‰<ฟu่๕อu.—ฌ์ศ›อw|%ท=ไใd?‹gยไ‘ห7ฟ0%ŒX้็F;=กo|5€ขหฌี๓อด'(|žฤ„๒Šr‘+~ๅฬณeาU๕ด&+!ฎ&ฺyyX6ฑ์ๆ0A๖’฿ไ#•n!ิ้TTTJTํg-้-4$‰ค{-ั›hา— h=qษ‡ด›'ย ˆCfญๅJณsGŸล@๚อ›Y~‹ํ@ŒT=M‡๛d฿rถLj>wะผอ+ฑชฃผP{;๖•Tw!„บ‹ชŠ*@ฑชรๅฏจ&ˆบq-sๅ๒eฤวJพำu9ั7หกฌมน’)~}*dJล…๋‘/ซ/จ+/๗Mk]จห๚vศฦeถอžำOไ๚ผ‡๛ท๎ ˆฏ_"จฺฯ4Jฉ)๋ฦkเา/็ p7ุฝt7cDW•ิJ฿OูD6๋ฉฑ4Viาอ€ฟcY`&idฑT๋DกNGะ๒Xๆ๏ั(=&ReF_๑ณ-”๚;ื]xq"ผ@˜$ชาร†๑ด๙๚$AJภJฟฌœฑฮžWปow็Jเ๘๊๚l[Kำ๎{;=าโB`"]ชืƒ๛w๏i‘ๅซ“วE![๚<๒#1ะํญZ ะ•*|] _๎7ภห๒“Yฅ99‚ก–={Z’ย|อ ๗!„Bh‘|ึฆ๖แP2ฉˆฆฃ”X‘—•_Qช—F"‘H”H"๐QbCQ>goฉ฿ณทอ๊ฉ‚•็๒=iK"“EF๛ผภg๏้Rยd t8ƒ @`ฬวH„‘e๋ยมฦ=c,ฃfcž(“อB@*“G<>€q•ๅษ…เ‹@pุ๊๐ำ๔˜U‰E8ํŠาุuื]7๓วGy$U=I–L๖!ดBd๙ื็ฯ|ศฟททกm8#7)Vf็่u:,๊่r„D$ษq!’+•bI’ ใNไxƒ(‚ DB BโY0ฌ(–$ษ‚‚‚์์lŠZ8บนs็ŒŸdฦส’™Hฤญ['๊k๐มq“ณณL`tt:+w`ƒ šใฌซซ[x ๔๓`Aˆ •›t,&ไ›๊าฬ~.ุสา๛‰2เ` Ÿ”ฬ‰W2TฆŒ(ฃ๛‰ธJย˜ ฃฝษ=3"aฃtŒBUั๚ruุiwt๖{Q€eY‚ wวn7e X–K$‘_ุa้—ฏฯณ!๏ˆญฏฯไฯ;‚$ ท™f‡เ๑-ขizddคทท—eฌY˜ญšอf‰Dา/0๑xP{กถ}CณR8Žƒฉ •) ฃฬฌ‘มN†น3r0.†&ิฯƒqฒท6 ฦณDcู๚‰Vƒ”>ำ~:.Y5sl™2ขŒ๎'ีB(ออ c8:ŠถฮFjŒ†Hžถแ™ู้HD""‘( '’(ๆoŠ๑;,- AIUฦา๒’๏~๏w์“!ธด้hŽฬ มs$‹หสสฬfs__฿ฮฬกำ้๚๚๚ aใ ฤš์,!Iค9ๅ›*ฒ'fD&"ชตJฦ๏@8–จ4rกP–]ฏYแ% DJต„ eนฅk๒1— งถŸอ็‘GI๓(*Q™2"์'B(ํPลE"s#^๏่จ,'O)$Zc612H(‘—4ทค(G)’=ั`ฌY[Ž‡BกP„ๆ8: …B&ๆ/ฏp8ีีฅื๋g tๆ"‘( &Tilดณื"/)T#"่ gภโœœ6ฆT๋ท– ุะุPงe 2oำ”ฏ’tX†Fr๒’ิ๘๛ูซ(][mฆ&์ฑub\—ฺ~"„BลƒR_Yw เsw์์aฝ]ฒาโี".ไฑu๚โOไ๕๙ SaeTHD#}ำมฒ‡รs–ผ.฿]ภ…=-๎žƒ๚เh›๛„f| ฅ~`๒‡๎ๅ๊ะh๗ฎQ€พ†C๛๗N๖ำeู๏ฒฬส:ปงijณปyE๛‰B!ดh‘ก};‡xาฃcึถF๋โcQ>GO›#žอŒฏ’฿S€B!„2ฯ2ฮล๒Ir ŽB!„M8‹B!„2!‘x€n]]>xกล๙ิhŒ3็‘C|ห•VถกK/ฝ๔๗ฟฤฟ+฿zๆ๔s…[Ÿc‰ญgึ’กญ๓Jร.!„gNคŠsฑ!„B(๓`‹B!„2Fฑ!„B(๓`‹B!„2Fฑ!„B(๓`‹B!„2ฯ ฟ๕!4้าK/]dษ๗[\ผีJธqทพศ๚“*ษญ'uฯ'ZIVถŸ‹–ฺึyฅa—B๓ภ(ก”Y5๒ขธ~9ณ~hˆฟ๕ฅด’DIl=‰{~๕ฤoๅ๛น8ฉmWv !4ŒbJฅล\)ŸiKฮ,l‚ญ'กญ$IZ๋Iฺ๓ IแฒR:ฏ4์Bhล"”b‰^/iKึ,lขญ'ซลคHJ๋Iู๓‹’3dคถu^iุ%„ะ<๐๎.„B!”y0ŠE!„B™ฃX„B!”y0ŠE!„B™ฃX„B!”y๐%‡ฆใฬ๙š^๐๖'้๕“.นกณœฮX๙}>฿๔ฟK0ฑ๕9ญg๔๒Z}XŽa๒v> ป„Za8‹B!„2Fฑ!„B(๓เŠ„B%H’[ตมู้้ขDฦ๕ี…Šฟww์์แ-™Uดต*—โธ‰Ÿg๋n‹—ทธทNพโค4ปฐุค•‹:่๊้ฑ๛˜ไuี(Œe%yJ ษ†}ฮ๎ัHŒŒ;™!ึ”d+ฤ๐ X,ร”ล5Eแ}Mถภฌํไร(!„B ๔["ฌwjอqtธฝMLl TลUนภ<…ƒึฆฦมเŒโ1๋<จ8ˆ ฅE’‘ถฆถ'ั—ญ+ฯoฐ๚—<ฦีF’[l"๛๖ ‡Š‚ต•f๏๎n+๓ม;™—ศPZ"๓ด7ต@fฌX[œใูo/ŒbB!ฟฌขญUนB๔๏๑G€cข‘ษูO™ษจ๐X;š{ใ/wd–R1>ผ฿ๅวhAžR pโC[ๅ‚๋ธ+ศrภŽ{|œY"XbฤI*UYพแV_”๐9ฌVB@ฤส*ศฉฌ-QOฤ:vu{–ึ8`‹BกDŒ๗๎ูู YE[‹y~Iชน„ฃe”ฏi๚ฺ<Žc่ wจืโ๐ศฬ[|nโAล)Jศาฬิดขงg‡ทCThฤj‚R(ๅŒฯ's์c4E น้=O{ํฑ+d†vPฺฒ…ฌ{|Qc˜~2*Aฅ…sฮ9'ี]@i-Cฯ9~ๅ•WRี“iiุฅ4!ะไ่Bฮฦ‰ฏe๙ื็Kfึะ6์hn"€H๕%ลฯพก0_q:ฏ87kร6ถ‰Q6เ์n๋นœ`พc4ิŠšญล* ˆฐm_ฃd›๋ &๓๚gj‹‹ณ<]Mžค,\ฦ(กUฏฆh~™x†ฬ์sšโiุฅE Iฒ   ;;›ขv๎G•„Rฃ Ž๖O`‹ะj“นืTด22๎ ™๎p๚„เiุฅE0›อ‰คนน9^` i \ฅdฦ์SหW9::่•โ์าb‘ฝอ6q๓Dฬโผ‰ผลiš&)1SiJk๓3o2Š/_…f8Lงฅฦptpิ-V+ภ=:๙+ญNฮxc!`c4Mำฤ๔ž'E"a8‰[ ณKŠd๎ฮ./ฯ<์ฬc$‹หสสฬfs__฿ฤ(กU(ฃฏฌhdึ2ัด พำฐK‹ ำ้Z[[ a สR}C๓? ส ”zฝส๔าyŽNๆsM็็->'‘ท8๋๓๚Š F…ืเ$zƒ†wฌเ}๒C–]l”[|4)ัจd!฿ิGinY…Yุีๆdac4;๎๑๒ใCNn4(ฝฮž˜ฏส้KŠคฎ๖N๏‚ >ยแpWWื† 0ŠE!„‘H .,ฅƒL?ฃ`s]๘๛š'M น,ฬ๗๕>;2ะซ..ูX#$™ˆoฤา=<p๒Ÿ›ศ_”ล5๋ Žเ˜๐๘poWฟ' สโšข๐พ๏ฺF ืW*f$ธ;vv๔•J2โฒด๖z[ถ”Fค๙7š%ฎ๖]ฃ@eๅ•ๅชค&<๎์ํถŽEHYnYYพJฬ}w€ฌKFฑ!„J‹$#mMmNข/[Wž7`๕@ ฟฑษRจ.ช*ห๗์๎๕ฦ]ฅHcสW gฆD<N0dnโเhฬ‡๚ว#:^๏ž|ซ@U\•๋€D›+uทึ๛Œี9๊>‹’ข€ฆ|ฟUZๆ‘้W#d™สœตฅม&dนๅๅEฺฆฮuพYเlฎฆ๒ซส wฟ/๖Y/ŒbBกC™ฅTŒ๏๗E9€€ร1ZงรŒx‚zF}dฎ”‚๘ฃXJฎ3ค3S‚Q๛(dpโฃXŽ‰F&งe&ฃยcํ 8‚ € ‘ถฐ<ตถ๔/šึ๔AชL&ฉซื.+“€P&A|ฮ‘ˆQ)‡/„๔‡† „…*!@ฌณ.W"ใบX„B่GQB–fฆ^๔ู๊้ำ2”@0Cชน„ร6ส„CใชŠอ"‡›ฮซ\“้kอจ@šW ๓๕ŒOฟ%˜GXนZM!VซคB!ภDiR"“คT*ŽาQ€$œu8‹Pjœz๊ฉ‹,๙้ง‹kbžGก4ด๘3d๙อืทธฯฯ…ซJV=)๊Rฆ!fภฑsใ(Rจึ(ุเpฦ.L'MŽ.ไl @ุ์&ฅ9ฅe๙k{›'ฒ@แ4#ิๆrƒอnrง’8ฯ@ฯ๘š๒ญ8:2๎๔†A0™e‰9๕YวฃX„BtYZ\–YižMซRฯ'ŒbZm…ฉฆYcLƒนุ ‡ยž_๎4์Rกišคฤd\ก)ญอ๓7๎ทG"  ‰D‘Hxjๆ่K‹ณi{G฿่BwžวŸsšX_R’อ$T$ลฤูฅล"{›mโ% ด%9มž–^:wCXgฃฯXmPŒน2cVZชV‰ฤโ๕‡'Vึ)›CณcpŽ‹5˜g]ํc‹ะ*ดบ'œๆŒ.Mๆb'ฌ๎=ฟ4iุฅ๔ย๚ผพ"ƒQแต8‰ กวftดฤ˜งต๙*c61า‘เขXRขPฉข#qดฮiqVขER,ส ”zฝส๔าyŽNๆs๙ฆ{[F†)วฒ 4"รฮ‰Ma๎บ-๒ก]ฃโ1QNฎ๋ ฒruฏ-ึc๘ฯบ`‹BกฝปWR\ถษ$:86ุ9่ฦ%+-X-โB[็`ขู X›พ€˜Sq‹สy ศ@ำƒ‰YI๊’ฺสฌฉำ3๖ฅed W]\ฒฑFH2฿ˆฅ{8ฬฤTrhฤZณvkNิe้Oื1ล)์่๎•–Tl6S\ุ็์ฒธbฎเ=๋€Q,B!„€ บ,-.หœิ่˜ตญับุ:ลZณIC;{m!•ูฌaœฝ6/bm_b9งMq็LZb<–/wฮ›๎?ฬŸŸ :ฺ๗:ฺŸi7ฬiQ{หฎฉm6่ฒ์?่\โรึล-ณI†BกŒ!k๔zต”Jฆุศ๔ฤิ:D†?œ‹E!„ะฒฺZ†9švจตมษัtฦ'ฆึ!2ฬ๘a‹Bกeม1‘๐ฤืำำž˜Z‡ศ0ใ‡Q,Bษ๑€ฯ555ปw๏ž๘wๅ๛เ๓๙ฆ]&‰3 ปดโf๎:„สhธ.!„BeŒbB!”1DSqฑ1 ใ„+ Bญ*คv๋๙ื_ujY๎๋๘๙Ÿ?๔^”?#‘]sมต—ŸฒตXK๙mM;~๓ภ“_บ—ZgF#ฅู…ล&ญ\DะAฯPO7นH’R˜+ืƒปบGSร ”Bg0Dึกq6ี]I)ั–˜u A=6KทฯJ๔•J2โฒด๖z2๊ึช™ค๙7š%ฎ๖‰“„g˜@สrหส๒Ub.่๎๋ดธร๓œu๑มฯ2!„V ฒ๐ปJ*Žาัษœ|g]0ŠEhYิิิคบ +! ‡™†]โ•)LcƒEนน ฉ:๑h™็_๏&.ศ๚฿ฒิ@4‰tzธ1ึบฺ>W๙ฅ๋.yแฝ3๋๋2—ฮ‘qื™ูfลๆ\‚มฤJb‚^‡ gโ\,@*\ห†nA–iอš"ฝงu8์๎nv“าœาฒˆตฝอรa*m ๕…น`ณ›†้4พaF๓ ZณหชชM\ะืๅ›ฬ9ร"ฮ:ŒbJพ”<ฒtๅฅแ0ำฐKผ2ฅŸ้อc๐มfcฎ๎่ฏ)uผ๕~ Nng๛๗~ํmจบ๚4kภdv<;[4><:ฐ]/เ›,0F|_y๐ฝญฅCCCผ9็ซsUษ˜จ0์๊isฅบ‹ฤ76l๗ำะcvwp“BรBฌ),7Q๋ฐา\U]v๖tXว2dž™TšอRgG{@x •w˜lภัdŸU~ฉgFฑ%ู!2ว–†รLร.๑ส”~ฆฟมA€5็œx˜ศ๚็๗›Y‚ †ศฐAึw›F๋~๐ว฿ž_$~ํ‡฿~ดศช:ํป'ฌงฟ|=๔ึ๒RWkซ‹7gฬ:WšฆIJ@Lฦšาฺ<ใ~{ ๆล๚’’lฦั7ส€D_ZœMOlO›N hศษ+œษGฯyฝ+วq@iK*r‚=-ฝt๎†ฑฮFŸฑฺ s-1พใKษ'UซDb๑๚รŒ“?+๋อกƒ‡ษoษgFฑ%ำ!2ว–†รLร.๑ส”~f„ก+ วœz†™๊ร]๎-8็คห.›u์๗ชวK IDAT|;๏ซฬ‡]$ญvrg$ง๖œณŽcช่@qยIZฦ๒วฟท๒็ŒY็*ร๚ผพ"ƒQแต8‰ กวฉ๙j[ ฮRฉข#ท๋Kำำฆร ๅไฮไcววE9นrฏ#(ศสีIผ6?ะloห(รp ‚ใX–c“ฒ๐šw/%Ÿฟฟagฤฆ0w๙ะฎ๎Q๑มรไทไณN@QY“ษ40ฐ*ฟ(A!ดฺp‚ฒ“พนU'„ฆr‹ภูึ-จ9๊๘ฏlึ|ฝพี?qMไิ๋Ž;ผ€ํ๋๏Ÿb0L—รฐvฦmGnิ๛฿|่พ?์๕ฒผ9cึ™๙f_๔ixDa,*.2็jลA[wH„P—ิn^S`T‹ yถษd2Š|ถัะ|•.Yิ;<8่šธฟiๆ๖มฬน`+Ž ŒGฒ๒JŠ‹L9YHOฯP€™žฉdhP™K‹t๗ภภhhฉใKหJ ะEพมั0๙๑Ÿuxƒา9‰„Drเั"uuu;w๎Lๆ˜B!”–Vเข/ึ˜4ดณืR™อฦูk๓2+—x€@™WคŒZญ#‘คี™ )ุuฉร{~ฮIฬฌG’!„B(cไฝ^-%€’i'6V2๑Bชึ๋ต2*™uฆB v]zรนX„B่Pด}B QŽฒSฬ &ฮ Š)‚ŽD.yuฆ@*v]สฤ3‹ww!„BhYpL$<Moฌ`โ Lt*5yuฆ@*v]Zร!„ะกฟ}E™ฃX„B!”y0Š]™e,.ฮืˆR„B!tฎ‹])ำ ยจcptต[ ง์—:>vb๛ฝ+๒.{{นป†Bฅ)ั–˜u A=6KทฯJ๔•J2โฒด๖z2ไลณ“ๆoh–ธฺwu‚ศธพบP1ใ—๎Ž#ค,ทฌ,_%ๆ‚๎พN‹; @Jณ ‹MZนˆ ƒžกžป/กฅนล.„qu7z!บผy>…ฟx๒๚๋฿ึ{ร]ง›S„Bh๙‰ ฅ…"Wถ!7UVšuฎถqmฎิZ๏3V็จ๛<.HŠšNอ[K˜ShDฆ&๛ขรํ๕๎ษv TลUนกฮ7 œอ๕รT~UนAแ๎๗ˆ ฅE’‘ถฆถ'ั—ญ+ฯoฐฦzั\QฐŽF"Qf‰/4>ิจพํฏ๕]_พrๅ€๎๐ซžฺฑปอาี้๋?f™่^}๕ีw›Fg–tว.›ญ๑พ3Nบ๏ฝฦ๎๖/^ถ?g!„Zศ,ฅb้ะ,๏oฒอIA@„H[ดถ2O‘Yมฉ2™คฎ>๛ิ|วD#“(Qแ˜๘@HฑAˆaฐP(˜!รCพ(หา‡c”R*ล‰5‘ฌBTNemํ†|Yช๛‘Iิ'฿|ตyN ™ฬ-Wnง@|ยŸปใิฌ๏ผเ๒'{*/|๔‰หK็+ฎ=ๅโํฎท฿ld ŽปŠใ+ีk„Bh9Q”#ey›ถึึVฏ/ีK €ฐ{h\Uฑน@ไpำy•kr"}ญŒš‰•ๆ่|ใO๗‘jc.แฐN ‡‰าคD&&IฉTฅฃ%d้้yBOฯž–กpBmcป.์๓xผกL{„ZJ…v๚’+๏๚ัณŸ๕z ”lฉVย่วoผ๑ž[=PU‡ีศ็)>๚ƒ7=๔/^ู 6ๆiVฌ!„ะr"€T*ธม ๕Mใ๒โ"ฝ ์๎nnุ๎’ไๅSCํmถฤ†ฆœP_˜ห ๖นyV๔ 49บำ˜‘๓ Zูœช๊๊ ๅxŸณ^ฦฑlข_|ใ๗ต a1อA  4g?ป4D หไ1Wพp รI๘ ๕F]bGƒB(ฦiz็ศศz{#lFM/.ธฑaปŸๆ€ณปƒ›r๖bMaน‰rX‡•ๆช๊ขฐณงร:–!ทy‘JณY๊์h็ŽPjTมั“ซlภัdŸ•gฉห51Š]ˆ@SX‘+pY,ฮฤfน&ั—gำ๖ŽพัL๘œuŽูœ'‘ุ<^`เ —‘H`๔mเหษ„1ื‚ (Dฃณ q&>ฃ!„2GŽX|MYู9f๓Ÿ๚๚R—4@ำณƒSŽใ€า–Tไ{Zz้ ๙c>cตA=0ๆZb|7rด%%ูฬrลRตJ$ฏ?ฬ8๙ณฒN1ะุ8ซ”ฬ˜}›ใiš&)1อjJk๓๛ํ < ฃุ…"นJ%Oย๊LRขPฉข#ฤย9ำมQ:ฝญญ †ฐqฑ4ิ{แ›ีว[V_t๓ฒฟt๎CปrฮแyšอZ0y๎นr๏พ๗฿ี‘็_sแZใ™‡ 4๏;'ยBhu‡ี๕เ† ลฐใcขœ\นืdๅ๊$^›hถทe”a8มq,หฑŒ8a:ไ‹ณ–1๖๐๗7์์Ÿุๆฎ"ฺี=uฯถ(K!๔ อภึ็๕Œ ฏ=ภI๔ =๎H์ฉฆล.„vด~1 \žQฐ6}1”šV‚N$“SW๘_๗\๐S๊๎‹๎~ๆ qph฿ผฝ;โm—?๔ะฑ6ž๗ะC็u?ฺ๘๎Bป๕‚ฟฎ vฟำ[~ณ79]@!”รแฐ2Ž•i‡†ฐฃปWZRฑูLqaŸณหโข€™˜$ 8Bkึnอ‰บ,K„M_ ฆ ๖ rY0X ฝปWR\ถษ$:86ุ9่Kฌ<ฑ"P‹๔‚Qซudฉo=kอ& ํ์ตy3aEม"5ท-๏พ‰อ๐ๅฝ1™<๒ลWœ๒ฤฌœ‘Wฯอ{un๑Mg€็oืี,๘า„B™Iฌ-˜ธ†Tfณ†™ธ,fJโฑA—eฟหย๗+.่h฿๋Hฎ3O%šVf˜Q{หฎ™รฺ้5ฒp)6่ฒด๐๏xเ3 BHีzฝV–„p_ ื่๕ji†ฌ(@!„–ร๔ี’iง/‹™’˜Z‡ศ0ใGH$’้๊๊๊vโ3s „bŠ #‘%ฟ๘€ˆDG‡ฃ1๛F]]œทRลŸs‰Vฌ!„BI4็ฏ๗๔ีqYฬ”ฤิ:D†97(“ˆ+ ฤDรษ9 IRM!„Pฆ:p5œqYฬ”ฤิ:D†?\Q€–jลๆGq"!„Bำ0ŠE!„B™'รขX‘ฦT\lฬJคื"M~ขE’X|vU wก๔Djฮพ๔๒s4/nMา‹#„BqQ,ฅะ Y"ฝฆไู‰Ib๑YU%y”˜ํ๔ฺl฿Rขm๗๎ฒู~}ผ"ีZ!้ตูl6›ญฟฃ฿บ๕๘e sNป๓แ{ะ}g/ฑ่บูlึ'พถศโ!ดชˆuลU›kถmVปuSฅIE€D_ฑykM๕†"u&ฎ—ๆo<ฌn[ฉฒŠถึี6ฅฆD9‘‡”ๅVlZ[[ฝพD'ž,GJณ‹ืmZปญfห†ฒ\Eขฏ˜สฐ]jktA$‘ีวA{[ฃ;ฑ"I,>ำ":‰(บ์ž Lž๏gN๐ ส™อษำFs๎Eืแฉ‘ฏœ๖t๏r=็ฺG์, ๗ฟ%Gกฬ$ห1๋ยึฦVw$ฦสM๙Z๛˜W›+uทึ๛Œี9๊>‹’ข€ฆูTw5!ยœBฃ 2๓ฑ๚AkSใเ์W'๊|ณภู\?LๅW•๎~€ุPZ$ikj p}ูบ๒ผ๑๋ฏ๛šm ƒ)ฤม๓็\–‰F"Q6‘K3ท`๎M%ฮ*>oฮ‡ษ฿๙%๎บE์ไŽดฅ=ใฎkถD?๚๙๏Œ่ฟ๊ฉป,]อŸพ๓o–  ีfณๅ‚lำ;lถถ_?๑ฐขW-];๛Fv ฐXž=ฏ=๑ศ=—โ?ฌฐ๚ด“๒€o์}ไuฯซกรา^แ_ฝ๖ุ<@Wwๅ“๏๏j้ถด~๙oฯ_/8๚Wm6วทžtๆoณ฿า๑้“฿2˜ฏุaณู๚[?๛ว฿ŸฝธtฒแMw์ฒู๏;ใค๛k์n฿๙โek)€ฃlณ}v๓:ม้ฐูlถถŽQ@Wwีำ;vทYบ๖}ึC็ฌ•จs{ฏืwu6ผq–ฉงf๔1Bย:สฒ รฐ ร2Qš8‚ € ‘ถhmež"ณพต%U&“ิีgอŸM คุ ?ฤ0@X(YJล๘๐/สฒtภแฅ”J๑•ฬmzั–ๅoจญญฬกdฆ๓็\ข๙Z\๋ผuN'.8Lœ‹h(‰Ÿ_Gzขดว~ืฅ ฿า €๘„?wวฉY฿yมๅO๖T^๘่——‚ใ๓ฯ,ีต5€โ๐บ*๏ฟŸ2dี‘G้%ฒ‚c๊J็o&๙‡l^ฃัศ;v Žผๅ้›Oิิ?xล5?Sฝbใฺ,@|=ฯ๙—xเฏถ’3xโชตSี™Nฟ บ๋ีท๖“ล฿๘ฟo–ภศพ้ฆ›žูu๐ป์ดง\ผ๕๖›lมqท_qœ:^ฟ๓ฆ๛wุุฝฯtำM7๙z๐ฯ๎8ีุยฟ๚‡wนฟz๖ฺ๕Sužฃ๏S๛ …1~ถOแซแ!„IแกŽn:ฟบถฆfzญงี2ยBุ=4ฎชุ\ rธ้ผส59‘พึ~oFอฤJ๓ tพ๑Y“tา๕ตต55ี›ซส ๒‰X“‰าคD&&IฉTฅฃ%d้้ว๑{z๖ด …j{๑ฑ ๒z๔Yะูgฝฐํ๐+.Qƒๅท้*J๕N9†€uฝ}ร)รขจทžuลฯ:๚ใษhรป฿ุ๗๔ปgป๒๖ฮฮQ i€๑แแX๖6Œม™']}gG9œxํ•G‰_:ทชมฦื†|ํIงoัญ)ฅิO>๗๊O_TGžอ…kg0ะผฯถŽl8๚๒๛ฎ0 @฿Os„ฏxocฃฮ8้๊;:ึชพU`klrฦef#„ะ"ฬŒC2D๓ต:ฑว!dูY`4tดทe”a8มq,หฑ๓D}iว฿฿ฐณbS˜ปn‹|hW๗(:RฏWน‚^Z ฯัษ|ฎX_ใฑ>ฏฏศ`TxํNข7h่qGb *‰D2C]]N—|1๙uแŒmL\M‰sฝQW—yo|H๏ฟc}t๛ั๎—y'ฏ]ภฝxฮั7$=์Š๛๎พุ่uqph฿x+โ่_ํ๕ปj€มงNฎษฉ:ึ\๚ฺkwl พำฉWฝ5O$•vถ?า๛ว๏ˆ€๖ู;wๅ๚ื  =x์ยฒำฎธแ’ำซ,ะpฎ๖Ÿฟ๗ึ฿}๎ศ>โš๛๏Qzมx?ป๎ุแ่_ตฝ๚]็ฃว`tCๆ+v|qืฦ-ฟwEมeฝท์๚เ*ƒkภ)ษQป?|๒–๋Ÿุ=ฑFƒศ?๑'๘5๙’`3}ฟฏ๘tฮQื?pฯ๙G”ฉูแzโฎŸ฿๋tวฎฎ?๗ํMw|&>๓นž฿ž๔๙›ฯ|n2๗!tจJฦ%ๆี*ณUฆายœ, ลE[ลแŸ^ JH kLY‚จาฺ3Me/ๅ@ „,งค8_#’Lฤ7bต๔บCฑŽ)อ.*6i" ƒcC=–!฿๔W~ผA้œฤ๙ขXฑถภคกฝถสlึ0ฮ^›—มฤีŸ8!#ฃุธ‘EGตี@ๆqั ฿!;~๛ฃฉ๎Q†›qฆบ+กด3็‚’†พD/‘ฉrˆ sB๚่ฃ?yแ‚ยูน๓ฯzbว๛?ฎœฟฮœ๏<๑ฯ;ŽXl6๐ฮ๓็™โอ]xม๓opc<‰้aห{๖ปฦฅื๛ลmฉ{)พ“!“-๕H๋Se iฦร๊ถ•j$๚Šอ[kช7ฉใzUšš9"Rข+^ทนfถฺ๊ ๅน๒ษเ‚”ๅVlZ[[ฝพD7๙–q ฅูล๋6oญVณeCYฎ"ัทณอทหBCm.ˆ0ภฺa0๑Hฬ %ตฺf—ซ5vแ์ษ#TŸU˜œ” ฆัธgyฝ้7^๐# “๒]ฟ๙ษyM฿yชฝๅฑo๓lผแออn๐ษ‡ƒ Ttอ๛ญ˜ี2เ(ญs ‚ศไKช$ฺ\ฉปตgฌฮQ๗y\4ฝขืด%›5"ฑกดPไj"ไฆสJณฮีๆคP็›ฮๆ๚a*ฟช p๗๛ฤ†า"ษH[S[€“่หึ•็7Xcฝ่‹ฯ|Q,K‡ƒ/3gขX€ฺๆ—8]็๔ฦ‚9—ุP;Ÿ&‰ ๎บฅี™IšjjDฎ–M“Jeๅ…นฅ๕๏์yv8‘<น!Ohoนคื+ฬ^๓J™f๏žปํQ•2Š"รz‰ ๖7นl/z\Jee…น›ค๑}6ะ๓œ+ฦ^H7)่w;%U‹>K6ั†-•๏^ี:่~๋ฏŸ]๙-hw๐exร;K ]Ož๓a‡g2•4}๕๚[~p\ฅ^0ึ๙Ÿง๎{่Ÿึ™Dๅ‡๖็[ศ๛ฟ฿>Usือ฿ซ-Œ๗์|็๗O๙ณมyHd{ฯo>^?๚๙๏nฟ็>6๐ฮ รW^๘โl๙ั{W\zษหา‹_๚ำลrึDว.|Qฤ—8dWฏฟŠใ+5Œ}๏›ฟพ๏๕€7ผsƒ๛g/^}ํQz๏๎ง๏ธ๋M  ๔S[๗?พŒ*๋h~๋แ{ŸrbีIน๖ึ+ถฏำƒk8" %๖ภy['ว\{๋•+ีดฝ•‡๎นy๙ฮB๎‹‡Nปๆ/ผ!,4๚Guิ•™™˜๕ตkoญภง}์ป>/น๑šf๎:ษๆปฉๆณ๙ย†3~๘}๖ซฯ<๕์ŸnสญญRฬื-๓ษ฿ฮ๗฿O๋หฎ=ฐX฿Yp๎QG}๏™.็kWuิQGuแ‹1Aqโoฉhธ๗SNป์ ็ื~|ษๆษtŸrš์•ซN๛ฦ“๕…G ้'น๙โ[ณ๏žr๚%๒z๓wืNโเ:'^w๛ฺๆ๛ฮ=๙๋g฿๚Fฯ|x[WœxU๛~๒ฏŸz้๓ม๏sมฺ˜ลys๒#ฝ1โ=xวKัืNข^๘ฟำNฟ๖Eื\ฐm๊’"ู\#y๕๊3พ๕€ๅ๐๏h‚Ž๗ฌใ;๏ˆ:ใ;_;-—c† 'อ+ะ๙๚ฦง‚๔ฐ{h\Uฑน@ไpำy•kr"}ญย<" (!Gส๒*6mญญญ^_ชŸ|‘ฅI‰LL’Rฉ8JG'sฒ43Uะำณงe(ๆŸ‹ฦ„ผๆ˜เไ๖โ๙๋Ÿ7็Jb็ำ$qม]ทฤ:3GdŸWp‚9Ÿ๒9Aสฬ Q”Sเถฝ84&ฅUว—ชื((๐๑%จ,' ˜f๗ภวv@’UNมธ๕แุ˜Dไ;Oญ^ซผฬe1๓}+L8”`ฟMฅeฮOทืh}—๗ZศŸp…U฿ดํ‹๛/5๑5Iย,NA ZvพvoฦฐํxๆฯปฌึูหLZgb:ˆนผ๙ูใ๛ซR?ฌdุ”ฝD_ZœM;๚Fใ-ฤ๚’’l&ก"I,>ำ":ๆEP~๛o-ฐ'\ญŽฃค$‚€‰…Uิjแ๔ ฯYทษ็ IDAT:{4ฒฌ#L%k พญs๏็h€qทๅ&๋ไjลษฏ<2‚ื๋+ฒ„Q ฟ๕๓:ฟๅkรq—งišL฿GชQพ ๘ฯŸpไฒ๛.?๚{?ž๘์h๋k฿กฒฐ๚œvหi{ฏ๋ย—Šข&v'วrš๙)ƒ7\:(qf?MวSo?sNน๚์ภ3็œฑีž๙ุU๓Œ‚aฮวื:Mำน๑‚?Y็+ผ9cฃƒwขŽัMb^ผŽwD{‰wDห1ฬXu๒‡๓๒าฏ_ุ๓ฯ/Z‘‹ๆ•ฤหnš4t€Tญ‰ล๋›zบ‰ฒN1ฐฯ*.ฮ ๖ด๔าน๒ว:}ฦjƒz`ฬ•“ั|#jlอร<{–e&šฆIJ@LFณšาฺ<ใ~{7eฮฃ•€”(T*นˆX8็48+ั"I,>ำ":ๆE ‰ะagk„N์ีฏ›…&๏ผ\ใ…†,€H—? ั่@–6๏าขŠ๋rงบ ฒoฺด๖ฒผ์ตbp@FXwาฅPo–ษึJ๎]W~ฒ"ึ ’ฃ๑tฃึLPŠฏ_W‰cไ\)แ}{ท|ใ์uZ‰XY๒3Žoฺ—ะ—๗ร'mา‰…๒‚o๛าฯN:๐่กhหฐ๊†kW…g|ฉ[ ดTtฬ้๔2๓?Bžkา Ia๖_๎์p€}ศ–_st…VWzยU9c๕ญห๎ศฺxฤฆuvI+ˆ•8ะm1ิฟV%’ไ~์fฆป;Vิ?%‘KI๋6œZ“ะ™L QŒ?40hฌ=ฆBซ-:๖ฒ๓น๊:V๋ึn‹~KY .9๓ฮ๛ฟWsฝ)oฮ˜วh๎^J์-Q–น8GD u‡ป9ิ๎Ž•๗ภ๑Žˆo์ผ#ZŽaฦฎ“๗,<๋๎๛nพํWืm—,นe4-‰—4i่รฮI{zฝฌณ}gใ€ฯำาn๓1@มq,หฑAq฿ˆ‚์๘˜_™“+งHRฌสีIผใฑ;ภ๚ผพ,ƒQ!$IJf0h่q_b3l.6`m๚bb๕ผEšพLฌH‹ฯช*๑ฮฃy‘ยษXƒ &6ุั็:ฌขรIYl4๐aO๏k>pลž}MŽb“xเฑAโ็%Oณ๓ๆVŸฌ7-ฆธh๐ณ๎ว8ฯsํ}da๎๗+ฒElคgd๐_ฌซข์˜‚ย#'ะPสำ •แเc‰ญIOถมื๏{8ฆป_ธ@/๏๛โ…ŸผะสT๐องฮš˜จ๓'—M[=}k6ภ+Ÿด๎ฌK^๒๎x๔—๋nนO๏้…พ/ž}๐ฝ™แHธ๙ฉ_|๒ยํWืžภ—มัถN๊โk~u…Y'๐v}๘/{cะดžฟ?ๅฎ๙ร฿ าศ`ร๋w฿฿ศ€๓'|ิ=ฝ๚žท๘หว'Ÿ;;๘฿฿๖˜{~๒Y"o/ฟ๑;oขwวฃฟ\๛ฝฏžงfอoไg๕1‡ŠปŸC๏ญcn~ํ๏?ู๛ฺƒ?z่ไž๚\zๅ~พฌ#;ž~้+?~์/฿ฑผr๗Ÿ?=ใยXmวh}|วฃฟ^ฏz™Zด}๙โQˆqŒxsฦg—ล๓KณฝปWR\ถษ$:86ุ9ศ{+Kl„Drเ3d]]ฮธš}‘ึlึ0ฮ^›wษ฿8ˆต& ”ชVภuugโษ€šฯฬ็ฆ!ำœ ส๔ี0ค:p…]Žฤสผ"ฝ`ิj‰,ขฮ๔นjง`ืฅoP:'1รVฌ๘เ _zW๏ใ‰_3wG}†ผผกฬ$6”Š{w๏9&1›uHดนRwk}O ;GM•qฑ™0งะ(ˆLฟƒg˜@จ๓อ็๚๚ฏขภ ˜สY$๑t5ํูฝท}˜2•็อ๓ND>ทงVวF#‘(“„๗hฐt8๖๎4พ‰jm๘3“™์MาtMto)”ญ,ฅ(/ส+*ฒ(Š ‹, }Q.‚€ŠrQpปส"›Š,Eธ\ฎ ]h)—ดiำคm๖ฅ™ฬผบฐeJ+-ฅํ๙๘fฮyN2™<9s2วั5u!bฯw€Lุ๔ฌH$o๔ฐ=>_qฑฏ๚ น š๐]จH๏ฟ$$ฌ๒'@* |ณ๏€๑ƒฟ้ื๋ต@™wใ๎K๊w๏฿+ั[ะฬ[ึ{วc\๏…~".€tเ„_๚)ใฝ#?ฟณิpKœŒ=]ซ=]c6Œย๖ภ ๐——g^ฉดืYสฏ๒มKoญภƒF,ูด'้ฤฉc?o]๖ธฒ /Ÿฐ๙ฤŠง]๖กวwฝDW<`ฤ’อ๛Žž๓๋—พ/พQ๊ๆ ๙งไไ]‰‘>ฟJNNNNพmจ8่ษQ๒วาi๖-ล)ณ่ทำC0Ntโฮƒ๏=,พkCท฿๔ฟM#ฌ๎††ึw'8™ด{้Cยๆž:ท/ฑ[๎Žท!นฏำQ็๎XjyHH‡{Hฤ&ญฦJัดำTz๕าu- 0††`\yhฯ˜ึีฯLธ4(H +ฉด7ํฆ›ภ! ฺfฑป\Vซƒ$ษฆ-ซ*ฬNšฆฌM-!‘ด๎:b็zข:แ3xpŸ@แทDZอRl๕่ๅ5Pl-ญ์ฦeณขƒ‡rmจT—(ัศ๐่ ฌ_ห$Sข•ƒ ๓๎ผํณ@$.{):x(ว๐]N๎!ปpTDไ8A๋vŸฯ~Rฅ๚ณŽ?<,๒ูฆ—็คุ๖o็{=ํอoMœ๗‹#5๙bฬ+Ÿ.๘P˜ M3ฃผ“๕ฯ™ใžzแ๓แK^ู'ฟ ๙ใŸ๛gแะiO€๘‰…หฃSWM3.q‹vิณ๛ท๎ฦื~ใฮ ™?a์ Kพฮ๐+f๏๒›CฒVO๓ฬ์ํๆฑหฆ๔lฐ1ใ„{1๎้…œ?๋aภr>9ญG|}jๆ/9๛g&W@ทญ฿ฏพณ๖H9๚๙ภS+fฬ๘๐Jไ‚้CXฏ“‰ŸXด"6sๅคงฦฮ๙ม6้™=ู6t/ใำง‡ 6๏ื[h=!…฿O6lฺ7๙ฺ๓† 6lุญ nEŒz’๛ว๑lXทtgอั/v0SŽ๖VLX4N๕ๅๆณๆป5ิ"w ~bั=ฏฎ™:๚ฉฅˆบหSwวK์๋โึuบ=๊Xฅ–…„tuA2ธ0 บ฿ภมƒ๔Ž๐`Ž๊ “4บ0WSMฤ๔๐ญ+ษ.5ฒญ~@{™KหLMghw—“ย๙BŽ <'ๅlุ’ฆšF๗๔E—ฏUดn-w”ล ใ0๋๕F;šะ๊2u”1fCf[–/Ž"ภ\ซYQ๑ฏJ#ฟ‡˜e8#<8Gฤq•T—}œ[กพG&ƒ๎ŒA{ต0QOถ96๎woh}GEลwลฅI5•XใฤYฝซธpE @ภแด"ฮ๛ง๊ะ๒—ึœม^ฐํท_ถ,ถง ("R{๖๗4ฝฮ๓๚U‡‹;dO;vฌฤF›ฎgdสจ(ํน“™z‡ฝ๒์้T^TT๋&๑โNzxy‰1caสต`ฝfNงmœ6๛ซตvKลลดRoo๏ฦ(>ผํ@ฎ‰ถ็^ษชSศภp๎lvมƒH้๘€ณฆณžืถ~ฟ๚ฮฺ#๕ฑov]T้ิ็ฮคำส ึ สจ(๙“ูšาž>qYำ๊ฑเ;ต๘ๅhิkิŽcว šฤ}œŒj็IŠน_l˜B๋๓ปทำBw มัQฺs'2 NงนคฐขฎนภอK์๋โึuบ}’Yฅ–…„tyเ1Sž•z%ฃภ$ ๕!ีWSำrt€@ข"็บฺนา'ฤŸ)/ฉพy6’ปn0๚rํ;`@ดฤTRinุ๒&ใ/ญะแฝ<—พ๔บพฃƒ่ชp•A๏P๘W่f/†“อล0@โ,,LํžBญWฐื ‘ฝ^Zฃ/๛,W‡a€‡O๔^ `เspw'๗ป฿hฑT}oนi{šกภกyRฦะ ๐jiœ๗“ณโOŸ฿ฝ)่ก฿^๑ษ|๕๘uH’ จ†'ภRp๎ฯ;๖ฉุ๚\ Iยๅjุ’ข(’ [ีvล๕_cษื/๚Qeiฑ้ซ“%N๗[ cž{w้ธ’rbb?๘ซฉœi; ศƒKŠCF>9ะ’™ฅ(+(๔{่ษ~^ใ้ชL;๐้š๏ฏ่@:h๖‹ฦExŠค|‹Zว)>yE’ลmก๛:รผ9๏๑Uyeฯ'kw_5€0v๒ปหฆ ๆ›ŠR}ปuื9–…แZqโฉ๒uรgzY{$์•ฤพWฮ๖%Oxๅƒืววzัšซฟ}ถ๊๋Kตะด*Uึษgr๕๕๛๗]|hq๕๊!๓ ๓1๕๕Šwบโฮาปเึy๓๗ธฅI๓หๆฬ]qฏ/‚ ร98ะ.บึไฤ=$b“6หJ€ฉ๔๊%0††`\yHTญบVj์Di,. ่Š+…‘๕หถ3.g]ร‰Yค๋UyvIะ6‹ๅยญRJ4}zุฐa๓~ฝ}1ฐ1ใ„{1๎้…œ?๋a๒ฮุr|+๊Dคณ๕<8ฦทC๑‚dpa@tฟƒ่แ#ภี&it`ฎฆš ˆ้แ[W’ฉRXA@ฐ—นดฬt็ื\ฆ๐ว4ฺ๊๚๎ธœฮ๒p\ เ9)'A4ๅjQ_t๙ZE๋.ซข,้ฤjชKึๅๆฎหอ]—[v•ภฦq\%ีe็Vจ€/Ž"ภ\ซQQ๑]qiREM%ึสรž6žฉ0WsU[–ํภฐฮs Cฅ=w2S๏ฐWž=ส‹Š๒ƒZmฦq  ็Hc{*ุ ู๊ิ?™mก)ํ้—e112ภ1œ๔๐๒cฦย”k7q{ๆyืี‹—ํ6›ญเย…j›อF’$ะiงอjญRq1ญิปูNv ืDsฏdี)ไญiศ}๐ญจAฮฮe3๊๕fGŒฤธDฬ”gฅ^ษ(0‰ยB}HGuมีิด? จศนฎnฤะG๚„๘3ๅ%ีnf๔r<}ฝ์ZญตแOF_ฎข}c ˆ–˜J*อpหBa ๊๒ฮ๓qŒ wฐ kฌ7ิ๎)ิz{ฝู๋ 5๚ฒฯrีyNP4Œฅ๊๛๎ต–)I.Wร‘ข(’ €Qg๖Xถk฿\ณE“๖ษ†ฟุ ู๊ xnO#) ๘vu*ฌ2๘Kพ~ั*K๛๗ŽM_,qถ"Naฬs๏.ARNL์อ4ภ4žๆh†ฦ[๙•ฤm๐๗X'‚ ‰CWt]ืQ3ภช*-”กฒฺึO,‚*=ฦ๓ ‰ "4ช*‰2v@จC[”ซ2t’ŸyแฅR ออqq “xJmตฅ7WikenFๅ-๋— ”ล"] ฃาผฉ-๒z<ฒ<๘y/อZ ํเฯc˜ˆะ˜๕yu ˆ|ขท†J1๏ผš}ผk6Œข(œำ“q8Šข|ว-’็&wมปWYก๔?ัrฏˆ‘x้aั™๘šeomX๔8ฟ]"Dn„ร๓JE\ ็‹›ทซฆ†: uฺdฐH|EŽ๓ค^|ฃษ”พ๘ZŽฺ์ 0†กi††ฝj` IDATถรm7žฅ45ฅมๅb#ญอIiHaธbาli~h„6อ~ 1‰ใ„ะฯฯ“2™[7:€ฦb‘NL"Uฬ6<ฎฉ4aฑœซ–๖ ๚ม8m็J vน*nˆ๏ศเ`Žห‘^QบW_p'ิ ท9่ŠŒว6ฎ๏๖ชฝ/ส\šซWฎพย”พ๘ป]ž .ซ:uวชทvdบ- _x`Dุ•œ๙['ฯฺYf:ถ๑ำo}๚kขŒcS_ฺนถภ €ี^ฯ#^~mรซJ/Ž1ฯฏ>>าฬฤุ;U๖ทแห๖_X“ถาOFsว0g^ึ”†{์I~rพœx๏w pผ{ฺ#[w {๓IEน๏ฯัS›C_|ญฬ ทๆจะH,‚#kYฦ…๒† =VUฦ…ฒ“{ฺฑัฆ†: u‡ฆ X_I0ณ6ฟPG@รด/{ฦฃ็@_งฎฐ๔qอ๛ ‹„6ซ๕.ํฺ+ Š๙a‘‚ธ@ู ๅyๅๆVถย็฿PHHHHII๙ฑ"]ฯ/ บ๘ม šืgl]๑ซY•ีสDŽXytฬล๑o$Y#รfm๙LฒibฦswŽ฿˜ัม"า๖ย“yRฺbต]ชTzบดลjฃซำvฌnาอzn“า ัŒคปยA<*Y]ีญRXpf็ค๔ๅฝ‡;pเภฏฟ์๛ไัชฟ_w[ุั‘"า5qDž>>2„P^ vฌnาอ–Ccฑˆ{`,Aนn๛@ม8\.มP'๘ภีy ;V7้fฝ–Œลขyฑ‚ ‚?ŒซฮQŸ(5=่<…ซ›tณๅะŒAAค๓AY,‚ ‚ า๙ ,AA้|ะผX้"ธม/X๚๒#1>„ฑไยžOึ๏ฯnอjปฝๆผu’/`xษทำฆXาvaN๒Kบ “฿=alปJ๏“™?|.๛๔ู‚ ]ฯ+,R้%โโŒหaา็—(พOtLฐฏำf๋;ษยณw๖ํซไ๋r.ิx„Œ๕'๏Q๋าfUh\่(ๅ1ถ๊’ผยj.๐ ’‹ธeำWUš[55eฑา5(&ผ๓zะ–ฬ\Z่ ๎+_ฬ˜ด-งๅป_๐อะw๑กฅmWๅ™ญ๋ชlฉ/…EikB_ฅ—C•ž]ํพ"ฆ_ ผา`”๛ ชณฏ˜|e%z8AEตjรG๚†(8u7/cSeค—฿บค& TrดWฏTฑQ~โ๊R3ฯ/"”_s=ใบ•แ๛D๖Š 0ฅชZ3ƒf ’(xkBยwก๑กฝฟ‹ผ%Fฉ๎็ทO\L๚‘ู5v‡กเท_ฯyฦล๙hิ'ฺูฐ๘„'tpa_ ๐ K6ํI:qุ๊ฯ[—=ฎlๆ,€+†/ฺธ'้๘ฑƒ?~4ฅ๋v‚วื:ัปศW๖˜฿๚.>”œ|ๆื/?|)^\พ“ถ์Ÿื๓ฦ#Vž๘เQ–จ๚.>๔รฬ๘'฿žt่ฮฦ4/Ÿฐ๙ฤŠง]๖กวwฝ„{๐ยุษk<|๒๔‰฿๘าC\ถ-ร_)9yWbคฯฤฏ’““““x1ˆuwA–qQNšvนhฺๅข]NŠ รร0ฎ<ดgL€ธs%gธ4(H +ฉด7ฟ‡$h›ล๎rYญ’$p‰ุTUavา4eีhj ‰„ืบฆvะาูIผ:ซ43พ2ๅxY'OcฅRฉรljXO•น๐ษธื๖iภr>9ญG|} ้/9๛g&เ1jม›1Yœ9๎ฉ=พไต‘"ถJลO,Z›นrาSc็`›๔ฬžlฺฮ'_‰\฿">^|๎์5ศ๘๔้aร†อ๛๕–ีhิYU\$๔๗วE#i๋ฬžเใ็ง.)fˆ๕$ฑใ•qฯ,๘O่k3ใฯaƒ๘{็๎Ÿ…Cง=ฤผ฿๘…3่_ๆO๛ย’ฏ3วŠูบY๘ิaรฆ}“ฏ?oุฐaร†อฺYฦถ;‚ H 9*r จภƒ Š๏-ืgึะเจฎ0Iฃ๛s5ีT@L฿บ’์Rcง‰{™KหLท,6+์=x๐ A๚วF๚‰๊ฯำ.'…๓…<xNส @$Mนwิ]พVแhU(‹Eบ/SjKyลnญ ๗โv๒ู5vs๎rุ4ฮอ๎?x p๖ฯt‚""ตgOำู๋ ู?ฏ_uธˆ๕4 ŒŠา?™mก)ํ้—e112ถ-อg“3๛ว$ค๑๑็ฯfฐžƒีY\R๎๏๏าซง<4.Fๆ็็]ZRฮี’ฃJ*ฒา๖ิkŒR้ีPjO;vฌฤF›ฎgdว<Žแค‡——3ฆ์_ป๑šึuำํ๎‚ -Dz‡… ks3ฏ^อ,ถyGŠ1Guมีิด? จศนฎnฤะG๚„๘3ๅ%ี7ฯ่ต”]MMฯศศธšyฝุศ ๓ใ0๚rํ;`@ดฤTRi€[ฦšพ%nNษ ๗ ~ๆy›๋ไCฑภ07ฟ๙1ghชฮžUอŠ๏ƒŸ—ว๗H9— €$ Šj8MZ ฮษ^)Iฯญ๛i$฿ฎฮbฟ‚^s6น๘ๅ๘XŠW|๔ล—ูฯย๎๊ฌ*.๑x(,ฤฟ๚ิ)AdŒฟ^|ฤู\Wะ MทŸร*๖ฟ>—=๘Š๋ฟ ว’ฏ_๔ฃสาฝcำW'Kœญ่ฆAZ†#๓๖ดUๅm €ฃข:ฐฏคิlภxž!QA„FU%Qฦuh‹rU†N๒3/\ขT ดน9๒F)Mี9:เจฌถ(„BmญฬอจผeึfญทCY,าq0 จV|ภFžุƒp6๔อฃ/ๆอ˜ทฟ ิษgk7ฤว๔—๗IM^]ŸqQ…sฦ_qกง 3ืX็bE•๎[2sปชT%ŸีMŒ้๏ี7๓šf. นญณคุเHQ‰ฃ~ณ‡ฦ๒หฎ–ถคฯA4\•jy๐ึœ฿ึ.๘ HIศ€ษoฏ^>.mฏ:ึnา c๘voIจ‚ดพOD˜7U™[Rฮƒ–m฿†ใภ4fn 08Ž!๖ต]+ฆ๛๒าอŠ~ฒ2ƒฎs|& dR.ื{ˆขแoI‚ธ,บ= Œ[y]]3-ุG‰(Šย ึอzF ฐคgUึฑn4ฃ้พDRฟ็ง๛y8 ญไ‹/GfZNำ/๔’๓y’๐งว?lสศิ@ษูdWฌ qูฆ4ฬผ/+(๔{่ษ~^คฅไยw๋’ช vแm w3ุ•œ๙['ฯฺYf:ถ๑ำo}๚kขŒcS_ฺนถ ูห็ษษ’—ฆi6nhผซV฿ล‡พzN{’_œ/'ฮ]แถNฆธยzๆ*jห<ๅฅอลz šทํศB{ู•ฝ๏3ƒuผย]CXํ๕<โๅื6ผช๔โ๓๊ใ#5,[€ํ๔ท›†ฟั๎‰\ห•Mทไฦํ๎‚WVUฦ…2`ฺฌฒ2•TE„ฤŒ งU_Zคq€ซ~จื^ฃฑ๗่9ะืฉ+,ํฑl่šฒbYXx฿A$๎ช3ืTฑฆฆ๖ส‚b~Xdฟ .P6Cy^y+?‹1>Ÿ฿๔GBBBJJส฿้J~IH˜ะ…Q๐ึ>dๅตูล]๛>ฆI2\ฟG^่ฑณฏฎ8š›๐=จ๚.>ดธj^้n๛@แษƒƒ<)mฑฺ.U*=]ฺbตัีi ;V7้f=ทI้m…hF‚t]ขวV;y`ใ๓†mŸu‰Aฎ€#๒๔๑‘ 0 „๒๚จฐcu“nถ‹E๋โcฑ‚ ศr ฦแr †r8้ฦฎฮSุฑบI7๋ตd,อ‹EAไa\uŽ๚Dฉ้A็)์Xค›-‡f ‚ ‚ สbAAฮeฑ‚ ‚ H็ƒๆล"—H๖q/?ป๚ดาขŽๆ‰ฦฌ}๙ธiํYำ‘7ฦ||๑jํ5็ญ“|รKพ6ว’V๏ฯ ~|มา—‰๑!Œ%๖|ฒ~ถโ–&m็AะSEึัM~yฎโ–&-ฌ˜[ฌ›฿ i Aบา?v`ฐ#็ฏZ8>1ƒ|๔WฎUึ฿ฌYิทYrนศ€๑<ƒรƒฝล<ฬeี—VYqฅBฌŒ้ฅฐๅ],จmf+œ๏ฎ๔s1สฆWTZn„$์Wษืๅ4_C›‡„$("ฬOยe์zuaaฅล\E๏!โ›6ฉฮMษป๗๛[฿ู[n[7ทKH(‹Eบ%R61$๐ธญs฿Z๚KาาแIะึIตอฯ฿ }Z๚ทvWLx็๕ ,™นดะ8๚/Vพ˜1i[ไ=uึฮ2Œ๔Š_ี{3ฯ๙4ตMขEคำเศd„ลฦ•y@ญ\๚Zs˜LŠW๊h ฅRžAmเ๚E„ ๕99V*ข{†๙๊[ต:iห๑}#ยRbnf๕์z<ฟˆฎ๎zฺu;& Š‰Qz้ฎkV~$}CœบถŠฏๅ!แ๒ะ(O[ี| . ๋hJ+ต8ซrฎT72‹# ‹๕ท4ทคb นkศํ†n[o—ะŒค{โ๚‰ฉ#…ๅE]%‹eƒŒXฒy฿ั“'๏\๒Y}กtะ์ฯvv(้ฤ™Sฟํ{xอ[ก๛:รm“tุม?šาวƒตmnŸธ˜๔#๛ณk์Cมoฟž๓Œ‹๓ป้ฟg๕…s™‚เik;…y?๚ึ๖ฃ'฿๕แุœต›๒1๋~;=เD'๎<๘รโๆ๊Dไ>ยe2พพดย*•5ผ/zฝM"‘ิ฿ฟT*๕Fp‰ิร\UavาดำฌQฉ Žฦ[™๒๐ธA๛*%mtoSงฅV[’]jบRไธ‡DlาjฌM;MฅW/5ฅฐ€Kƒ‚บ’J{Dิ๒@"—[5ๅฦ:—ห^ญึ\.`\ฮบ„—Bฌ/k‹ธ5ไ–ึ%$”ล"“ฝโดœ$K;^›z0ˆŸXธ<:uีิ1ใทhG}0ป?ฯฬ{พ๖๋iO5c{‘zืI–B–:ญˆอ\9้ฉฑs~ฐMzfOถฦฅRฉรljXอ•น๐ษธื๖ilึ๊/สัฯžZ1cฦ‡W"Lยa๋fอั/v0SŽ๖VLX4N๕ๅๆณ~‘a้*0‰Llิ๕z‡T&จ/r่๕NฉT˜D*1๋๕.‚ สีpŠ Œ•eตใ’ค@ฬ#Hก˜฿FIŒหRฃีZp—)‚ \oเเมzG๘4- ๖2—–™ฺldคๅ!๑ธPWวxFG๘๊๊๊ธ\๎M‹ห˜F]Ÿvอ7ไ–ึ0$”ล"H—ฆŒŠาž;™ฉwุ+ฯžNๅEEy€Aญ6ใ8††sคฑ=•l…lu๊ฮŸฬถะ”๖๔‰หฒ˜ห†v๓0‰หawrายHฏ!C{JJ ญ์”๚ุ7ป.ชt๊sgาieœญ›ภจ๖žค˜๛ล†)ิฟ>ใg„!าFฤ2ณมฤPz-“๑๊ห,z=.•๒ฤRฉMฏงฏ?๛๔ˆ2คŸฒแ‘M“ŸSญPw฿ooŠ.3ๅYฉW2 LขฐP€๔ ๑gสKช๏:nฺpgใŠ$‡ahฟ)ณใx๚zูตฺถธv฿|Cnนmฝ-CB๓bคK#Iยๅj8อSE$0๊Œยหvํ›kถhา>ู๐[![ฯญ๛i$฿ฎฮb๛:ฮ07J4์ "qวู้@;L•ื~_ฝ& ฆ™=oืิ#—หE[7€ส๚๙ fสœ๒mI๎้"™Œ/๗†eD…†ณ^ฯ ’5ค”ึ็ีบ6œ\ฺœ‹Z„k:5PึฺถสƒZ‡ฦPUiก  •ีถ~bT%Jฅ@››ใ ๏D4Mcๆชฮซ€๐รh๚ฦ๙“xJmตฅwZ{ฯ นๅถ๕6 eฑาฅQ…sพ.s8Šข|ว-’…TW\.ภ\.ทฎ๎F†(’J\†ถšชLCท…ิ\๋mšQ€tWA ล3 น ฤ(OIyR{(+(๔Kxฌง”ห๗๚hWA€$ธž\‡รม๑ฦkn S๚ฤ%(yผ๐ ๏ฌห6๘เศLห‰{๚…^r>O๔๘‡M™Zถ8ฏ]=D)ษSŒ||@ๅตkฆf๙ษIœ๔~hDœ#/ทšฅ›œจ้‹‡^lแสุิฃไM๛‡L|oอฒท6,zœ฿l?iคLFšL ูd‘ศ~ฃE๔fI`_ฏo˜ฤN›๔fฟ1วI…ŸฤXSC ฃzDF๖ ๓ๆดsฐศ่๐ˆžก^xcH‹ฤื_Dเ8O๊๏ล7š,–าิ”—‹ด6'ฅRุ;Ccmญะ7@Br8|นยซฉiคๆzˆIณฅƒ-รฺะ!ฑทฦ!กฑXค›yธฬIHฦ…HฌUถ฿ mu‰ใมa<ถq}๏ทWํ}Qๆา\=ธr๕ ่๗ล฿ํ๚๗lpYีฉ;Vฝต#ำma๘ย&๚ภฎไDศ฿:yึฮ2ำฑŸ๖~๋ำ_e›๚าฮตNถึห^๓Yเ๏ํ˜้ร1•\ุฑrG6๕'G๒ถผ๓ึOG=]—๗}๔S>kŠŽpi๎k฿๖ิ•งฺt†ฅ›Xเฤ%ฯชฟ›žjฏษุ่5๓ฮฌNฑ่‹ฏ•ไึ‰E๛#๓™uiŒหdr(e’๚๛mQzฝ-BRงoบใะไ๒ย#๚๐0งY[X m<8ํลuYํm5+ ใ[Ÿ๗H๐Wี๕K…zpฺฬvŠtY์'/‡ฆ X_I0ณ6ฟPืnSa[’ซบ8_ึw—ฑ๋ีyๅM)"& mVkเŒญก;BbmฝญCŒฯฟ1‘’’าfu#ู/ ะมะ‘#VsqIภศฐY[>“lš˜๑…ใ7ฆwtฐ‚t่๙&ฅทขฑX้^œY99uร‰NŠa`Lู;ึ\w๊vtค‚ า”ล"H7Suz]โ้uท—บ-DA๚u‚ ‚ า๙ ,AA้|P‹ ‚ ‚t>(‹EAA:Ÿ๛๋.ะฑำดจ\๖_…F\ไ(ŒำชWj,ทN6(ฤ~๕j< IPD˜Ÿ„หุ๕๊ยยJ‹‹ญ!ท8bEdx€„ำณถด ดถ๑&’„XำKaหปXP{ฏF<2iะซ!พฝ๘Mู25%ส-Z.๊A%ณ๗ๅCเฆ…^MG๓๑ล{ซตืŸทN๒ /๙vฺ๔KZนw์ฦ]\:zํy๐[๛๛Jฏฏ'฿nฅI›ฦyx‹Ÿzw๘J-+Uฺw๑กลU๓n[๚ A้Ž๎= lชŒ๔๒[ต }CBธ5Yฉ6L ˆŽ ๕ฉษาฐGNธ<4สำ–w5฿‚หยzFšาJ-๎r‹๏„i2/Wู9โเž1Jใ_z†๏ฎโsืป >˜tjdะ ฬxจด–็๔ค2บึ๔ืท9ต$-žmไ]๐อะw๑กฅณZ0(>ฮgp๚ว๗็ะkึๆ=๕ึcูถDAVญQเ:ฐo@ร: ’ฐA}ผ†ย@ฉwd฿Aƒ๕‹๒iํฒŽ<’0hตŠฆ–ฃƒืฐOฺณ ๘๘Aร<›[cN"—[5ๅฦ:—ห^ญึ\.lฎ1B7h`_ฅคi‘M›^ฅึูh†qš๔fFภ'ภiฉี–dg—šฺmQคcq๙2—ฝธช์วสŠ*Dจั1ต <`ฤ’อ๛Žžอ5ŸsฝzP|(@ฏ๘ุฒœาถู๓~๔ญํGOพ๋รฑ!8k7ๅcึvzภ‰Ny๐ฝ‡ลอืŠ ‚t2m5/Vเใƒ•gu๙Z 4Pึ2์‚ภƒ4 lคŸ0ซ2rช๊/ใB—ขœภ๑ ›๓ำ.]JอัุšYฌŒเqกฎŽ๑ŒŽ๐ิีีqน\ถ†H˜GB1ฟฑฤ^ฃช4บ#ฤ‘หlq€หRฃี\๙@pอGiiKJ€qH…`quษ—[ฤยๅัฉซฆŽ—ธE;๊ƒู1xf๓ต_O{zฬจ‹ิปๆฎHฒฐฒินhElๆสIO๓ƒmา๛3{6ำ~ํ… uƒใ}Cโ๛—]ผา๔ Gพฒ'นมŽ—Cšา-ๅ่็Oญ˜1ใร+‘ ฆแฐuณๆ่;˜) G{+&,ง๚r๓Yskž9Aคใ๐x<ง๓๎ืๅjFM[ฆตนฌ3ฬ'ฏPn)ปšZฦ๘„G‡๙้3+€๓$พ>^^žBง&_cPไฌ-5S €ญู•’qgใŠ$‡ฑำ8Ž7ำุ4๙9uB—ฑๆๆฯIŽoฬเpmี\/2ต๒พศ ็ ๔z฿;š‹Mช}ี]2‹UFEiฯ}•ฉwœ=ส›ๅi:ƒZmว1 0œ#ํฉ„Cjท…lu๊ฮoอถะ`9}โ๒ŠcdญgูซผxA4s๔c"๓…m๖๑ƒJ๓ทNพcฮƒ๛-R๛fืE€๊L:$ะบํ&0ชŸ'=ฝ๖‹ .ฟ^๙ฃฆUO‚ าQADD„Nงป๋–m6/–น๑รXวbiชฮัp‘QYmQ…Ž4ดw”ฬกญิไ•๊-ฮ๚Œร0†iIBIำ4†aฎ๊ฟช?Œฆถ†€ฒึjญทีแชบžR…Ÿ๐่Hธ–[ŠYนH็„ Ÿ"ยkLบŸJ*ŽU[ู;9’$\ฃฬE‘ Œ:ฃฐวฒ]๛ๆš-šดO6ภVศVgภs๋~Iมทซณš‹‘wแR๐๚ษต?พค็Žo>ึoูิ#—หE[7€ส๚๙ fสœ๒mIšๆFไ~IHH่่EQ:ฎคไ๎ฟ)n}ห@c’๊6Yล0Œfอ>yaส๋jKcMธงยฏฎ๔๒๕ช[ๆ 2wkจUW\.ภ\.ทฎฮมาP=ŽภำSไ2ี4G่%'LZc0”ญึ่ “‰ก“ ห๓๐#โ่ต9ฏิฺ;:–๖DQฮi˜=รแp(Š๐ทpH๒œัหoIฒึYบoษฬํ-๙yๆDฎขๆ\96ขน๗q+ถผ 'ๅ๗เลMฯห*ดธjฌeปS‚ HฒXค[ยๅ3"}SRน^ _๐gkซท::ช{`IZ:< ฺ:ษปถ๙๙แ›ก๏โCKn Fg๏‘ร„งNZo.ฬz๊mถG๐‚ H‡f ‡.ิVR•ัUeqPfWG‡ิ>๐€K6๏;z๒ฤแ๋_ะฐR™tะ์ฯvv(้ฤ™Sฟํ{xอ[ก๛:รm“tุม?šาวฃู๖ฏI‰๙?โถ์ๆ่[ž}ื‡cC๊Oa๎บ)ณ่ทำC0Ntโฮƒ๏=ฦQ ‚ ์–,–ข(ืQก ศใิ(.>ฮ ื™—๓เ๕ฌŸฬRป?ฑpyt๊ชฉcฦ%nัŽ๚`v ž™๗|ํืำž3jฦ๖"๕ฎน+’,,…,u.Z›นrาSc็`›๔ฬžอ@งŸLŽ๙ศญ dไ+{’์x9คีRŽ~>๐ิŠ3>ผน`๚[7kŽ~ฑƒ™ฒpดทbยขqช/7Ÿํš/1‚ Hwมใ๑œฮ[=ฟ%‹ีjตกกกb1ฒ@บ…ฺš’uน?›yฯDF>ฮฟ๛๖2*J{๎dฆaฏ<{:•ๅตฺŒใฮ‘ฦ๖Tฐฒีฉ;2BSฺำ'.หbbdอEภdž3dไ#า›ห๒ทNึ`๚๗ญžm ๊c฿์บจาฉฯIง•Arถnฃฺy’b๎ฆP๚šVทƒ ‚<0ATT”Nงปน๐–yฑ*•JฉT๖่ัƒ$ษ๛๒ H้NK];์ฦ‹vธH{Œ๑}ส[xผฬz๗}:’$\ฎ†ษE‘ Œ:ฃฐวฒ]๛ๆš-šดO6ภVศVgภs๋~Iมทซณธอ†ภ\;๕_ลœG<ำฺฆGะิ#—หEฐtจฌŸjฆฬ)฿–คiณึน' า)Qฅำ้JJn๚ธ%‹ฅiบคคไถ-ค๋!ฝขwFzๆ—ฆญจp`†utLํ‚ข(œำpล…รแPเ;nแไ9ฃ—฿2cภm!kฅ๛–ฬฎjiY'ฃ๘วˆRm๋‚ฟ+‚ œ”w€7mฺ฿UP  ฎงท7—รแppผ1yw[่žช ะ'.Aษเ…Oxgํดุป^นน~๊?๛ˆผ-: ๒’“8้ะˆ8G^n5ธ๏&'j๚โก—?[ธr76uมจอ‡L|oอฒท6,๊ขณHAบ tง-ค[ชซ๚2ŸŸจ๔z*HJ;m็U%;๔๔๗๊|Œว6ฎ๏๖ชฝ/ส\šซWฎพย”พ๘ป]ž .ซ:uวชทvdบ- _x`Dุ•œ๙['ฯฺYf:ถ๑ำo}๚kขŒcS_ฺนถภษฺ|ฃผSถผ8ณ้ฯศW๖$ฟา๘วฉw‡ฝบๅ=*:รฅนฏ}ุOPWž๚๓{kำ–nb—<ซnzชฝ&๓๓ฃcืฬK8ณ:ล  /พVf[sTh$AคSร๘|4ธ๑KBยtง+"Gฌ<:ๆโ๘7’,€‘aณถ|&ู41ใน; วoL๏่`้ ะ าNะX,‚t/ฮฌœœ:๏แD'ล0 0ฆ์kฎ;๕n ;:RAi‹EC_A6>Pv‚~… ‚ ‚t>(‹EAA:”ล"‚ ‚ สbAAฮง๎Q€‹ขรฝppgUAžฦฦ}้xไˆๆ{`+=]Uฺัั ั˜๕ฟ/Ž34 ฆ#oŒ๙๘โฝีฺkฯ['๙†—|;m๚ญ^ิ/niาฆq4ํ0Ud๔แ—็ชo2.ปA•๖ห†U?ฆ›TŽ\ธAuEiy:ช-ช‡ฤล๚sร์ช๔๔r[[Tูy„ ซหสP฿น๒Os/‡$lPˆ๊ี ว฿nW#า]ฏธว•฿h,V$๗ช+หผ–u]G๘ˆฺฆNig๒žDื๘สeIZ:|๘๐แร็จษz๊๐แร‡฿s ื6?__็฿ฎก>˜ฃg|^1|ลฬธ› y์้น๛]/ผ>!ภยŠื|w๊ธgๆ|Z๔๐๛ †‹@1แืƒฮฏš9nฬไeGฤณVพุใž;„ ศƒฬQSZXจ6ดI ๆ’ิ .\ซผ๛ส,ˆ;mr†เ y๗žƒถัXฌIuีฬแ‰=ฝe—ูเ๏c/ฆๅdUVไaศฟช23ภ“‡†{‹Iฺaจ(*ฌ0Qฌ["HปโHง‡zCuี%™o|Gวา~๐€ฏฟ๊c1žฎสดŸฎ๙Šคƒfฐh\„งHสทจuœยํ“W$YบฏS1|ม›๓‘Q•W๖|ฒv๗Uำข`œีฮe &„H!๕F)mฏ๘๋jูผ ?เส๔ส8:?ื@\9pฒ๒›Q๐฿k}โbา#ปฦ P๐ฏ็ๆอˆ๓ƒ [˜๗ฃo}ด์1Ÿฺ๓_พ‘ฺ}฿ๅcึ๏|6ใีฤ%xtโ๋[ฆญ:knำŠ ศ=เˆ‘แR>Nู Ueฅ๊Z; กcIฐ–ฆีX๓NB๊+$ งu˜ต<-W+ ๆฬW BB=น”A•›งฑ2ค,8*ิWฬ‡ISœฏ2ฐgฎ๎Z๏๎0ฎ<<:›๋ิซ๒๒4V†ๅๅhHแ<ธP็ 9tลอ…7็u๗Qล’^‘๔๗˜‹๓*Gํลกbs~๊ฅฟ2หhEd ˜uKiWxOeุr๔?W฿5๋ฬฤO,\บj๊˜q‰[ดฃ>˜€€gๆ=_๛๕ดงวŒšฑฝHฝk๎Š$ K!K‹Vฤfฎœ๔ิุ9?ุ&ฝ?ณgหรน๕ห)ฮW ๎ซฌจฌฉT๊07ž๚Lf“L&ƒ†ย†ณ'sแ“qฏํcMa”ฃŸ<ตbฦŒฏD.˜>„รึ๗šฃ_์`ฆ,ํญ˜ฐhœ๊หอ(…E๛Ž็ศT^ปr9ํบสศ•Š9ฆโห)))YทŽ›๒‚ช๔ห]ส(ทูี™นZ|}9ื._ฮฎๆ‡zb —š าบ|UM๙†+ฤญlฝ›ใ๛(ตyFaร๓้๖ๅเ๘„†‹อ๙i—.ฅๆ4Meษ๋๎—ถษb92oฉ!/5#;ฟฌฺๆj,5้ ด‹vY zง‹va8 Š๊๔:ณ ˜บ‰Hถ-คqDsx๊ฒt ธ€แ$มํ่จฺ2*J{๎dฆaฏ<{:•ๅตฺŒใฮ‘ฦ๖Tฐฒีฉ;2BSฺำ'.หbbdw #ฝ† ํm+)1@DโŽำงO๗ฬ๏฿L`๖|v 0์ถ๗<†มm….‡ู€‰๚ุ7ป.ชt๊sgาieœญ๏ภจ๖žค˜๛ล†)ิฟ>ใ๏O•@ไ๏ร0‚K@Y๕•…ล:๖aSส๎hL)0B,nแฒUฉ4Šก-3อใqภXœ~ญไค]ฝษFr›=ทด๕๎รก--ฏตีูkkŒL๓้–@(rึ๊ฬรธlึฦl–ผŽ. ่้s—Z๎–8Ž{{{ฤgคด†ใYpฏA@๋Kฏ•Yvย0Œ็ำฯ‹œใฒ›๏–ฏ&$$5ค ฅtๅUd‰ร@ู๛ป๚lฃX5Pฐ๙า๕ำฎป์ุู$แr5tŠข(’ €Qg๖Xถk฿\ณE“๖ษ†ฟุ ู๊ xnO#) ๘vuVsŸ‰;Nฯฺaชผ๖๛๊5i๕…฿LŸตื{ัU‚/?๘๑ช€ฯ6…ˆa˜[ ›~ตฦขฉ›.—ซๆถ๏@e|P3eN๙ถคf†vi7Ma)?$ฌwถkิ%%:ึŸ„;LVqxฟธ`—หa,.24•37ิงฑd˜ฏงi x`ธณฆต}RŽ[?๋›ฮถ ร4“–aฦ~ฒne^ว๓Ž์แใ(ฬบปCKžyŠขjjjŠ‹‹้›> nษV•J%Ÿฯฟz๕ชรq—_ึฅษพุข†a์•ูๅ7๎n?๋&yr?kJV๊~แุ่เ”n[aEzœEQฮiธโยแp(Š๐ทpH๒œัหo™1เถตฮา}KfnWต$€‚oฆปฟu€3m็Žข/?ปโžr0 <‘ˆเฑHl0่ŒF#O์A8๚ๆั๓fฬ_uท ‚pRNp฿w^ด๑ผฌโมำ&wWYำY๑ศc1ึห'.•ืตคc‚m.‹ฆ๐šฆ#REDTธฏ1Kใ๖mว๕ •ึ^+็๎ร \Ÿg๏ฬใ›ชาฦ{sณ7Iณwoา…–"ดะึ‚}]~โ่ˆ(Š(ฎ ˆ""8จ0โซ#"ขฬ๐ขฒจŒŠˆห Š€Œ8:hีฒuฅะา6MทtI›ฆู—{sค-’ด…B[8฿OHžžๅyฮฝน็น็<็œ85]_TิA3คztFศYํะต_ .ว…:๋ 0ะ=Gึ3Wศฏ !Oฒ:9C€แtซกื?๛ly‡“˜˜S[{fวœณ" d2YmmmŸ.์Eเr:ุ" ภ๙๊„Q‘Bด_-b(๐บm…fsกู\hถท3ดปl7]K ชuชœ›Sลlฎrโ้tuuษb‡หๅl‚ ผ'z' 00๕ี:EFN €ฃฟkJปภฉกถฝ๖*œu-ภ]Z\1๎๖{Eฎ"}ฺอ…E•๎Ew?ZสๅˆดwNปฮZrยผ4:ZJโค|าM๎สำํAl ’Y2๑๘฿ฏ‰=ธ่6iOธฏฌ^๚โฯยฝ0kDแฉต๑Jฤสใกเˆ๙3เFฒู8†tt.†18ฆs|$‡K{๕ปvฤนธ].ฎ8\@’nc}‹T›‘๏ต6้สkฃฦค@i™5bต?ไi\N 8๊ŠJ ฎ€ต#ฮ!ะๅp{๕iา่ŒGSฅกCๅฟ.๒๋|CE%{tdxsE๋…ดปํ>'ไใrฯ =ไไไ๔s,ฝ)/’หVโvๅไLG-%Bดr”#ำž฿gŒิฬ๔wัฦ%๗œ/œถกxจ•E WึกเาคLe็๑๒V็Eงฅฒ๔๚KธฏฬUโr ต™็†ื^ฐ9H๛ล"ˆ‚ท์ฟ?>ธ๐‹๏ๆy)†a€ฑžฺพบk jMฤUฯึ—>!ฺ๏๒0”อPะ}ฤp็ผb๒bˆซŒึŸืฮ๛yํนา€B:<& ด"hu@ bไq^์e‹จธ"T@ 9W‰ห1 อผ`•ะX,@ bไผX@ ฤศc`ซปeJฆF ฮ† ๅวtAฯzใEM%k๚ฺC—‘ฆf†น๊‹‹/้~ต#–0&et„ณ๒Hutmฦ๊^ูGOำ9็ท)ใ„วjcๅBF;ฬ :]๋ีธ/)๕ybx™๘+อ#x@ม”u฿/ปzิj๛”7\\ฉฃk๓}Jภ๐ฺzไใฺพ3'ใ…} Ÿปณ ขfl๚๐ฑถทgพ|0ุฝ  ผoำŽคํทฌb*@jฟLeฆ-ฝe๊‘n_๓ ›ื|ฟRถuฦ;ี/์85์ฬฯ๑?/_ฟฒ-`สฆ@…Ž]ฒgI๋‚ภงฆ!ร‘&3ฮUZฺt้Ž`:ฟฦ ฉJVoใจ/.5ธ็สโด12!ษธญญz]}็ูI“ชดฑ‚†]'#าdŽV ภ๘(—ฅนฆชั:ฯ3ฟ(3A“e/>ูาQrฃฦ&c•% C๋ต ฬ‹ฅ[หท@XงฌฤะŸว๚ฦV[xธยโ'hฅธ‘W™ ใv9ฟ`g}I?ฝ~ฆdซด|sEI…๘ษฉฅนฌํ๙>2ฑ๏{แ๚}0ุ๎หษw๎ฝปdฯ ƒRšm^๊,<'rศkฟ˜2}ผฬ์4๘ฃ„HฯN'|'๛Vm}๐์๋˜,%ธH,5วืœ๋pT ฎ้TQน Fฅ$วู +Mฝ|SŽ\มiฏ๋์1rิ—\8G™xFm*Žcre&ืํ&ู]g‚ฐIาcฟ|/AœˆŒ#ีŒฮศฬฮš0.%ZD๐ฃวๅไŒ‹แณีi99999c#นค$vtzfvvๆธิq_WฒคฺŒฬ ccD}=wฅแตwkOชณR—ถ\$ณต6ูผ>ŸืึR_฿้พšZ)_™ž๙Yvๆ†ุฐกึๅ‚G๔;_๎๑เwŸฎ›3^โŠ3็ำo๖์;x่?฿์โปีSม„หŒธู Ÿ๏๛๗o?~kBตqณv๎;๘ใพ/Lโ๛ec—์ษห;๔๕ป{,ปืY็ด™k>๎วŸ๎๖ทว&Eฑฯ.Gpํ‹฿|าตยพSžwหฺŸ7ฯ๛ฟ$ฮ|๗ย1Ak?฿"ๅ}›พZz&มM+ฎธ1ศใ2`™c—์๙hV๖ญฏ|ฒ๏‡๏wพ~ท–ัLๅํ™ู๑ฃณำ*๊B$@JL~ใ‹Ÿ์๑๛ป#ฮฏy ›A:e‰รˆไyŸ~๛สu! G Ž4>5=3+kุไˆ0ึYย์์ฬtMxฏฬyx˜(ฬฺฺlง|ดวาาๆ‰ฮz(rๅ ฒญํผWŸปำๆbsบžL#ภ้ท™ท‡Mฒ“%_›ฉFฒมํ๖O ก™ƒโล๒๘ฅฒ๘ุ๑uERด ล๙๙ล๕OsY~~~~พ฿๋Ekลึ๊โcวK ”Rัว๓’ไ 9,’/ไ^eัปดd4;ฯŸเEษสสฬŸž–จ„l“ฅdฑH†ขป#)KsCวฟU]6้ฌD๕๖]]ร๏ฮ+8ŒB๘งลห’ W=8e๊ผMฦVฬMว ๒ฎ๗vl}่ฮ)ท=๚Iaว“/ํณ)๓ู—าNฌผ๏ฯw<‘๓พWgฅI ำณหSKW?x๛Ÿ๏๋ฎšฎ—ฒ’๕wๆๆๆ.๘๚ฌ] Uำ?๊ตp๚๗?ทตD•vึฃ›>๙ฬ฿฿๘วa[_){ใ#ฏ 9ห๏WFdg ํdฐฺXิชฏแซีธเฆๅŸmž• •สPซrฃ,4Sฆ๒?z๊‹ŠZ8๛บ/ํ‡{ฒฒ•qู้ G z~๘‰๓?ฯ๋b๛œธP)s๛ฝQy้ัGVธ่‘k r3˜๖฿vๆลทห#ฆ?;ตw~ะนๆฤ…@(โ„ถชยฃวN4๘"ฃ„]BญะVUt๔haE‹ณืถ๘Cๆ ฐXค๏LIS$ู{๖šฏPเmm็^pŽ8Œ๋vwMkŽ7ฆ฿f๚n›๓๙ษ&๎.งaอ”Sx|งฃฮๆ๕tดwโั|6XOL[๔ล'1š๖˜ญN0่0ŠgKU…‡O[Lร1ผไrco(-lย#x mฒFe>$fจ)ปšลจ 1`˜pขธ๊8…#ˆวมฺัดณน“คฤw‹๛ธG,1IIฦ฿฿;av๖s!gn’ Šฺ: ›ว0ภpBœ–{ …มสl๛c๓)ป์?<าร)8e˜269ษ๘๛{':ฝตบฆPม*8†“a2™kิๅตๆฌWศด9ฯg^3๛ˆฝฏ”็`๛-๏ฤ3ูศ‡๘ูู๊?พ, ๚ถศ"}mฃZ-“ฆJใ•)’B•ผฎด1Deะทe๗i+€ต ฬ“)h ’k>rX0๋๖›ถร[\ำฒบคU›gž8e@ ฿qค Pฑo^ดภ๐fฆซ์ปsอฝMทsh‡yฤe€วxฬu6€6ตu&F Hฐyy|ทฃฮF1N‡ซืฏu่<P‹Bนg,wœ๐cฦeG†3”ฃณฉฆฅ+œ`$ธ16ำใv“$O ๐ค@ภq“{ืc}อ/ร0ฆ{1ร08ดMก:Qฃไใ>ฐ8tUX7”ฃร่่+ัU‚๒ธปณอํ๖> ฐoฺ”= ภ*ŽA?^3˜วย o0Œ ฏ|{I’Eำ]ฯŠขH ŒกD7j้Ž/Ÿดู[Šz๛@0aฐ2#๏Y๛ูd X\—ก,่+‹uฆ๖ะ4ํ^๗n์ำฯm}XE5ด}ใ{?ึ๚cฏxทผ๚^ฝๅพcฮพRž้ท<œ์1Xพ,;๙ศมใม dQซพ6l’&NŸ๐SิR—~๏@๕^>ฦ‡c!ว(*]7ณใใวฬ์iก ํwสž–งišลbA›จฒ}๒ภใ[๖sณˆAร0Ž*eœฬ8AปlœํHœอy!:ˆ0นœ2–๕Ž|uิ—4ฑใ3’ˆฺสFk>˜~›้q{H‘D@ุ[:ู a"ฆ๎ผCgๆ xฑ ร@ท็zึศs–›ฯVฤฉ้๚ขขš!ีฃ3๚ ภ"xแแฺjฒธฏเ9฿ม‘'hุอๅxำปU พT& -ํทื)ฯข(ŒE`{gณIทใ๊Yล0,V๐ทฎ‘EQ8ัๅ?AQ€r๊โk๓ฟ}ูYฃ๎…Aหฌ๛๒นYŸ๔ฝถˆฆ้žฺq<ค็จ๘fอขo€ลŸนตeS‹|เ<ธrฑi๊'g๏ช_m!S 5๏ทถู)้ฒฑ'~_"\& Eตz=Y‰‚ชƒ๛Us'ฆqJ๛Cฝ0€‡žŽ0ˆ๒n์ส3ฐX,/ๅ…ภ7'ใกiœ2}ึC3ขูัะำฃ nธ9ลqเัฦซ็ฑ€ธ<0 ใj>Uาxึqz;ฝ3TžEQ8ัEฒๅํ^ซ‚‰2ทฑไผ‡ c14:ฦEซ;›บmnLอdTผ;c๎ฮๆŽ๒Jึœg~*FFXช~}๏อฝฝใ3ฅ[ฬพ|aึ#ou†Lyีyyขวjู๐v๗C)PํM-b๔ต ฃซr6u4„ฉฅuม‡b–Jซs้5๐„™R่2๘ว;V/ศ9๔š฿ใ7๋O6tJ๕h$1ุPFฝ^˜:>†…ัnณกฺแฏฑ Mแhช4tจข{R_O@คษญ๒;D้9ฑ]~ˆปนบ–ซ•หbVc•ฎ+๊—($vcMเcmltคGซอMฎหฅ|นH3ฝnทฯCู=”ฮx<=CฑCh&ฦๅžyำฮษษ†ง๋"†„]99ำัอp%Bดr”#ำž฿gŒิฬ๔wัฦ%๗œ/œถกxจ•E WWR‡BศGeH Nทว๔R1lอ<วS”ฑX1b๐–๗ว~๑>†gฏ+8ธฝ~ฌuรุ%{–ด.˜iรP+w6qณ>๚‡dJฮ’Fอุ๔แcmoฯ|๙เy}D(๗\,Qt‚F%b3.ณAงkถ๗๋H๋„ลOHSณ˜žุOำYาo๖[ฅ^>.Œ“ฬi,ญ๔Ÿ!ภUง]ํฉ)ชlฃบSŽV  ํถตีU๋Mƒเ]l{Ž3ัรฐ่คฆdaปใซ“’โฅ%•ฆภ๗Wญ‰ฦZNouยุิ”หฑj3C*ใโุฆฒย&'ฦ‹HN‹W˜สZปมlU‚–oฎ(ฉp?"9Uฃ4—5_[œำึ๏LFgทฦฤ&Fgb–=uy๔ญ1ษึc\nา5sWัฑ๎‰ฉ‡ญฒ1ท=ฑ๘้ษK๗…<`ุั|h๓ฺVgแxmD_์นpi|RธณฒดสŽK4ฉIQึขบ~œ’'ฮ๚’โFgŸตฬ{*ฑย5IแU'zŽมr›๊tŸฅ๗a™Žบโƒ #%๑c#Mฆš‹~^d{Ž3ษ‹๕Šน8ๅ์lmจ3tธ|ภ‘ฦkcๅBา็๎lชั5Y)่†ฑมใ๖พžnXRํ5ฺpบฅฒดยญ็๊€ไ๓ูึfฃ“›ัไ‰ ภไR;อ๕ึ6งŸีlcbธ$€‡Cฒ:F;ๅฐ›,n— ๐ืˆ‹ฤaถึS6/`kฉฏวˆ~ฬ>ฬ๑ูkj:ี๓•#’ะ.ฝฉแใf ›šฯgƒeบH๙Dœz,E{ํGk>lu GWŸฉ–6Rะ์๒@cมฎํ๎9š“฿๘โ๋KoV˜o๙฿WพััxไMYิอ)แtsั๎๕ซท˜•๗mzW3๋j6ฆ•พแ็[W—›6๓ๅฅeลrญ5๙{>ุผใ๗ฦ`ถŸ_&ภุ%{–ดฟถ3nแข๋ไผ๛โช}๕>ํœฯ>™ ๐^ €ฎ๓ภzŽฟชฺ<๓ะisฟสฬUXŽm}้ๅ:€฿o=ฤpเผN?`ฯ%’J-ว- ะ“,ๅืูC&}ม๔ป฿„ซฤQ&jธ-งNZh€ฎ‘`uE&๛นU0^sงฅdใกฯึพ`‹๚ฏH1spโb9ช๘(ฆ๙dม๑ข๒z [,$E|‚ะVUx๔ุ‰_Db”ฐKจฺชŠŽ-ฌhq๖rWIžร"๙B. ิสํ๑ $`‰˜G’A฿5\ฆ๚f K(ะ6ปl๕%]งฮฒ๘<6E‹G`ฑH†ขปฎein่ธ2ข;0Bยแ(9%‡ไ€ปๅ๕ขข็๊,€ฑว‹๙`ง2'…Kf'วNd;จฏ?J &k“ง .‘‡ป0๏Hส๕/ฬ˜ค ร๑๙บ^1S๎ๅ•ูณ^+HX๔X. ย?-^–\ธ๊ม)S็m2ถbn:ญ๚พZ nZูๆYฉ Pฉ ตzจฆ-~ิทkแ๔;๎nk‰:+Mด๚e@mทฒถฯŸzืขฦ?3+ะm{07๗ก๗ซŒ_-ศออออ๕G;”ฌฟ377wมืฆ”ฉ™2•๙ำS๏\Sิยูื‘ะ@ ฮ๋๔๕\,<&,*9Aม๓xC?\‘วเœ ๊่{ี๒d6fฑึู>ปŒ+Lbญี๐iS'฿œ %d๊;ใๅฆuฯฒวŒ3นั–๙/T๐ษฝณ๛”ภ๐ๆ~ซะทศ๓d„ %&)ษ๘๛{'ฬn€฿~.ไฬM’A‘พถQญ–วISฅ๑สIกJ^Wฺ วp2L&bบฏึ„:?2P™mPปŸ๛jU…'™'bdo์ฟEมสิทe๗i+€ต ฬ“)hม๛ญ'๊๔ฯ๋นุ8ฮ0 ฦˆDมธ|8>]๖†าย& 0‚งะ&kTๆM๎@ตJ่dพณกคญ๏น!~ฬธ์hภpฦูTQ>Hรอัž#วฬsฝุœœœฉ๓๓Ož-๐;M๎]7N3&’ใsYL†ฺฺ6'†qT)ใd>ภ ฺeรร0† 1@9:Œg, ญฦ•M~~พหXUlิ8C๛ี่HQศ๔tky~+ฦโ)ดษ‰p๒tป—วI’ธอ-•ufปืAฺ3ฟ@฿U‚ฑโˆD๑ใ5ฏอHƒ2๏ะต6xชŒoZฺdm๛ฌถ้@ปc`~:†“”Ša€Œ็่%ม๔วgoฑsc๔ค‡—ฟ๔ึBรดต‡€๎zฆiวp IVข(’E4้kร&iโิํ๙/1E-u้๗zšvฏ{7๖้็ถ>ฌขŠ~ฺพ๑ฝkƒŒP* ็–๒1>k`oอ)ำoQ๕D รƒณ;}€=๘|> ร่๖ำวฺX*์ฬำEเฃ<๎ฎqwsป=‚ฯpช=p๎ฉไจฏ0JดuษfWhี๕ล%เlฉ6-5ชœฐ เโฺsฤ˜yž›ŸzƒOQั56H8EQดฝEwฒE‡ฑxโˆ„$ญาRึโaฦี|ชค๑ฌภบFฑณ‚0 ^xธ€ถš,n_?ิธฒ!…r iดx€$Iส3๐G๐ฅ2mi๏๔c|™”e5Z<ภPฮ‹W#B{gx„สSwผผตืpaเ๖ฤๅฦ"0หฮf“๎a๐9`ื)“้L\l˜rŠ€0+žฉ๎8็ํZ H/ฦ๖i้ฉ‹ฆ` €‡c@`ะƒ๑ฝเ8๎๓๙gรo๏ห๔ูqแp8`JŠขpขห'ย+ฎี๎ษJTฏš;1PZเจ๘fอขo€ลŸนตeS‹|ึ2{รbฑผ=“t=๎gH๚,๓ A๕$psŠใ๘มฃ(PVœ้ ็สใ6› €อf{<๖ฦ‘'hุอๅpใŸ“ X{—žgwปT‰q6Uี‹ว$E[ห๊ƒ๏zpŸว้L– pp^t๛@s„š9๐ธX—อF„หE,็ศe"อFOญWŠx$ฮP~ฏศๅtฐE.€๓ี ฃ"…8ธ].ฎ8\@’ซูฆŠฒqœ ‹P‰,ฆŽa8Q~ัฐHM†qWDฤ]u๘D๓…|‚K๋/!~Ÿ.[5 ย๐ศ‡ีณUažช๓"ี‡ช{ึo{๙๎๑ัalR7๙ึ ๖eม&๏ชuชœ›Sลlฎrโ้tuuดิึสฏอtTUœ>Mšฤ่kฝX๔ฅฯ‘+ey;F "?`™ฃQฒqR6๑ฦtWEE{W๊ถๆ–ฐฑ“ฦ)%๒ุhiะ฿|ฐ2ฯ#ธžq3^Yฝ๔ลทŸฝ…ฒ๑ฤeๆN?pฯe้่เ+#E$Apฅrฬdบ๘Ih/Cˆ 1วpRจ”๑m6{จ~๓ผnwภ*น[ซ๕.ERฌธ๎ †sยล|ฏ}ัฃlฯ‘jๆภใb}uีโDmz&ษธ,MีMฏอŽEวฅฤ๒Hฬ๋0ี๊Œ^ Œzฝ0!u| ฃfCตร^cฝAš4:#ยัTi่PE๗”๋uู›>+V๖ชล\ฃhำี„ฯmmญา๕ฤ y6Eา๖๎!{บฝพ6<19#‚…๙ผฮฮฦ๊f'\‘’ฃ่)ฎt~eเ—-U:Ž6แšHๆตuีฦa้ž 2Iไฃ’ฎฯฆfอcธLกๆ4|<]ฯŽUๆ๓:ี่ฟฒ]…Lห ŸฉŸZด๑ฉ8eฌ๘ๅใe–3ถุฐnฬ๒U_<,ก[Jฟ]๙ZŒพ4ctUฮฆŽ†0ตดฎ ฃผ’5็™ทŸŠ‘–ช_฿{soะญป– a™ ถ์]มw5|๑๒%9`ใ๕ฏพพs^ฐ๑‰็๖4๗์Q๐y|จxwฦMมส<Ÿ zš๕':ฅŽŠz4‹@ +ฮ๋๔๖\tปพŠŸ ;žอธฬ†สฦAXทแ35่%ํุLง=6“ฎบีช฿<ท… PษฎซMะXJซL๎ล๛้9ฑ`ฏ-๔๏šฯMฯ‰†๖8ญฦ๊Z๋ล9ฐ๖ฑfฦๅžคศษษนบง๒gุ•“3 ฟf\s‡GTYs{฿‰ภ0=s@\fฎ‚q™8วSฎ๋TˆK ฮ‹ๆPy†Vไย"1Agw!ฎV|mฏ็ ดD %๋๏œ=ิ: โŠล"@ Fศ‹E @Œ<‹@ y /@ 1๒/็ส4ฃำ3ณณณฦ_“คtสE7!ห/#ธŠไ๔ ™ใฏ‰— UeˆKpฮ๘œ]9ฝR๋"อป99ปาc5-Rป9'็ร๘ะว ฤณึ~ฒ็เฯฟ๙xํำ“ใ8c—์๙่แ่พrqณ>ฺฝxl/A๐ฺฃfl:ฐoท jซธฬŒ๖}๘@ฤ`ช€@ ˆหษ x“UBปญผจ… ขSRbdmๅF —ฦ'…;+Kซ์ธD“še-ชฃฅj^๛ฉ[ฤxฅคึฦฮbEกƒƒ mพมิun•F“’qQ‡;‡็มฑƒฦ5sWัฑ๎‰ฉ‡ญฒ1ท=ฑ๘้ษK๗=ค`จi>ดymซณะ2หD ฤ0f0ฦb๑0‘ะjlqP>ŸืZWzดH€H*uด4Z<4ํj7ดTส รร0ถ4>5ล0-1ˆ๘์ฟ55}๋39}oœฺซkฌน(/–56f๔๛ูY[R#ตร๓–ๅDชฅ' š]{cมฎuท ‹ษo|๑“?~ู๊iZู€xไMฯฝ๓ๅ~๗้บ9ใ% ผoำW R{ รoZypล8?mๆšฟ๛๑็ƒปทํฑIQ์`ตk็|–—ทc^ขbฦ{yyyyyg†`ฯซ}์’=yy‡พ~๗oe ฯะฯŠ‚่ฐฬฑK๖|4+๛ึW>ู๗ร๗;_ฟป๖ˆ๋Ÿฐs฿ม๗ํ|aฟปœ~7@ †ƒ๑XfฑH็G&›•5~L‚‚‡‹ร‡ ‹JNP๐<›อw{“Uœœหniง"SF)=ตง๊,h$1ศ`„„รQr8JษWำU์ณ_ิ&”ฦอqœtbrqฬ]lT…yGRๆฏaฦ$MŒฯืํดวLน?—Wfฯzญ aัcน$ดxYrแชงLทษxŠน้ด๊k๘j5.ธi๙g›gฅ‚Bฅ2ิ๊} šถ๘Q฿ฎ…ำ๏ธนญ%๊ฌ4aฐฺuฬอ}่*ใW rssss{ฮ๋:ฟ๖’๕wๆๆๆ.๘๚ฌqโVDฯ€e€fสT็OOฝs๑OQ g_็ทูๅฉฅซผฯ๗uWMื!ใo@ #ep\$dห JชญMผ‚ภqœaŒ-‰xร๘ppทW—Uดq#ฃXMๅ=ี#gมR<Ÿ‘ฑ)#cS†6kNตแอ*ฆf Nฯจ๎ึ=ห[}ปnั–ovmZvwช Kn๘~๓Gฟ้[๛o‘G!€˜ค$ใ๏?ž0ป]อฟ\ศIJ’่kีjy่Ti|FŠDฅ’ืี6เN†ษdBฬขหjอ†กp~ํ้wE๕ š๚ป-ปO[}ฎำežˆH)ฤ&'?xขำ๋ตี๊šฺู๎  |>†at๛้c…u6 รCC'<~tขศ\฿สŠIŸ>:F<<ฤH†2๏8}zํ้ำkO7žคXXื๋ `Xลx›๘์อgธkึ[q๓ZxญaMwฝ,า4c8$ซGHQษ"Z๕ตajM\l๛รKLQซ]๚Z/@ำ๎u๏6e<ท๕฿~ึโษqไ€u:ฟ๖€๔ปขภzƒ้พ>ฦ็ฏล:c{o@ #ร‹ฅ(๊ฌ๏ รPฐูH4`ณูXRmฒสฃ?Yeจร:+‹๋ผjี๐œEŒdื)“้ˆษtฤd =v(P$oฯสฺž™z+็2ฉv)มqฏ™q6๖วฟ๑qแARR…]?}‚ ?เZฝM•(จ:xค5vbšผกถภQ๑อšEMนํžE๏ฝlูTy( z\ล  ฿ึณ฿ะ4c{w‹ คA 79%+x0@ .ƒแล๚ฌv‘R-`แ8Gฌ–q-V;X::๘สHI\i„3™@™๕'+ 60ภฦ็c|รwX qๅภอŒˆธ+Bƒฐ„7DDYๅดF๓…|‚K๋/๎กีp0Pณ~หwc“ยธษทNฐŸ(3IฺPญSๅœ*fs•oLงซซ ฅถV~mฆฃชโ๔ilา$F_๋ภโฆ/}๖ŽŒX)หi4Zh€‘กmอ-ac'SJไฑัRb ส ข@z€ฆ†ฦˆฌ๋“ฅา๘็=2ฑ+๊ข฿ q3^Yฝ๔ลทŸฝ…; š1ุ ส„พปฅZฯำ&งวฐทอXฅkฃ€nืW๑4cวณ—ูPูh_ืฌหิโ•:A้mำี]แ!†๕ฑqื๙฿—Xขฉq"Gซ๓๛N7อcธLฮ!ึp0hูปแ3๕S‹6>'ขŒฟ|ผ์รฒ`ฟ-ห ๋ฦ,_๕ลรบฅ๔•ฏ0ภ่kA3FWๅl๊hSK๋๊:ส+Ysžy๛ฉaฉ๚๕ฝ7๗†vมฦ๋_}}็ ถฝ`ใฯํi˜j์’=๏ใTผ;c๎ฮๆWPฯ@e6ฬn:ฐ๕ณVผ๓ๅ}บฯ_ู๑ดูlณdCงิQQ๏ ีธไ`\๎™…œœœžฏilt8eิ\โ˜˜pฺจ7X.อjฌ€!แP ์สษ™๋fธ<šqอSeอํCญ @\ม\ โ2qŽง*ข€„+,พิแฐ"$*แีฮ‹ๆPy†Vไย"1 5‹l6‹ก^_๗‡Kด1VภŠpจ„~ะซ3@ ิก ‹s<ีPqฑ ํq๛šž—†€!แP @ †?่HE@ ฤศyฑ@ ˆ‘G(/–ญัD„แภ๒@ยซAˆ@ 1 ๅถฐ„2•*œK ๗@ยซA8rเ;6gืตIูกSŠ—srv๙’e—Gณ!Aœ1kํ'{|๐›ื>=9Ž0zแฟ~๙ๅ—_~อ>+nจ๕มdผฐ๏ร"งฌธYํ^<ถ_Iฃfl:ฐoทˆ^ษุ%{>z8zเ๙บQท้เK“.< 1˜-@ ผจฑืๆd';L€1&็,’ค?!'็ฺn2ตAยธ๑9Y ƒPqYrvฮ˜ˆ๎ใ(น๊ดฌฬ$yฯ (‘&ำ_fvf๚่x้•pjeจี]ฎฆ๒โ6๐ะเk./n„W…๐JรgS]ว’'S๖'=ฮNrฝNKภ…rฎ™ป๒ŽŽuOL=l•นํ‰ลOO.Xบฯt๒{ฏฦ.ู๓ยPซ‡8อ‡6ฏmuZ†Zqมสธย๒ŒokEA{ืF—„X“ฆถ;_œ๕%ล:•‡I„`ถb"ฑWุmชำy|ชWJG]q‰ม…‘’๘1‰‘&SอHพ„๒b}ดืร€ฆ๛^ ยaˆH9/V5–O‚ืQ`จูิb๗ˆ5SU|ูฒรฉฃ[:ล ฒRo๖4ฎmไ</UP[OUโv]ภaนŸ^,){rt\{ี‘ตmม[eฉVejาฮ|g~9}xCศsญ.9œHตด๑—‚f— vญxlwˆำb๑ˆ๋uม-)ชนเ๓ทึ์,ตŽ]ฒgI๛k;ใ.บN๑วป/ฎฺWคิภ)ฅำ฿๙"ๅ‡ีป–mอ{{ษสZ๐ศ›ฒฉ›Sย้ๆข๋Wo+0€8s๎Šgง&„ ฤ\ปกะ}2๓ฅ}๖€ูฅ9๓WeZšฬืR๚อ฿Wm=ฺ0้ฅƒnเน~–l๏šฝš๙๓ฦY9๗ƒ“T@Ed๏ฅ|ฎยrl๋K/๏ึั] ๒ิ-ฃะึ๊แ;ฟ ฺœmปdฯ’ึณ?m€Œ๖-lx|๎Nœฯ>™ ๐^ จฺ<ำŸ `™ำศช6ฯะี๑€ํ{n“ฎๆPฯ +G~ซะ๙S›็ส๎”_šณ๎}–ouบM:&]cก€q๚ะt…yGRๆฏaฦ$MŒ/ฤ+‰๐Oฯพ”vbๅ}พใ๑œ๗ฝ:+5จโoป•ต}ิป7™YูกSrำ3น_,œvฯบ‰)„Zผ,นpีƒSฆฮdผmลt "๏Zpoวึ‡๎œrฃŸิv<๙า>{เ์x๚œฟ^[๖ฺS๎š๛‰ํŽฅtฉIคฉšึm<’4&๙ั๊ฬƒฤOษ ™2•๙ำS๏\Sิยูื‘YžZบ๚ม|_wีv‰๛ฐ\tฬอ}่*ใW rssssƒนฐPฒฮ_Ÿ๛jtพžมˆนจผ๔่ฃ+H\๔ศตD0รn[๔ื”ฒ7fM๓/ก}๎™ษ‚^epำ็?Ÿ๙๛8lƒ\ฃภCŽ!O IDAT—8ู๒ฤp†+ณี5X๛9B„K"ิX‹กฃฑไEษสสฬŸž–จ„z๚RfณO,a๓ฤ"Wงล_™U แี vp…I,ฐuถ75}จฏืdjฦp๐XตถWSŒปคต๕วึถ๒žo๛}ใwMฆzA ค"ูร๑๑sขฅr€8y์œ๘๘ปฤAŸ๓xk๋ญmuษ’*ึW์r\ค‘O๋žeญ>„]ทhห7ป6-ป;U4eLRR?žฒ๛(ใฯKRR$ม„PปŸ๛j>WUแI&&&T\qเ”ฎขj>kyษ)p๑„ูํjํ็BNR’ : Žc`8!NK้)๔์พข -Vฺแฒ7)ช“หๅdt้‘ใ.งำY}๘pปำ้$ษ`.pvw[vŸถ๚\ง ส<‘RˆMN2~๐Dงืkซี5…œH+]$็๋ ร๗wฉo3~จุ- f{tBข๑ท๏‹ฺ\žฮSZท๊ปš3}™6็๙์รk6๑{ซพF/q-Pห#รRงfk๛๛*F„+e.ฃฑซ7ฑ7”—”””ž(ื[ธqUจ(Vwง™+dbฺู‡cส—}m๖„Qaf}หะw\Mจม7w[My๔|@ยซ@8์ภp€๒1ภุ[ทู๛J๏c(pทผzดc๒ฆษช๖G)€Xขž ๗ถ|4ฦวb…<&%dสฆฏ๒dwํ45{FQษ"€1”่F-๑ๅ“6{Kั[o;ฏ๐ž์”{^~ajIy1ก ฮOุมฒ๗Vวp`ฑฮู่'oฅ‹ไ|=ƒัฃนำ™,เเƒ0Lจg ฮŠล6'ฬ ฏแฐรeซข@๙ˆZจ6๙/ษ‰“ปยไ= N@<5>rJddfฐูŒ›ฎTN– EภOV*' .zฌ อ€ป‹อิ(…rฒR™6ไ;–จ๎YฟํๅปวG‡ฑIaไ['ุO”ƒ$ญฏึ)2rb8ํ๔]๓PLa1%'eoLwUTด‡ะ Ÿ)ชuชœ›Sลlฎrโ้tuuษb‡หๅl‚ y,Wภร#ปๆŽLฅC-dภ%@๖ฆ†ฦˆฌ๋“ฅา๘็=21x|ฒฝนษ•๙?ษRYยไงปฎW๖ถๆ–ฐฑ“ฦ)%๒ุh้@^ˆ@-%qR>้ฆ wๅ้๖`ถ7T๋T“n'ใ‚ุ;W}๖ฺญgถ๓๑žถ๖Pฺ’g& r^โเ rA[>nฦ+ซ—พ๘๖ณท\šhwฤๅcv|ƒ฿oฺ๋ ๓ป8ฎท๘Œ๙~€งNLึ&คฦหฮz๘ฐร„คอ๓š่e‘B!fใN •2พอ๚ ’ฑิŸฌh๎๏ภ*†sยล|ฏ=ฒ]X=๋จ/9 ะPrธฑkโ ฏxแฐรg่t=;N996– ลMu_˜Š2G๋ซ๖‘q7(b๖น๖Z วฮถเaSตฺtg๒)ญาะh๛ร~qkFp^$891ฺๆ—ำญeม็z.-{7|ฆ~jัฦงโD”ฑโ——}Xฦค-ฝe†vไอ๋Zo=ฐa˜ื=OB8 G?]Sํ€€Bห\ฐe๏ พซกเ‹—฿( u‡๔3ฅๅภ†uc–ฏ๚โa R๚ํสื €ฦ๔๎๘i.ะCแ๖U/n?่yดƒoฎ_๚ีฟ›ŠพZ๛ย[ทฟฑๅMxำ~ทRภ์ ส%5ุ๚ู +๙๒>็ฏ์๘mฺ์ๅžoปq๏ๆนฏพ๓ล}5฿พ๑ๅฏท?ุ“ิ๙๓ฏ๕๕3ุ๖‚O<ทง9`={|ž7*1wgSฟอ„št๔ษgถ}งโy ๕สšb&˜ํ;lX7zู๒O๖)H{ํแื๎๋๚แ.๒f๖ๅ ณyใhฏQภKผAฮ#hห›๕':ฅŽŠz4;า†฿ๅ์7ฝN›‹"iปซwVL(เ;Ž‘ฯิ —hดc3Iœ๖ุLบ๊ึ๗Xืจmฯ้9ฑ`ฏ-,mr?6='ฺใดซkญV~ธqนg^ksrr๒๓๓{พrคฑัแ”Qop‰cbยiฃ`ก‘๐ส๚ู•“3ฝือ€ธ*้ฝ;า`ฅ yำสSŽL{~Ÿ0R3{ำ฿Eงm(พฒ†€‹ฒ}ค0ยฏbˆ9งC†฿ ๔›ˆหภ9žjจน8BฎPHxฐ๘R$ผ„ฤeฦ[๖฿ลsพ๘๎›ปwฝ๋หทnl}๙P+…8 tƒศ0์๘Pฟ9B 5‹l6‹ก^_๗ ฏก4‹@ ˆAแœev|ƒาo".็xช!7ฮก=nล้๙€„W@ ˆKว0์๘Pฟ9Bนœพ @ ƒ๒b@ #ไล"@ Fด;ฉN›๋ฎ8VีqA๛ๅrีiืD{jŠ*{v ใ2าิlภ0W}q่ระยโ'h”หตึไ๏๙`๓Ž฿ƒ`?vษž%ํฏํŒ[ธ่:yว๏พธj_ฝ@:/R~Xํฝkษ-ัึผท—ฌกผ้/หŸบ9%œn.ฺฝ~๕ถ3ˆ3็ฎxvjBธ@ฬตฺ'3_ฺg˜]š3ล_ฆฅษ|-ฅ฿}ีึฃ“^:๘็ฦ ž๋gษ๖ฎูซ™?o์‘•s?8yqวณ!bุ3๐ธXL$Zฬณู-–๐€๎่ฐ$b€#6Ekลึ๊โcวK ”R!ซx~~~Ys฿žVภ์ภUจนํงKŠซ,‚ธ(IPฏ‹Pฤ'mU…Gh๐E$F๕ไ'yB‹ไ นร7"˜ล"œ™ภ ฺe๋II9:ŒŽ~ฺ;$ไ่้lmถS PอํฮqBดšฆ%ฤ๑c’$ncsKeู๎๕๛F>สใ๎šLu7ท#๘|ศษ`f~6V1‚(~ผ†๊ cะฌ†“”ฦบญO‡วPเny๕h+ฦ ฤณไˆnU๛ฃ@,QOะ{[{ฑU้‚aฮmตมธ˜Mปืฝ๛๔s[VQ E?m฿๘ตม็Qz*๔1>๋GKำWyH’Eำ]/‘E‘,C‰nิา_>iณทฝ๕๖ฑ๓5้ฮฮOน็ๅฆ&”ชเ„ธj8ทซษ๏ใะQŽDBื1ธ@œ0A-!Zฺhฉร3Z,์`‡Y;ช}lEœšฎ/*๊ R=:#ไLd๚ฮŽa˜/x?อ0Œซ๙TIฃ๋ผผ๐pm5Y>่ก—Ÿะืห=!๘R™€ถดwบ|xx„สSwผผตwŽรX]ฦžƒฯ5ะ‘๙ฮšG๒k€๑fF_qฑAUlฌV+G(dP& ณูmภ๘œ่šว๑พยh|ŒวฮJไจ๘fอขo€ลŸนตeS‹|ึง*,หK๕v)Š๊Q‰ Šข”S_›๗๘ํห๚v๒•S๏xๆฟฺ|า้๏์J๋+ฝ แ†›Sว ะ‹@ ˆหฃCI‰„ดZป|›ี.’ˆฎ†ปฃร'‰R‰fฟC€aAƒ“aJ1วGrธ>€ฮ ู —ฤcKdbŸ#๘2—ำมIธ8ฮW'ŒŠvสS'JLญ‘d๘๒โณvฺEJต€…ใฑZฦตXป๛vž:1Y›/๋ฒ†ลb1ฯ9‹Xผ !R(ฤlรIกRฦทู‚น>ซูฆŠฒqœ ‹P‰,ฆŽก^ใ๑ดฅัOฤjEz'š/ไXZ ผ๋ฒUQ |Dญ~T›—ไฤษ]Aจž' ž9%223XœฦMW*'ห„"เˆ'+•ด]ฟTl\'Šซา๏|0=Rฆะฯทล––œ€ๆ&CTๆ$Ke “Ÿ~์:Aeด5ท„4N)‘วFK ,n๚าg๏ศˆ•ฒผFฃ… ฃQฒqR6๑ฦtWEEะmสชuชœ›Sลlฎrโ้tuuษb‡หๅl‚ <๔s‚`ฑธู5wd*ฒ่h!;ฤS,nฦ+ซ—พ๘๖ณท\šจg@ %๋ค IธภึึํัVซ;F"๒๏ทๅ่่`EGz๔5sูฦ๚ฉ6#+kmา•ื(FIา2[Dื้9ฑ`ฏ-,mr ใวQ๛_วๅฤ€ฃฎจฤเ ˜ุึะwMf2แsYš+ซญณSFฝ^˜:>†…ัnณกบg™ปืewSlฺแฦฃบ[ช๕จJƒNรWซ7ลฟ๘ส?็*9ๆ฿ผพ๒ Œ{7๏ศ}๕/๎ซ๙๖/ฝAู่ฃเ๓ผ๙P๑๎Œน;›œ?ฐ๑๚W_฿9ƒm/ุ๘ฤs{Z:ส+Ysžy๛ฉaฉ๚๕ฝ7๗š‚V–น`ห|WCม/ฟQิJห ๋ฦ,_๕ลรบฅ๔•ฏ0๛ท้?๑ำ\ †ยํซ^~"ะฅnฺม7ื/๊฿‹ME_ญ}แญ฿ุ๒&ถมM'๐ฑอ[bwL~๓จํฺe{๖Kz๙ ๋ทŒ;5๑Ÿ๛ญ€ฑยŸฺ๐_๑‡ื๏aD/ั๋7ฤmรU™jท_˜"7œงๆiฅu(…ฝ&บ฿๗^˜๖ฦ๗฿ฯษ๎ี๙K{.แฮ๙ศดนป~|ึM$ dำล/Wๆ๕ถSธีAcฑjะฃs†%Qซฅ.}uฅื็ˆ บก z 4‹@๎ธM•%ืต;4@ }‡[w+@ ‚”ล"@ ๚(‹E @๔=z4‹ๅวำ^^ใ“)V๗<49yศ ่€ซŒIš4dP˜อวE n๒lH;ผ์o,ชฟ%พบณวป ”O๚x฿’$&€$qฦ๊m๛=ผ๗‹ี/Žาะํฟ`฿ึวีะฬุบg~ผO•ธ&]ื‰‰>ท๙๐แืG\–Hfพ๛ๅพCฟ฿๒๖?b๘oฆŸ-ด‹<ภดU_xไทร{?šูSN๕”}้ บู๎ิงOูp๐ภฟ๏_ทZD฿€ฅŠ!ม@64>ˆrฯn@\rRดขหนDt๒‚ใ‡„‰ฎำgD/ัƒY,ห_ศpต-.Žหยข์%ูนีd`tฐ€+ เ5\ฬ(ฑ)ฅฮdขม`DOƒณ#ลโPสD๎vGจ&ส/ค฿Uเ่ฑGf0hึใ Ÿ<7aฬฤื๒โลQฒž๒๔& ทtW_อ จซm'ไํๅๅ#Š?˜9้๓ทป๛๗ำp:a/ะ.๒อพ>1[|๘ล‡ฦ๑ฅ?•๗ŽKท5l\ฝ๚หำๆ๖qcแ(”œ†zS็๛ร8ห‹‹ซM]•ฆK:}ปZใตšW_Vใhˆe2[m•ูๅ๑8ช๋A&ใ $†a€a[ึ?๖๒ึฐDม’??`ภc’;ฐgฑSด!mQ4DฏU„Ž|yŽ‡์฿๑๊~gยVิcฦส<๏NP€ฌ๊BFรeญสุึำK4ย•รฎWŒษaŠ{^vเศฯ_{ผ€ˆ™ำาพ~6J9ๅใดดดดด–ณd“ื~ม{}ถ๏๐กฏ฿ญ™v๖v๕ศํ}.น๕uฎพwแ‡;๗๕เwา‰N* …'๗4๏•YMํ„C๎YรWg๋ญ–Š#;~๑ŽI#๑๚แ?5~ู–o?˜4dิยอปพxf๘qSW}๑ใ‘ฃ‡๗l๙๗ำ#‚ูtฦiฤƒ๎]ธ›G๘ีš™Cคด‘๗dsZฺ‘eรฯ~่่ัƒk'(hCGก“ฦy*([3~มพญ3Rฦผฑmก_ฝ5.ค๙ทDูm(Žฎ๎#_^ทsกƒ?|๑ŸวัxQŸฟ`_Zฺ฿๔๏งS„ญ%iชIiˆ2tˆ[ฎBษชฏฟฌ‚ฑe๑I)Iƒฃy ชีญ–\J^64>XขˆŠOJNJˆQ๑1Ÿt๒ีƒตฺม!|v@œVซีj[k1Ž,|@bRJ๒ะมฑj1ซƒกมัJดนu/ำSwz^PจR^ูิ๖ รไฐมๅ"Eม1‘Jžหๅbณูเlะ5IbBูต DPl?Wูลr๓-ผ,ังภตฮงŸ=}ช.Eึ,Ž~yi์•ำภฃKvทnM)l%r์๖/‡.’ฮsiงbgฏ}uสˆpคื้@Fศ฿๋๋O>๙๏ŒจyO co™–š:“BทsRSSSS/๏์ลMHโ๎š;qา;ลรงVเ 3— หY๑ุธ‡fmณŒ_๔Xท$6็xtูษˆ…/tฆณึฃ?Ÿ(ณ^!“(ษzฝ+~ฦ5.T_งW*•4BFœJทๆรSัณงฒถฎ<@3\ š8I๏๎น“ว?บpsV@rœา2ะ๙)=qฬนๅำฦMxvƒ~์[ณฺ฿iGพ๎›็RSวฝwฦ๛๋ฒิิิิิ–-‚)BGฃ“สyŸ;†๙ๅ์ อ๛=์ฅ)8Pwส†ฃซ๛หฏว]x๛‘ฦ?ณีศ›3๚๛บฌตฆฆฆฮ๙ส=ฉชIkจC่ท$|ฅฏฏทด›ซ เ6\ส:_hh‚ฅ4•žMOOฯฉนz9lžฟ?C—{๖์ลฎ&ุ๓Eงญ๒|z๚๙ ›ซ&'=====ซฺ EXคภ\pฬู ๅ.eดบu. Oฉฤชrฮœอmไ…5ป„่5z&‹e)5dUYCป๛!Žใ$IblXฬcควqgCQ๖นฬznP0S—ŸWm๑๔ˆyขฎ๑ฐฐ™j™@ฃ๖ฤ—‰<ๅ์จจ๙ํ›ๆื—ๆ%`ตƒ๓า3ฝฆ๔ฟZm„ฦD๋Oพ`rป-eลบ–๙>”ยŒํ๔ดฎM€ใธื๋ ํ•ว?๙โุไง4~๐้%ฉOoSรdบ‰ึไฮKzq์Zƒจใๆ>j๛d๊ฃZผฒษ๋wว5K ‚ธlˆ๏'ล,Vw—uRbึ๋™ …ภ J…ฒฎNO#TR+ฐๅ๏]5o/ฐฤš!S—ฎX] –ฑp–bฤฝ‰ฮ‚KญZ๊kjE๑#๛KกjูๅO1ฎ„มdr<8๒Aใ“mrตZศฦกฒจX5bฬ`9‡%}p๙๖cฤพ่ค„ฬ๘3-๊กi 2พ@}๏ฃฃ+ขR‚i&/zy|bจŒ้6้๕f@ง๓๚;๘YYTฌาื_ยๆ๚ฟ'มSTิ’wˆผะ้์"tญ) ๗gใ,๙๐{๙๙ @mจŽฒ๎EลสDm€1๙_ซฆวu:f|M์ฃ!อ”7V.zํ—๏G้dxQ1‘รไํฒ\ช๔ณ้ฎ|ฟมเpY`lฉ\โตY}~ึ๐Aง้dŠค"6‹อใฒ0pุmฉ\ศฤqถT&&mถ–’ .Ÿฦ’สฤซ๏.!z’๗ทงกดะ$2d@0ฎ+จฒ€ืใ!ตyก‚๚:ด๐โ&€ซyl็แ๊F๛ต ๗IZmLNv^หฟฌYู5รด๑4ผ;i7[—D}ผๅc}J!๗ฎ1รsfธฌด๖งu ร็}ธ๛ะมoึLr}ฑ๘ณ@ำฦฏa๒๚][ลf์๙ณๅ๔’C[O‡พดๅว_~ฺ๒ผ์ง7>=฿๚รถ๔รjํv์ูฑ•TšNะ๘tฏ๘…o}ฟI|ืซ๏ี>ธ้ษ*0\ทฆp๐าm๛ํ๙๐!๛g฿เ‹N€aKฆฅฅ}?o๏wำาา.`ฟหฯฦ๓‹ฝป๗g็ฒญ๙^ Rbศ+`๛า๛_๎ฟsอฦืิ้ฤุ~šฎ[Sšฒ|ืฯ?~RะoošAาDhtvสึQาœM?้๓ูฒ}หถd‘@mจŽฒ๎Mืญญนwํ๗ฟแฟr2ฮu:ฃร้๑ ๖ฅฅฅ}ใRCฎ\ttŠย††ปrš1@๔Weชwเššˆ;œงๆiีu(…ฅG๒cโOJCWๆ›Š<LนRdิzt๑อกqkฦbิ^cฑ่5ะ ัS ฑX@ DŸeฑ@ ˆพสb@ }ฮฒXถŸ:<ฤ@ ญtถญC—wพ\๐ึไo— ป%Dj˜Mบฝfˆ๗˜/บ้…๛๖ZGƒfฝ=ฐๆน 5ษŽ}n‹ฃ2ํง^“?w?Fฎ‡๘๛^ฝ~ีฑquœ๙ฺ%๛*๔๑ผ๋Ž@ ฝIgYฌืใv‘เ%l=@ย๎ร8x=^ฒํเึ๖ กฑj 7Aภ๓<—นrUพฎG๏-UถCN๎WQ~ร8?๊œbqะsš€xำใถžช*๙ฌฮž“ฒ€_JfE9$Gฅ,ี.พDsPซ&}"๐• Xช฿อซ*่5 9Aฒชc5Te์~๋้=อ›ฃโ#็-™sฌ”จษุ๙ชูดอP–ฤี๗พฒ๘๙‹U2LฟmZ๙แ oฤฬํf†|œ6 7Nฅ[?~มพ'ษšหqษุ&\ะฐb‡f๎ผTฅ๙ฬๆื—ํ)ฆyสป\๒.…แไGฏ-฿_แM^ฟ+๖—•๎‡ฏnJ{มฟิเA๗พฒ๔…๛b<5™{ึฎ’aคvžฆšธฉหMOๅ6•ค๏๛tใื'ช\4ย.CYw*>ฤ@ WะูซnพzPrrฌ?๘ม-Hx'๛bนjจปแO ้/ ™(ลฎO‰รๅฒศูlภฅOล„gฉจ8MFEฤL5'ฐู \๚T\์Cฦยม้จiถฎPมŒYI™X ฿uZ๏1œ็าNลฮ^๛๊”แ"Ho๓‰p๔หฏว]x๛‘ฦ?ณีศ›3๚ำžOYR4v’ุœwfLxเัe'#พ4JPผeZj๊๔O ๕฿ฮIMMMMํ$ๅสZ๛`jj๊œ๏ฏ7ฟ๓ล ฮ-x๎Swuถอ}ุุ1ฬ/gOxh๏a/อHiฝ\q’ธปๆNœ๔N๑๐้ฃี =qฬนๅำฦMxvƒ~์[ณ0็ฉซฉš8I๏๎น“ว?บpsV@rœVุu(๋Nฅำ‡x"โ :หb=vณัhq’เqด แ ์C45Vlจาํะ7เr๖u็เ$ €c\a4,†๊ฏtบฯkฬ~Bฆฮแœ-K๎I‡‰„26XN Xห?จจชฮ€I˜ฝPทo๑ำ+ภ๎šทi๏๎ ‹๎/‰Žฎ?yไขีK่>+•าNYRฅ?sfฝรeบ๘šๅ?–๔ฬ ๏า7ํนิไu\สศqษ:)Yvเ๓%6ฏฃ๐\."o‘:2,ณ{›๒ฒ.:€ำ์ผฤ‘ Fงฃๆ๘ัsœ่h9๓”ีฤ1œ%’ห…˜น8U๋~i:a7น:โฮฅณ[ฏณพ$ฏฺ๐rtศญd๓ ปมP kV…แ,ยKA’ภยq›ีั’0?`ธ\กฌ– 5€<^’๐4;ัCฑnษํ๏ž๑กzฤใK_on๕ฤีฑXฬ Iซท"€ษuT็ฐ้Nฆ,ษb1 ขๅ}ฟต่ฤŸ=ไ(ฺู‚^า‹ceฦํK2;<)่พ}ๅ๙V็=ž? ‚`1Y@ใƒๆบcืส6…BๅCมšE!RŒดœ08มa)๒€ะ/่๑€ภงT"Wกี .GWr… ฆK[Nใ–œxกšดvหฒ‡‡จEl–P3jฬP๋…=@EQฑ2QยเDLืช้qด“P)KVซFŒ,็ฐก.฿พbL๋šQ๕5ตข๘ƒฅŠPต์ฎR& ๗gใ,๙๐{๙๙ tล*‹ŠUฺ๛๚Kุ\แ๗$xŠŠ๊้œงช&ฆ™ผ่ๅ๑‰ก2ฆคื›=^a7กืIOอ”7V.zํ—๏็v2@–`\๎ๅ+คVซMOOoW ’$ แ ุญีNพข3๔&~๕sกq<ฆวm=[]๚iญี!8(ศฯํ4โ,กื‘ฉ+๙จบษ€฿›2G๊แBๆ6 }บ้นณŸ’คงัtดผd—ั้J‚ŸU ไ1ฝnู๊าOj-vเM๚™ฆ— ๚cึ~๐Sก€2๊Ÿฏ=?2JสฐWŸjีสo๓7ฯฆ)สถ[>Šง* ŒQ ?{Oฌ’e-๛๋หี+พหky4`E>ๆ›ฯ a[3>|nแพJ—ฺพำo&ฃ)ณv่โ์[P7ง๙ฆฤW๗ฯญ|fึ้๏eตŠ๙ŽสŒ]๏ฟ๓u– Zึ(ุ~สํ‹2BFs้๓๗ฦH=ตู?|ฐb๓ฉF qžขš˜8nโs3' ‹ ‘3ฬ…~๑๎š}….J!uไ)ใIU๗zT๑”ณxำซฉถ=ฏ?๓iV๏.€@t“[๊†‚่ำ\•ฉv–ลrdกj?B_Zํ„„๘y๔ฅีfยfn๕‹ŽเryีžL4U๚BN ํศขoะ>฿E }˜[†‚่;\•ฉv6ฃ€!๐S*ฅ< ˜|Y๓ ยพ ฮSsˆด๊:”ย"q{ำูX,ฦ`ณ™$แt{[7sญ@ ขg@Y,@ ข๏ฒX@ D฿ร็,็)ย$ MNIJ ๔qฝsQุะ๘ Ÿ—๐‡' ไ๘zV฿‡?L›้wbLaศภ”ซ‹Q ;€q4MNI20สŸ฿็Ÿi"wjตป๗I˜ˆพ4๗๑ฺรขSnž7IโŒี๖>zx๏ซ_ฅแฤ/ุท๕q๕ณ™๘๊ฯ ์ฌ„fฦึ=๓ใปค,xส†ƒ}๋ฮ 0`๎wวŽ;๖gฺ—34=้RC๔๐L[๕ลG~;ผ๗ฃฉ‘]๗มgจฃิu?ปฮอชQฎฏ5ฏภ‡พิB:ั /8~HgทŒก&qุฐaรดฺมมผ๖ลw:๛บ‹ Ž*2Œ˜—•g#นสจัAM็*ฌ7ฤณ;–ฟ&แ๊|็IฎdD ทZœืRยVEF๐๙Y๙6เฦ๔๗7ๆิ๔ญ.อ&^cK5์ึ[sทุม Yo7ฌynย_M๒cŸ›โจŒE๛{)Ÿจ๙cใ๊:๛นถ€sืcไzˆ_ฐ๏ีlˆ๎฿ž˜->๘CปtŸs๓ปR—์:ฝWฃึšฤmCเฏdjŒ7oKูนฟส@64โโษyึฺFGnโโc‹‹ฤยฆบ‹›ฐีึBƒฤฐ:Yาะ่0!œMตฅ…&7ฦ•‡E„ศ…lp[+ŠJ๊[6๎ฤุฒˆ˜mฌ((จต‘ภ‘…E„*„,ฏำค+)ึ5ะ&ฑมๅ๔2ผm›๛0eƒ"<ตูๆ[r'ะž—จีผ๚า~ฟ“RnซA_Vh“ฦส๘ )mˆ%"KE‹›ฐิVT`Œ`ฝXปtฒั^ณำบ?B๛Dเ+AฐTฟ›WU ฒฟŠ _ฌ•x~นxz“ ฤโ g5ƒyLหrขฒไ๓z;’9ษ๏sUญฎโ<&S†อ ฎนทm/ภ Uหจqธ *c๗[O๏iS๓ฺง4ต้_o์-๖เA๗พฒ๔…๛b<5™{ึฎ’a๔dรGŠM๙๘b๓)๘ฝoบ๛่˜ท~งผฺเ#็-yแJจฏs๑ํ฿\ฮน?VJิd์|oีŽ์&ˆ˜น}ฬP€ำฆ@&a2ํ์ท^™'๗ึf๏๏๒อง ะn—ฏยSธd์ฌข†h\ข‚าP‚} V์ะฬ—ช4Ÿู๚ฒ=ลG6?oภ฿ถšบ๑E่ e;ฑ_VบZpฟบ)ํoR;โ๕รTญsœ!iีOแณŸ?๕๖ฌOs ŠบSG‰: Tึฉœงฌz7kDP~ิe‹ฆ'‡r›Jา๗}บ๑๋U.š6๒ก5ี๗พฒ๘๙‹U2LฟmZ๙แ /M_๊vgh ] รษ^[พฟยKSwส(Q๘IS#ส(Q ๏Š~CUฆฬๆA~hB,V˜QfกฮX๕…ค*\ฮ% %y…๕N†00*"Hยล ปฉฎฒผฺเ๐M"ัE๘๊ม๑j@œ6lๅ™Yีj๋e,ืgฝœ+SG„๚บ‚zฺ2T™•(lhธปฐšง ๓cปe๙z€(lhธ+'ซฺโ๐$#;[็ห‹*ฏc๘ว&GH[Kx๕yงŠŒ el’ฟ๑\Kk† Žeg”RโnFX์ E]Iฉฮ์๊ฉอวwศL&หKxZKฮๆ๊œbu„คฉ่™ณูี„D ฐนจ",B`)ฮ:s&ณภศ ืศ[&p•sกา,„fa„ะR˜y๚๔นZ{ป๊ฒxB“ลr๛๋๏ฮเ…ส-ๅ•MืhgตQoด{บ ค‚ษd‘mญI˜k* ท`rๆ;ช€ุ ‰‰7$Fo๒"Vจว`ฦฟฌคLฌ~ะ{งลง\`๙นธxCqษv\๚tL่p†้ณK๛ฑ‘Qฺ^ฏpc„๖฿๊ญ8W โ–ึy.ํT์์ตฏN.ย๔z[๛NศธGรŽฝ๑ิŒ‘๓žNe€p๔ล1็–O7แู ๚ฑoอJภ ฎด„€ ๎]บ}ใŒ TฉชหJi˜…ฃ_^ฺ?{ๅดฟ?๐่’%D›๐๕ธ o?๒ภ๘gถฺysF(2-5u๚'…๚o็คฆฆฆฆ>๕U%ž0sษฐœ{hึ6ห๘E๕€ฌตฆฆฆฮ๙ฺƒวT†จ]ข„ฮP๘ธ /NxpoมsŸบ‹P๗อsฉฉใ;ใuYjjjjj๓6นกk†›ฤ5wโคwŠ‡Oญ`ฤฉtk><={*k๋สไ=ร5ิuงŒตŸtึ;8OIทkD…jโ'ฝป็N่ยอYษqBฺ6ข„ฒคh์ผ%ฑ9๏ฬ˜๐ภฃหNF,|i”€.J์ 6v ๓หูš๗{ุK3RZo*๊N%*?ฉ]ขŒฅ๐ฮภc0˜R €#•0  ะdธXยะๅž=Wl—)ธภQ…“5นg3๓*ฬlI๓ฬFฺำป„ญ๒|z๚๙ ›ซ&'====ฝ9๙ฃดN—ฑtร:`,qPฬ XฉหหพTkฃญคหฌxJ%V•sๆln#/,XฺR”yง./=====ฬฅz—ณพก š[Sฺุš ำุH๛ะJ˜+/f8กq#>NHฅรืT๐Šุด)อฅ็sซš^ำุdgฑูภๅ๓]ฝูๅ๕–š’ย:[หฉN}y•ม๎rอ$‡ร_เ2ึ[<@บ๋M,€ี,t๊-Iz์ถ๖ใฯ๖ฺยขยโ๚xyS–R@V•5\ฯรœ/ด4 Cู/%%%eุฐม!‚l๑fะุPถ๚าฅี—.ญพT™ฺsฌๅTTUgภ$L&ธšจk("HgV]‘บ๚<Wอ„&S&ใฯ ภ&~ปพ.ญ๚QืXภc๔ะฏ‡ฉท๘้•`wอดw๗†ล๗omห๊Ÿ7n=^ZWu๗LW@  Bขฃ๕'Ž\0:5วžใDGหJหชšea‰ฑR•JQ^VEc(4&Zโ๐“m)+ึต …DGืŸwKถมaีส,W(>V“าฅK>Q๚ใฆ=—šผŽK9ฎภ Y'ึ;„™–ูฝMyYภ๐dŸ:๋ฐํEี`ทY,VOิาz๏nจภ1œ%’ห…˜น8U๋~ilัูตฮ@]Rฅ?sfฝรeบ๘šๅ?–ะฆบ฿ส|พฟฤๆužห%CBh๋N%J?)]ขŒฅ๐มc0XD ภ”J8FcM&เ5ื๋ํ ,fซท%gม0&›ลยfฌ).ญwwzz7้`.c้Žuฎ*v`(วX}ฑยะ๙๛vบฬสฎฏิ=เต™,$uงฬ๋Z`ษยรEฦโ2ฃ€0,"ฉ`JคN’X๐ุ๔%9ส์’จAQ2_็ดRqตญVI้๔ŒR*1C๎ฯวฝ^`rภิ,ฤ0Œ$[†ƒ<6ƒกตp›$Iฌต$G;X๎œแqXฐซNฟยfะบ่p_$TnHO)฿ ะC?C๊(ตตฆGŸJโฐ!แิ๏c8ฆSถซ„/Ixš+H๗œŠaL‘2fซœŒ\F๋ำKเฌ}๓tF๖่คžฤญ;น“;>Tx|้๋๏อญžธ๚/๐xZ๘<Žแภb1„Aฐ˜,]i™hDธ& แื_yQฑ2G้Otำฒ˜ฬหงทมb1ƒ&ญ>Š&ืQรฆ:€;iูซ"Y„ชเŒฏ•ค4D้’Oดu}/้mŽ๕กปทฏ< ข<ฝ๛uงดE็}าูFkจัํY๓Q่‹ 7?ฎ"*3๛๒ร”น}่ ”%Y,&Aดธd-:๑gงฮwณ3ด“y๕ฐญ๎”Qข๔“า%ส(Q ๏ƒ]-‘-˜๊MอืeชL =ฮš‹šj‹หนš๐AฏรX]VVo';=.OH๗a;ฑ6๋tKwฌ“$Ib8†]{ •.ณ๒๒AW๔\สผX๒๐paCA–ฉ๕Wๆ2jฉŒ,ฉภจ๏สTO รqข}ษ๋ฮๅฎี^ฃQq3XKภ"“ƒฌ็sešOEfฆมCฒ$ถŒค“$ ญกฤ,&nuๅH’tิ\ฬชr\!„vง_ั" žŸŸภำิhvzฏํp_D*as8‡ต~Y+ึ +ฯŸฏดƒ/“ <ๆ“ณฃฉฃ„+ฌญ5q6›ๅด)๓ฒ€๔’ฦlํฯ@’@SC๑?+Z&ฤUทฏใึ}€ใธื๋ ํ•ว?๙โุไง4~๐eI‚ ๐ึœม`eฅ–IษQ‚ยรTณ†วq+ณห้ y<žถำqoำYอย*ฎ.}ubๅ?n๎ฃถOฆ>๚งล+›ผ~wœฏีค4D้า€2t]†พ๎]K?ปgฦ่ดๅ๏]5o/ฐฤš!S—ฎX}O”u5\$B[ิd(jพQfิxฌตลนตล“' ŒŒŽ๐7็ิบฎqzว›`วด‰’~ใr)สŒฅ{ึuyla‘ฆŠโŠ; š™†a–4—.‰๊ l%U^,EDฟก ะ๎^่4ฑRก˜%47^#9a Tšˆ ^SๅฅlU3ป˜ฮ]ีp>^๏ฝณEค ฒpœษWฉˆ&‹ 0 c0‰ณDŽ—ลแ2p vวO!bแํB)ื IDATƒ็=8FA;t์ฐุb)ภ๙‘‚„88ฎฤOภb๑d!Aาvฏpyัขข„+nอืบ=€ต\z gKอ^}~zs ภ ˆŠ‰ˆ์&๏™ดทษhฉ‚„lg‰UbsฃแFฯaธ…ส‡›-ฆpUฺ=’ aAใ‚‚’8ŽฆDBiŸ฿_ฑ|@๔฿…}g๖ตjาฺ-หขฑYBอจ1Cญr๔4E+‹ŠUฺ๛๚Kุ\แ๗$xŠŠ๊ ถฌL1,ษV˜้6bYJ?.คซฌ L#“…๓์ร[&.T+ต!Nฤไญšื:คW_S+Š1ุ_ชUห &“+เแภ‘Ÿไo“ซีBถ/Qฆ4D้า€2t]†พ๎WG้FXฟ:1อไE/O •1&ฝ์๐B'ก”%+‹ŠU#ฦ –sX‚ะ—o_1ฆuฉฑQ๊~g…„๛ณq–|๘= ŽŸขD้'•K”Qข€fส+ฝ๖ห๗฿’๐{ งมเ•ซฤ6ƒฑ%•กฬ(แD„๙‹y,œ$\.š‡!บ~:-nง“)’Šุ,6หขอ๛( u฿:aฉ)ฬพXๅU๖ิ/P@{:]fลเ๒ู8`,ฉL์ฑZ]เt:›“(พ"4ุฯื„‰:ฏถ2"ŒW_Tnพ2Wต คD ถ6š:Kb™’ƒ"ลถา JฏNaฏ_g%8jŠJนแQƒีl ์ฆช‚* ่+je‰ษa๎&]q^‰ฒ฿ภXศฮั้K‹‘ƒ“ุa7V๋้s๕ฅฅยศCB˜˜วiฌ.ฒyภญฏจ–EH ด้ ช ชหธV'ม๖ุzvญ†พnq,ีั๖่%HŽ๕o๎žดJ๐ิๅ.6R ฉ๔9k ‹9‘ƒ‚8˜ข/.ขoฃพ„X๘คคๅธฑฦ๒ ].ไ้Šย,อสวฝŽŸšชฯ8Ÿ็—แš€'clฏซคฑ*อาwzYํO๋ถผ0๏ร4bBŸ์‹ลŸๅะฝุ1\ทfเาๅป—zjณx{E di„,.ด๋ •ขY9ํP,4ผ๎ทึ๓H๑ฮ7พ>>๑)h:ธnํภืึ~ฌ”aฏ>ีชขึพd?๚้‡#฿ฯŽ)lkฦ‡ฯ-ง;๐้‘‹พ=4ฟ1๓ีฏพ๗๗w6ฝ ฯฬษyฌๅ“|€iณ[>Ÿ›ฟgำ%|๖lหg้”†(]ขคํ๖†บd๊ะu๊บ๏ะuŒR ฅŸณ~#j†ผๆฬ—!Dฮ0๙๑ป?5Mg่zkšฎ[3`๑าm๛•,kู_Ÿญ฿š\vˆR7;ˆ’ๆl๚้-พฃ2cืฒwฒh๋N%J?ฉ\ยจขD)cinฅIfหฏธ}GblSไ*m๛2 ฤmฑbjMl(…นmeอูEืOงลำPY&‹๊—€yฬe๒๊จ?wฆ4ิึ€t+๒ฒ 6ใ๒SM๋”™S:phร๋0้ Š›\uๅี~ั์ตลบF zณยฐ!š|kCZึg ฬ๋๊$r?&โRZื(ซมภ ฐvšš2n]๎ƒณG๏ซ—{๙yOซี†/่ืลnญv2๊ โถ%~มพusš—;@Xz๗†B™ด„็ฦ[oฟจึอร0ภ9ฒ๐น!็Rร๕Žฐv= W•์‰/ฤ@ w yฬะฑZWZp)lw@Y,@ ๎@ฒึ>๘To๛€@tŸฆาณYฝfSŸชf่_7}็ใ@ ข”ล"ธmกœpyำพ๊]๋}…๋สb@ }”ล"@ ๚=“ลโU๔ !ษ))I‰ฃT-๋๕โ\y๘€„ค””ไ!ƒข8p•1 C“† “ขฏส> ฟ:hศ—))_$ฦฝ(‘๗ภ๖zTB7jตŸ…‰ฏ]๒V$๑ีiวฺ๑ๆ7ว่g^)“O๚x฿’$฿~โๆ~w์ุฑcฆ}9Cำน๐ฆข™ฑuฯ๘v‚๘๛ถ>ฎฆ-฿s๔@;8MจZณWี๊*ฮca2%aุ|ฑเ๕F/ฝ‹lšฏฮzแู/ห๐˜gฟXธa๚๒ใ–๘๛4ฌุก™;๏.…แไGฏ-฿_แigฟ๕สฤ8นท6{๏—o>m€ๆeแ›Kฆ*อg6ฟพlOฑ9oษ ๗PB}‹oๆ ‹๊1ce‡฿9฿ฃฦี๗พฒ๘๙‹U2LฟmZ๙แ /t๏+K_ธ/ึฯS“นgํส-”หัWฉS?ืˆ7uูข้ษกฆ’๔}Ÿn๚D•ซล๙9๗วJ‰šŒ๏ญฺ‘Dm&bๆ๖m3C>N›ะฒืฆธ็ต,บOikำฟุ.่์ฆK4%)‚Lใ<๕้ตf{hบอไ๕ปbY้~hม๊ฆด๗ผK-MSw*—(ฃD)ค๑ณyณยSธdผฺ๙๖=น๋ํN]Mฺxvก5y๗ฏ>0๙ฬ”ู฿ึ@ิ์k˜+^าy l๘H๑ฟ)_l)p๏‡๎>:ๆญ฿๏ไ›)C$แโ„TWY^mpx€# ‹UY^งIWRฌk"€0 QP_Hชยๅ\ยP’WX฿|๑fส"E๘yj ฒ+ฬ>๏‹gฑธ%R41%"‡ล"์h/2E้(๕ส‚YuEz~จZd*ฬฎฐดi!F“•้ฯฦ้๖๎๊Up‘XุT—cq“ถฺZCh˜Vvุะpwa5Oๆวvห๒ ๔Ž+7b‡'iูู>d€/ ฆ_ฐQHhื…Kz'M“๔ศŒKEV~]๓…ษ็ฑ ย ภdฒHœ3xhr๒‘Jเlะ5IbBูต DPl?WูE”ย"ฎ‰ำ^้‘"|qˆ`.รใvท^!@,W u7i!ฅ!ฅฐŸ Wญบ/*ญ|ูฬ๐€ภฅOล„Žเ8ŽTT้โŽ z˜€KŸŽ ฮ0}–iŸƒ?62jฏEงPtnษq`*ฟะ‰อpc„๖฿๊ญ8W ขื฿i@ิ์i-|9Sะxเ_’อป"p๒ห*>Zผๅr6v ๓หูš๗{ุK3RpRๆ‹4i๕๖Q0นŽ๊ถOึ อyวำฎ๋์ฆK”%)ƒ๕ำ้[“‚ŽAพขv฿พ๒|ซกŽMLื:บD%JกOt์ษืG๛jR6GW;Xใ๑ดา™)ฑtyJฬฉรg้Jg]i™hDธ& แื_yQฑ2G้O>ฦใ๖กนaตลๅ\M๘ภ Žืanฌ.+ซท“€aG;X๎œแqXฎ&tึ\ผp๙_„อ ฟาj4๑bUูn\pm๋ํฑUœฯชvฮ–Eฤ๕ฮ;_e๏คpoA;ฯ‚ผ|€aดี์jHz›ฏ’$ฝk\ z"‹ลUฎ๒ณyuํ!ˆ+]#I˜ฒˆ{In)0(ุTp8D%ญ4ี๛<qGฑƒ8DตรScึo+็m` ’sล'œ ยKฒd!/๚ 2J.|j`Œ‰8ฉน้u๐šŸw9ขTณึb, I ฉก๘Ÿ-ณึ„x]ึy^ว-N“8}"'ง4y๚๕ฑฏ+ฏฑ1™L7แ๐7๗Q'Sำโ•M^ฟ;ฎ…oอ๙qผ]6ภ:๖ž๊COฺ๋A\.ษ๗“b–Fซปฝม`\}ฅธื๖ณตFถฝซๆํ–X3d๊า‹'dฮ๙พž ˆ๒oฮุVั%k]หw|ะู=—(KR™าyสำi[ณS.™ฦฯŽMLื(๊N%jแ ขํ๎KซK;^?%%6AแฤสNฆีS๊,+ตLJŽ> š5<Ž[™]๚Aไ๗ลฺฮ>M7sธฯCฃ๕ํƒท\C<ึฺโฺbŒษ“FFG๘›sj]$I:j.fUu๑c+ฯฯOเij4;ฏcTKcฝ•ใ68 ๅ5•uม5ดx]F“=F&ภม~๋Œ3XKา๊™d=ŸSำพ†a–็EZำู–฿  ฐ'f0™Lาๅบ๊Vไm2Yล&Žs$rฎนษ „ฑ47ฟฺโ 0’๔zI/ %“ทL‰zUเัแOจC^ Sส€ธ`n๙*R QMR<ก8‹mŽaเB6W-–๕cx ๑ุ ฉฬa)$@่๔D@ภ“1ฏฤDโ8š  ฅ |~Uฤ๒ัถb‰ญ:‹ฌ4:{/พยˆ~bม๐ณ๖lฺผฑmŽ‹Bยู8K>žG~~ƒษไ x8pไƒฦ'๙ไjตMsuะUV&Œ‘ษย๎y๖‰แ—/ส,ํ˜‘…‡Ž4\.YYTฌ1fฐœร„>ธ|๛Š1โก๖พ6ื๘= žข"ŸrZ?;ิำL^๔๒๘ฤPำmา๋อžๆฏ%*ŠŠ•‰ฺ'b๒ฟVM๋t$ธพฆV?bฐฟTช–ัฮ้ฒฮ๎บDY’2ศ”ฮSžNืš”t25”ML้'•K”Qขขํ๎SซNKsฆฬxxHaZzg#€”:kหสร’l…๙—.a#FฅmCำš)oฌ\๔ฺ๛/฿+Lีฟ18,†ŸBฬฤqŽB.vY,๐"ยล<Nอ๙ ป-–rqœู/Hุiสร ˆ๎5 \q๓รHsEn~อๅ1T฿ฌ†s$|ท๓zา่ืbถˆTBŽ3๙*•ัdi~Rbp๙l0–T&๖Xญ.p:\‰Ÿ€ลโ+Bƒpฃ2ภ™Q€ฎŒี^ž.ุp)ฝ ัY[Tส‹ˆIa’N‹พฐธž€–aGcญฃ_ก๎๚โr4‹่ย\ฝQว|X!'รํN๋ัาฒฯ=อOดS8&ิO่uค——|oงญj›‘H`ิ Vึ jb‘ %ี•[/Uฐ5ฃBC็y]๙.# `<ฟ ื<ฃ`{]%Ui/`๕_Ws.“C#sปญฟ—”~gงR'ํWไฝJิ์iณ[๑๋ฒิ7žฒ๐แ๊ฯž8็hผ๐ม๑+็hX‘nQาœM?ฝลwTf์Z๖N  ;๐้‘‹พ=4ฟ1๓ีฏพ๗๗w6ฝ ฯฬษกฒาxp๓๖ป฿Zอ#ล;฿๘๚๘ฤงZฤปฦ ฯ=๔ก]I๓มuk,^บmฟ’e-๛๋ณี๛Z„—.฿๕ธิS›ร+2Hˆ›ฟgำ”ๆKศืiฯถ|N)ค๓ณC0C^sๆK๏ฟ"g˜ ๘Ÿ ้เบต_[๛ณR†ฝ๚๔WซŠ:} k?๚้‡#฿ฯŽ)lkฦ‡ฯ-WCYช๋:ป๎e)KR™าyสำiZ“šAฆ†ฒ‰)คr‰ฒแจ[“’ถฯvฆอ†ฆฬฺกฃ+LM7ฺทV”–&~zzํบ๗[—UขtžR'YZแ‹ ํ:Cฅ(@V6k,อญ4ษl๙ท๋H,€ืP^$‰ŠHHb‘ณฎHgp[ฌ˜Zสcan[cYฑ „พดTูH๓8ีE5ๅvXcst3…ฤZฒ3Ÿฌ๓Cดก@z\๖&}Qูญy‡GMQ)7๎m—X@zํMGหKvทฦ^)ฏ|๏>`xมวพ/“ูu0ัภg฿๏”ฒ7๏_yโFู๐•เ)>{บฉห฿ฎ‹ฏ ˜๛ฦGรห>ฤeําๅบkfl@บ๖แuY7ิQyxTˆ\ภฦIณฉถดฐฒuปUฆ0$v@ ฝเT‘@จ2ะ฿”wฆศH.IŠfWœป ๋d;ท^ๅ*็;v็ส5!r!#์ฦ๊โขk๗ww@Y,โ&a6้๖š•_ภ˜ จYถŒw๊}ฺx๔Vtษlาํ5Cผภไ~ัM็/xKฌ2ujีุ‘ซ ๑ีso˜ ๕ธฅKฆ c็gื0ืEอWืูฯฎ),ไฎวศ๕ฟ`฿ซWๅ๖ฏ;ั็เ๛‡ศ็/6ธ;8XVcช#ธ‘jน*IeˆฅB06ab‰‡[โfBฅ๓t5๊Gฉaื็eๆ90:66D^Ÿง๏v"€ฒXฤMยbัPmƒ&ๆฐธภp๊ญ!ส๐ิฒH“ @`ฦโ้yu]๕ถ์zPธ ž๗็นฬ•ซ๒uพnืM—,UถCN๎WQ~ร8?๊œbqะsš€xำใถžช*๙ฌฮž“ฒ€_JfE๓ฮ:ษQ)KDต‹/‘ฤชษŸ|%H–๊w๓ช nศŽƒํWชO|uสgfํ๐U๋\#gศZ๕S๘์gใOฝ=๋ำ ๖-hXฑC3w] รษ^[พฟ‚ฦ#Cแษ}}ฌpุ{‹พถ๕Ž:eฺูoฝ21N๎ญอ๛฿ๅ›O$IณzyBคŸ@ยตVื3ŠทM}}ฟ9oษœ๛cฅDMฦฮ๗VํศฆะฆmวฃยSธdผฺzชา|f๓๋ห๖ำŒ—ำ๘9yฎุ_VบZpฟบ)ํoR €๛สา๎‹๕๓ิd๎YปrK†p๕ฝฏ,~b• Sมo›Vพwธย @้๘๕‰*ฐหPึJgฤฬํf†|œ6ฅน<ฺยั'aJิัa|“‰Nfซสผค็‡ wV๓4a~lยTqฉ ึF๚Eฆ(ฅ^Y0ซฎHฯU‹L…ู–›ถaจ‡p{Y<ฏวMxภm5่หชmาXฟ]Y‹ล-‘๒ ‰)9,v…ฝฅ๓45๊. ›๔96šสณO๗ŒOh^,โๆB’ร๓{$ย?สU๛Vv!ปงฐ*๏ลข_฿ ˆๅชก๎†?-คฟ4dข๔zทd๎žK—ห gณ—>:œmฅขโ4!3Y@ึ8œภf+p้Sqฑ  งฃy?KฑB=3e%eb๕ƒ~=ฑŸt—aฤฉtk><={*k๋สไ=ร56v ๓หูš๗{ุK3Rhฏ ึฃ?Ÿ(ณvอTxยฬ%รrV<6๎กY,ใ=ึ‚š๓รๆ้Ž๛ไถ’๊ฏŸ}ฟ@8๚ๅืใ.ผศใŸูjไอiญdญ}055uฮ๗W๏J>n็‹œ[๐ง๎๊lG{๊บs’ธปๆNœ๔N๑๐้ฃี =qฬนๅำฦMxvƒ~์[ณ0ท$6็xtูษˆ…/๓ช‰๓Ÿ๔๎ž;yฃ 7g$ว i…]‡ฒ๎T:‹ทLKMIก9ฉฉฉฉฉ(…E๔Q8ชะwล๙ณgNgUูี.้›ŸOy ]๎ูณธšเ–kชใ,.3 Bฑส"=ศคผ›่งSwฉˆ’œ””2PfผX่ตQoดwx &ŒFฏDสๆIฤ“๙ฆๅูพB้๐็}็๛03ฬ0ร]D‹ukณดิ2Mณฌฌฬ235ดlาอU3i^บฏฆeVš‰ซ้ึVh@QA†00\ๆ~}/ฟ?๐๖ฮ0(่๛๘วx8๏9ฯyฮyฯy็zH$Š@ž(kซ๎ห๚๚ฯ๕f@V๏tส‘‹%wIG‰dฐ9]ซงm-ีิ่พlด ์†ฮŠล'๒‡ฃโ๘๑f‡รมf{็ZŸท IDATํปชŸ็VฺIg๙้sTdคผGฒบ&Mฒp๔นŸท:m๕' ซCBBภคำYQAAY’”ไHˆLHh๚ใ๐y‰~9”/MJ’v5wํ[v—YHgYA‰[.๋Šœเ,ะ๏‚€๋้2ธŽ@็v{W&๐QคC$‚คภ้าw˜+mh Uฆฒจ๓ฮูy:ไๅ๏[_~๒ณ*@ลjŠคPV›๕†ขNฝ`ๆม{ุ๊iOS9n๎ฃ๖ง=๚ป•”M๐] ('ฬ‘๗Kฎ\ฆ€ใx๕7‹flญ้YI““ว;๔ษbฑpฟ*Kk‹อC/ผฝtฯสy{€-Žฮ˜ถ๔% ็|฿DุM|ฅIoฮ ใ|O’=ะษ.ญศe`ธ)p”1’ึโSฅ}ใX฿ ( TปeM…๚u#`miฒq=ญN่™yฐ>K “ sณษIx๛หKPTO,๐7ฌก<‘D"ไ ภโy0ทC`/แršO%Vgฺz’toจR1*$dTˆ,Cฤ๕้hsXJp‡D/Œ‰]ฌ–"เ,1ทYBI่คะฐ'Cƒ\{ ขˆ,˜๋ฬ\ผ~‘@$R<ฝ8RŠPึฃญ.pZ+‡?ฆz:4ภ]n๓€ฉ'QืSl*C82pี;{gอSEัลŸวง‡๐ธ’ฤG&จ+>k}ฝ."๓O‰2y่—žนS่?‰ ศX%eหG•ๆ,-m๎ฑฎI“…a๐a7hR>—ู๖ชฎฎd>ํ๖Qขu๋ลZ^”rจRAxฌฟTj๗ุ„&,"วช+ฟ๗ฎ6Tอ็ธ้Zบ.ˆ%ชงฤD‹ร๔]iๅ~'ด~^Vร‰ Dz์ฟVjwYภฉwplๅN›ฤJ v5ธzรXฐบqE๊’ล_จภLš#[–ํจ0์ผ=็ญ ;งVฐ๊›฿xoA™sถ์{[เฌ-ุ๙ๆช"฿aฤkึŽ๗๎Az7๏~ฐ๎[4vี๑@ำฌ฿ษžQ‹wœ฿Rธk๕ซ๏=ฐjหป๐œŸi?๓L ์บำ–ฟพํฌๅภบ๗ฟ๗ณค,‡๎ไ—++|บH;๖้|7J?์๒Yน–|`šมK—๏|BJ4ฐ์ช-pะ’ฅ[sl[ี๑OW็6๐H๋…‹ุณ/ฏ}1Rฮ2—พ๑}->้I™ฟ{หlฯ›ีvศ]ู๕>ำt๒ษ๚Qo๓ซ)[ม๚็ํีต็jM2{i ใ‰e่8 uŽ!Cณิ@.ณ๎bY๕& E‡ฅฎข1>:eX ^cค ร๊ฤู„ญรsใjจะ๒ใำ"1สe5”kzไผM„วป4ขfgg_~S-Wฅฦ ZSLด:3ม๚^พหฮž์ใฺโ!˜@ๆม7†ฦ–†<Œ0tSz๚ฆิ„แdห็ตM=`/ข|5ฯำ5^ว|xo‰ฤะž’–<ป๓ว=ปw๏ปoปซq.lก๚"คตน ‹H–‘‘‘‘‘‘–$s้ =13O่AแK ™ ?ํ๛๗็‹EXFแ.ูƒ`oƒ@/ฝํ‹e````ธM`”žข๗}`ฑน‚ป]>๗ฒ'้’/ึŸลM๎ถCู:~0ทA Cค—}ยำ฿Lไ7f````````ธ…9ึท=swCƒฑb๚]]Q ŠษฦพtฎhK๙‰‹อ7s๐- &ŠLคr\Fy์F]ฅฆมึว#z‚b†ฅ„aํฆa8Jsฉ=]>sTƒ3ขE—=ู\v์ข;:cฐาtแT…‘Tž˜™ภฉ9}ถพwny์>๋(@‹ฅK1ใ:ึล:j‹ฯิ(โถ„งŒSIP›ตำFŒสb‚‹หmจ469!ยRX~โ[ญbน๙ฦ K‹Jํ P%&ว*%zๆs:ฬฆ๚=ฦ6ี8l}ฑsi็ฤสฑฃVB๚ซนsoถ$เ้ษูโCO<ดณp;ิฉu๓๊Fว้พlH๐ศจ บp๏ซ7[’ฅhพ›๘ฎธ[ฟ์}nh|4ง้Bแ'"T'%Eส›.pถ2:šำRrบ๐U‰)1Š–’†์่Žšข3u4wํ\9{K šŽทbIbSยlvฏ!ฦKE`ด b‰…พzย#mnฑณ ๔ฬ๎.vุ taS9+็แญ•ส›\ภ•ลฤE…ˆุคหT_ฉฉทเเ+“ล ‰ &.ื˜o{ืฎวึjจาตุฅI2˜b™ฬovอบฆศD™ ฺf@%j5ฟIซ ๐“*–Yฯ[=€ตกฆa๕C€ลโ(นฐY!bq๘๓ัaฉ|Œ๐ุNิU~ฺhˆ๚žส๚Y5gR8ฑต|Oขjฯ]๏‹รgE‡ ๅc„zดถ๒๓&GWo q8LดFš]ž๖;JืโชWย…`ีฝ{ก๎" JYฬKQ! 0๖ฤ•$=มๅ็๙งฟš;ท๖น™_ลพq่บu๎Q3ไ๛V๎‹=+๕ฤฒ™Ÿœดp๏ยๆwพŠž;๏ฮึ?>|}yn ฝ#$๎ู[Ÿุ˜7 ํ)@ร๏~e้‹๗$๚ย๏ฏ๘ฌภH/‘r๊G฿ฯ๐งgC=[P•ož๖kY๛ฃฒษv&ดย๓ะย{ี–ผต —ิ H™๖ๆโ้รฃx–สc{?ูผh‡HดะสI›Qเศฒgฟสฤ9ูPผ็_ห?:ู ะ]9Siซƒ6#IๆฬทLˆJx6]Kณuฺน6T5jks๎M’โ๚‚ฏ฿[๙UฑฏูZอ_ส=Ga>๕ัo๎ึ๘ุท์CN:}าjU฿ส’’ค`™.ผeล{‡jHZแi๔้#0`่[]7C็ Ab‘ลPbวภR]|าสec&ƒม†“ถณ+”ว๐aลbuBŒRภฦ0wน{]a™A3,ึSฎใGวspSMูล;ŸฅpjIYปฑย ˆR™ส‹}฿ฦุ+\=S„ว๖2 ิ*‘ฑๆข@`ตz$R>X0Iำฺgoกฅญฃภ-–ภcv[‹Š%ฌ๚s๙ง5ixXŠ˜x‘ต๔ษSgkIี€๘ `๓E\Œ-๑˜…บ„ญล`tpฺฦๅ€ME$ฦ+๘nท›รแxภ’[ซk-฿V cSx๛ฉpธY_ฺ‡ŒกaI›าำ7ลหนฃางฃFr?ีิœฤ…ฃใ' ฝแ’$Žวร‘=ฉโถเXŠTฬEฅฯ$Fd™>--๋Œ0ฝนงงoJูnH‹Cิcใq%ซ F€%›1 l0jฑบ๖จฃOO…ฑRB๋ืฌ?‘0{๛‹๛ฉปFF@ฬุ1ุถูš๗ฟ˜—gd๙z5Ÿ=ž“3ใrรฎ999999แ\t฿%‰ง—?>nยฌM†ฑoฯL๓๕Eิ๘อ๓99ใ;E๗อœœœœ๏ฒ‡ข๗ฬษษ™๓5—ฏ๒า2y;็NœดJ3r๚}j8)๒ปน“ว?บ่ฃขฐแ)"Ÿ"ัโSฮk2 4ํูืF”ผ๓ุธ‡fnตŽ_X2@๗ๅš๊ ฯ(ก9ด~4มqcŸฺZฉยน6ั} H9ปl๊ใŸ๛ย1๕ญษ>s๑ฅ๙ุq_ฟ4แม๙?Gฬ}๚N6ํณ>ไ}าj>h์ผื’JVอ˜pฃoท่ๅัB๐!<>้‡ถ์ฏ8†ฮภ06… ย‡>ํ ฐŽnWฏ( ฝ2กƒcวฮ8๊ญ‹u้ฯŸAธกICๅ$ ,ยiE|noฝฌ>‹qkำ…“าH’D„h.;ี €…"$I โศHพกฌิะแ@กฟ ฃ@๋AJO@“K๕ูO@p:M'Z์@J^peเ$8E๕๑I† @"๑ 9 x, kŸKmน_ ARแU€ ฌŽŒอ"=J†yLƒ™h๏ฏ‰–^“…a๐P,ฑB!แ ส)ๅซีๆw,ๆ‰ุVU๋ฮ(sอนRอุู…๒D‰ำฉ6ฏ# ฑXz…ป7hตข๘ไŒH !\F]…๔เqฺ\8‡ฐ๗ฆลฦ ORzปษู /œิภใฐ:q6asถ{‰fmน >65ƒC9บ‹u]\Œ้j(ืpใโ‡„sี ฉ0๔ฃ™3ฒ๕๓ฒNT่˜จ าcตRปห aมด1Ÿ—VกัaO%†pHweK]žีสP5Ÿเ:คk้ด฿KTOIฺ~ท่ญ?่"yšvึ…,T ‡ ZVื[ณโiฅ้5์ฟn\‘บd๑?*0“ๆศ–e;* ๛6oฯykรฮฉ•?ฌ๚ๆ๗๗›DPๆœ-๛8k vพนชศ๏าว/Ÿฌ๕ึ?ฟšยฑฌ~ั^ฝ๙ภบ5ƒ—.฿๙„”h(aู;][ูะฑ[เ๋ผูmะฦlฝp{๖ๅต/FสYๆ๒฿7พปฏ}โ5"ั>M9Sๆ๏2E๓fตํU฿ษžQ‹wœ฿Rธk๕ซ๏=ฐjหป๐Kน“hชฃž.ฃ9๛?ำ~บ็™@ุuงท-}Yหu๏~๏gIYษ/WV๘|ตื|ภrาCซy๓uk-Yบ5WมถUtun3ะ ะี;m =ดGWv}ื˜Q{ฎึ$ณ—ึ0žุฎเjจะ๒ใำ"1สe5”kšpจ")[ัฉน์ุEฺ u๊C†fy๗`R„หฌปXVgฝ1’๛€lฉีJcใR3ู(แถถh*6D$8์v/ rฃ—C€ฝฆ่x-ฐŽพŽถX|ฦ์w้2;;›™สg๐๒]v๖ไ[ผ1ŸJ2ญ}ฑD๏ืํx›p๙™\ 7@ซƒ}๗ฒใNLkฎ v์ำ›%^?q™!#ำlคT–ฉ4ๅ_h$Pพ:%ำtvอ-Wฅฦ ZSLด:3ั+}–ซ,ี๓ล20๔mPพš‹็i–กโ)๙฿แว็๎q–ง( (ห๙m+.lกzาฺ6Lํ๕RธUWังฯ„้YXย`…ยcญาแ™๗‡นw๛ Œ/–žภหภภภภp#`”žaq8…ป<$ a๋ฟŽ—ๆp'ย ~2>๊ฎ ฎ€ย๓ซฮฎit๐IM{Œ฿ผ๚๘ล]อ<8๋mz{p—ฆตvฃฦPKหขๆฦƒuแLญฯ3…„Q›‡„ณ๕็fjฏฺ฿ู ‘บ‚$}ฦาW&gD๒mี‡ถmไp•หอv๓T% hี'ำŸwี๕ไ=ใ‹ค๏?ผฎจ;_?S6}๚Lำฺio๊้ญด๒I?OlาชS=ั?0-ัgิ{Z๊„h` –H5 .\ฬCI—ีP]Q๊ภฤ๊๘ุP1‡ruF&แณ—ล ญจ1y@1XiบpชยH*OฬLเิœ>[฿๗I ่Šู˜g$่๑4–4ทห’ฤฆ„ู์ภ“…๑›ฯXUJi•ฑ‰รว™‹ฎ“ค๐ุ‡$Xฉพ2ืV{ฯู`6ี๏1แฑ๒AE s๋ - ฅ/Yธจหฎ๋‘O3h์ผื’JVอ˜pฃoท่ๅัBอg็ไLธฐkNNNNNŽ{›bฦŽมถอž๐ะผลผ<#ซฝฟแฅe๒vฮ8i•fไ๔๛ิ>rw‘W8ไdธๅแ†ฦDP๚s๙…jฬ‰ศ๗&nhT˜งๆLฉ“Euง๎l™ม๛™รW*Y๕็๒๓ฯ7๓ข#‚ฝMQฤuiชŒย(R[a™”฿;ย;[j๔fL$V›ใrภํฆ‚"ใ|ทอแpp—›Jฅ \ฉ„ฯf{}‰ธัHJคพD์4™{ลฮ๎-h‹ูอ˜]กืญXVฐR๎4ผๆถซนข๘tai/<ซ/ฝ ณ2_ุ ร Jภภbj๚ีdOณaฒˆ๋ogœ€kZ76ๆ;Hp[~mlฎภ(WQcใแฦฆ ]ฟ<4,iSzฺชh)ืฒฏษ„Dcใa“ใŠฯ-ส^ุ๊rnฝำi&Y ฉุCx;ทฅ๖rํ&ฝ fc="R`4๎]๒ฬŠ_‘;็mู๓ฆ%' "š8|Fโ†_ๅK“’คพงฉŽ`8๒Ÿย&งt5หฌ์r‡Qต๓J;้,?}ŽŠŒ”ท…: จr– E็ภ๕•ป๕HูดฌalIVVุGŠ|~๒F&$Ž>kt9๕G~9อMH๛Š‰"(;H.!fอฑ]+ืtน™7h์}ฎ+.hฒปฬB:ห Jชp™/9ชู๕Aฎ๊…[๛๙?ั/ใ๐ ญH>Kt๊บฤต%2้tVE@P–$%9า๗ณด!pอำCŸศw:ŽŠใว››อ๖!'ร-„ "5๋ ’”lม8l pปQฏั6๙^"†;;5E0‘จร0u4ึ4ุpŠด™ฌ$—๋ต,FI„d๔$ ]ฬ๊ ,eRv๖ˆŒ8Ž๎Bต…@Q”ข(„#‹๙,Š"Q Œต•– „aY™ร†ฦ๐=—ึพบLF–D!—FS๒ํัณ›1ปBo฿z€ˆƒ%Žึ๊๖šBธมั jฌกฆQ™’ใ2T–ี˜n5h ฝ‚`AŠฤ/ไ ,เฑP€๚jiฎ๚™๙ˆุ๓CiYžO‹“ด:๎๐ุ-™„อeฮีึ—ทมํ๑8ุป{ฑรครSวŽw๘jฝ๚Ž'–พ๑\ฤีวูl,|า๊ฃqภxN]‰ฯo_ฺ˜l6†ใmšถUฝ๋2Qํ^’"1์๊ฆ~ื+/๘ฮZŽไiŸอŒ“g%ž8”๏ปสูlŒ ฺŒใ8๓้ฝซ฿ฝๆรจ—}๔D(^[๘๓ถ๕Wต –hุ๊ัๆs.฿‹tน๐(‚๚”/๙๖‡†วžซ’ะฉJฉำuจฎK\["JWคธx๛7/Xm …๏ญ=ๅ๛Yฺฦธๆป)'ร-„ฃกดจ๙๒‘๔เTƒฆš;8œK:อ-บชช&‡/Ÿคหbล M"—Y[yi…u้ว ๎|ˆฦ วŒฏˆK็สšI’D„h.;ี €…"mdNC๙ƒ†…Rษ .nf4๑“Tžบbzใ…ฟ~|ณ[1ปBo[ฑB‰˜0้V*cฒธDฅฃ๒œaบxฦชส•ึšš๚•๗œแ†CQ8€ฅY๓ืšถ5ฯF.ŠคC.๋า„Šฤอ1 ฌ_Ÿ?่w๋งำi๚ฆ๛—Aa๗„SัJoวŠร_ งพษ?พ฿HใฅฉงAQ”$IสQ{ไใ6๙้่`8Žใx๕7‹flญ้๔qฺ˜8Žฃฌ6Kk‹อp=ฦ†a~๊อ‡œyGšฆd%ฅษSฯ]แงฺ.—“ลbแ8I]พใฃ฿^บgๅผ=ภGgL[๚ฮ’ …sพoภ†ฝKw๐™zฅ๐ฅOn๚๔‰ํ๐้Sิฟmฏํข F'm‰|rถžrยyฯ=ฐ$€=ด!p9้ซฃkใ|O’=ะษบšั`ธPธหIำP[ƒๆ\ƒม๘U|Bœา\า@[ฯeŒคต๘Tišหe ไ2ฬb0ปยญfOฌTอญn7p8,ฏห…รแธ.`‹Bคจษ`๖›อฦ=mš@ภฺาdใzZะล › N[L` dr!an6yW8๛‰ู z๙#—$b[mํ$nิž+ีY @ก(’คศ›๑ฝฤะ๗แ SฉRฉRฉฤงๅ"A"iš@ท|Pย"?ํึ]๋ $bยว…‡gถOนช"‹ๆฦ฿xms~+% €%ศR*GK๘(€P(ญTแค xC•ŠQ!!ฃBd"ฎ฿ๅ=๔"๕0ก“์อ‡3ิAถ(z๔˜aถณ%€š "=;’ ภ›ท•ำS|บสhcึVhB๏3Tฮe ฃ\พใ1ํ~ƒ&}CP๊C•า(ตฬ฿!บA‘ฑJส–ผ+อYZฺฅ@——็สš๑pFy1›j+4กู๗$K8<ๅศปาˆŠŠ&ะื๋"2”(“ว~้™;…€DO^ผ`|z” ๓˜ 3ะ6yวฮ3ชเaŸ๚•“•๐ไย‘๙šฟ์+ไ๑yc/อค%z‘hKไ“€ซใุ'8$„รbฑXh'“ญด!p9้ชฃ‹DO๙๛Šลฏฏ]p/๏zžf่ใ๐รโb”b>ฅpท฿฿(‚ฐ9AคฯX‚ุ่P†ฐxมำ้skซ@.fณX<™*iiฑ*‹‹Q‰ู(‹ฌ a›ฬ_”นๆ\ฉพํ์๐QL~ุ€ฤธ๘ไ9ฺYฬ๎ะปพXD$8์๖ŽถHถM=9[œ“‡)=Mšjฦหp QQัฃ@Wg๚ูbผด {*1„Cบ+[๊๒ฌ~ึ Q'kสsูัVD>A:๗Ytง\€ช๙ื!]K`]„๋`}หไ๙ƒ*ัO๚ Gโฺฮ(ซ_ †c ลญ†Mสg"ใ23ญซ+™๏s=$ญH=Mรพu;ย^œทลh1n(ํ฿K>-ก,ึฝ?๘๕๗ฟŸ%e9t'ฟ\Yแ€”๙ปทLQภ๖ผYmปฺicšฌ[3hษาญน ถญ๊๘งซsญ<ว/Ÿฌ๕ึ?ฟšยฑฌ~ั^ฝ/ฑ‚2็lู๗ถภY[ฐ๓อUE>฿vฺ*๒๒ฤฯLoXทถผจŽ๗_็อ†างฬช|`šมK—๏|BJ4ฐ์ ๛6oฯykรฮฉ•?ฌ๚ๆ๗€ึ ฑg_^๛bคœe.}ใป๛ผตฦปsฬศs?hํLหtr"S=ฌ๛๔ษำฮ–ณ์ฟbN๖ฏ๏xm๎ภดD+m‰|rMFดZข{ฒngฺOท<ป๎๔ถๅฏo;K๛–ะ6Z9imut ฃ๖\ญIf/ญa<ฑท"ซ QG'E๑ูˆวRฅ1๘šบq๊C†fฉ€"\fลฒ:๋”ขนฆ*x@bบ CHรTWกwัฌ-ฤวฆfp(งQwฑฮเาWj…qายXคหาXฎiนฦฅŒ๔3๗m1<ซg6'ีYฬ๎€๐x—>kณณณ;ึษ2๔{พหฮž|๋4แS้Cฦปต/–่;sถDxฤ๕‘์]<ฟำJ*˜4pเhงๆ‰ ๊ฟภๅ‡+๕iDcV๎ฬ9<๙อn5ศพ{ูq'&5ื;๖้MฏŸธ๎ฬอ–‹แVฃT–ฉ4ๅ_h$Pพ:%ำh}ž!x‹ม•EฉƒqƒV็”DFญฮL๔X นญา๐ษU–joฏ‹e`่ |5ฯำ6๖ˆ - y2๕ˆC๏B(า่h๙ผถ้v3€n!$“๚ว๗o฿†5่)๙฿แว็๎q–ง( (ห๙m+.lกAZ››ยฃำ†ฉฝ{)ชซ่ง^€% V(<ึ*.y˜{.๐ฦ_‘า}_,=ท–/–แฆม (=ยโp0 wyศ๖Dฯ๖W,ใ‹e```````่‡P„ปํดŽ=ุaโc````````่0V,Cƒฑb๚Œหp !ŒฺœiŒธ๓˜ท"’๔ซท๎=๔หก=^า่h฿ท+ š๛ํoฟ๖๏yfD_g^ั3พุ=?๕:๎>S6ุ{{กขๅ“6๎}-ณ‡๖ ๔†–zศUฝ๐kร?เ'๚e~ 4#บGซ๊ยยBข%หbา“คกก!ีUu~rๆฝฐSžkึ๑•๋O๘น)*1มp๔ะY“วcญาิปฝฌ8ฺxฃe่฿ˆBBHC“R€หPฃ39.c‹x<ถฏ็pgว้ฆ&uฆŽฦšN‘6“•ไrฝถ”ลh" ’ฐ›Œ‚$๔ฆ;&@ล"ชฎไtAQ…Eฃh+ฆหddIr a4๙|_๚$(ŠR…p„b1ŸEQ$Š๚&lตลงฯŸฝ 5๓ขcC{b๕o?ค‚$) ง(@บe$Eห ozื%<๕์x๗ฏึซ๏xb้๏อีM\}œอฦย'ญ1Œ็ิ•๘Jฆษfc86^ุ*Žu™จvฏI‘ุ5๕ป^yมw๎ะr$O๛lึ`ไ˜<+๑ฤก|฿วrณูAดวq6ๆsซ฿ฝๆรจ—}๔D(^[๘๓ถ๕WyผASวŽ6˜SๅCxA}ส €—|๛Cรcฯีmษm่T%4žั54jซ‚๎ˆk๏๙’ยdNํ>O ้ะ<ท6 [ฆž๒;‘‰a—า์ ๛wm ผั2๔k‚BBpCษๅŽj(ŠB๔.‹]74=Š \fmฅ้า๓—~๔ูพ›สิจทแเ&}ณcจH8€อhโ'ฉ ‰›c$@Yฟ,>ฐฏMŸEQ’$(Gํ‘ไงฃƒแ8Žใี฿,šฑตฆำวicโ8Žฒฺ>ฌQAฐฑถุ<—Y[ƒa˜๗t)w€ฦผ#MSฒ’าไฉgฎ๐Sm—หษbฑpŠค. ฿แฐ—๎Y9oฐลัำ–พณdBแœ๏›ฐac๏า|ฆ)|้“›>}"ทD;|๚๕okฏฑIปŽฯŠป&อ*ญuา๐ย๒C๛CgŽLแีWƒ…๘ฤqhู–Y+žำพๅฟ๛\PA\ซฯฌธŽๆปั ใ|O’=ะษ:ทฟ๒0๔‰B๎2ัทAHส—1ฤQฦHZ‹O•๖หฆฎ~; wฌ-M6ฎงี >ง’๚$ธ  €‡ใvwิ)K “ sณษIpCโc9๚ :๏ŒOO}i0+ n5„bๅฤะฐ'Cƒ\ถถC- X,07vkšฐก“์อ‡3ิAถ(z๔˜aถณ%€š "=;’ ภ›ท•ำS|:)icึVhB๏3Tฮe ฃ\พใ1ํ'ฃ4้‚R๏ช”†Dฉe~NV ศX%eหG•ๆ,-m๎R๎ หหseอx8ฃ<๏˜ืณmrf฿“,แ๐”#๏J#**š@_ฏ‹ศSขL?๚ฅg๎=y๑‚๑้Q2ฬc2ฬ@ไ;{ฬจ๒ƒ‡} ่WNVย“ Gๆkฒฏว็•uฤXK+ไฺ4ชชBFdฺหKหส;๎ ดU_ ๑ƒ็gซMY๘๒H฿{ป พถN5|TขLsืฌ'G หู…Šปฆ๙,{๔”ฟฏX๚ฺ๗zว1~ REฐะ|ๅ‡-‹หc#€pคr iท๙๚TA„อแ โฯ]W!-&›X&ฤP”+ “๓ฬ–ŽU<”นๆ\ฉพํ์0ทถ ”แb6‹ล“ฉB––๖Wž6 1.>9Ffhz(–XกpPe‹”rี๊gSภ0พX†[gำv๗™ไ‘h™วc๛_ฅ๖ถ—U๓9ฎCบ–ืEHรพu;ย^œทลh1n(ํ฿K>-ก,ึฝ?๘๕๗ฟŸ%e9t'ฟ\Yแ€”๙ปทLQภ๖ผYPพyฺำ_ึาฦ4Xทfะ’ฅ[sl[ี๑OW็ถ[yŽ_>Y?๊ญ~5…c+Xขฝz_beฮูฒ๏mณถ`็›ซŠ|ฮ4ัๆP‘—'~fzรบตํ˜S๎8ษk(~7J?œ2๓ซz๓uk/]พ๓ )ัPรฒw (0์ผ=็ญ ;งVฐ๊›฿xZ/\ฤž}yํ‹‘r–น๗๏๎๓ฎbๅ9fไนƒดvฆe:9‘ˆ)‹ึ}๚ไigหู๖_1'๛ืwผฆ[ภZ๊‚BฎI“าVA์`Mนฃพต6(LV] เญธkโW๑–w๓ถ-;ษU'้ํฮ–ํ๘๓พ™ช๙๚๏L|ฺฟœW5 ฬgšFํนZ“ฬ^Zรxb๛=จT!ต*/7bMตฆจ่!™‰,าiึ_ฌฐ๘zึiจs šๅœH.ณ๎bY๏I„›ˆ4nx’า๛:0[Dใ…“cC…–—˜‰Q.ซก\ำtอ< าw—CะB4kห๑ฑฉสiิ]ฌ๋0M=ซg6g[๗Cถิjฅฑqฉ™l”p[[4=๑&#<ฅฯฺ์์์cวŽu—+‹Rใญฮ)‰Œ & Z™`o@/฿egOพฌ1๔s„Oฅ๏ึพXข๏ฬูฦะƒค.ปฐqŽํ๙}ั˜•;sO~๓ฟ๊˜F†~รU +d`บฌฉ ฌ๙:62กฒ„Lฅ)B#€๒ี)ษ˜ถ@๋ำ่ฝลธม–@ไ*Kี฿Š–0Xก๒ภ2๏&๐vผA๙j.žงkdLX:$“๚วม<ฦ„e`ธ!`rEัะz}{๑Iks‘6,######-IๆาzbfบŸภXWแฯ‹ฐ8Œย]ฒม^n-_,รMƒPzŠl ๔AฎฒTญ‹ฅwกl?˜ภ กยXWมœQภภภภภภภภภะ`ฌX†cล2พ œ ปรTฃลฎๅษภภภภภภะ`ฌX†—`Yิ˜่cช›-I๗Ž[๓oฟ๖oฟ็ๅyไ.ฮ๊vชƒๆ~๋MsŒ่n&•j๎งu(:bสฆ๛qฏุ฿สฉ›ฝqGทฒ ,ฃžใสbv:แฃg|ฑ{~๊eฉ ๗~๑„:ไ|วผัZ๒Oเ%b่ฯฐDแ‰ฉรฒฒ†gคจํผฐ”แ™ !ํ${Žjp๖$xFฦฤ๊C‡ ž1$!Lxฅท„‘:";+>@‘=<^Š ๒ฤฌ์ม*๎.B7มD‘ƒณฺŠใ“ ˜aูู#ฺษŒ๋‘งฟต†žฃฅก๔% uูu7[’๎cห}uT.๔๔ญ็6<2jค.๛j$w ฏ›W7:N›;ู_2๊ -1บ ม‘์ฆข|ฝ Pคใฬ-WKตฦMš˜๑4–4ทOล’ฤฆ„ู์€สb‚‹หmจ469!ยRX~$[ญbน/?๔Ÿ%–ŠภhAฤ1 ๊ิ?ž2>N%Amึ@.ฦtิฉ๋ัห‡+–แถ„ซz7=:jj‹ิ๚ป%ณ_ƒ†฿สา๏I &๔…ป฿_๑Y$™3฿^0!>X(แูtM,อึioไฺh้ำTš๗ฺœ{“คธพเ๋๗V~U์๓ผqT5jk/;HMnใ€ห๎p*฿<ํื2c[LAสด7OลณT๛ษๆํG๋.๏เ…#^฿พ]๙ิŠใึNb^}Fด กแŽ7_ทฮ=j†|฿ส}ฑณgฅžX6๓“s8ํใtล TKสฉ›> ๙ฟ)ฯท‰w๗<๚Š IDATฒƒeฬ- ฎ>๎ู[Ÿุ˜7ล๛งถฯ$ไฎืน๘…๑๘–ฟ}ฦฯ&ใ๖˜ญ|ธ๔ญ}Uค-hcส&oุ™๔ำ ฯC ๏U[๒ึ.\๖S€,{๖ฏLL‘“ ล{ตฃ“ญ:ZุฮWัs็า๚ว‡ฏ/ฯญ!ฏ๓R‰ฎw†>G58#Zc๒า2y;็NœดJ3r๚}j4ํูืF”ผ๓ุธ‡fnตŽ_X‡>bฦŽมถอž๐ะผลผ<# ๕Uขภ๋กฯใฎ?{์ุฉJี\v์ุฑcวŠ๋]`ัๆ;vฌD฿yงฬ  ๓ิœษ?uฒจฮแิ-3x-HพRษช?—Ÿพ™์}ตE\—ฆส(ŒR!ตI๙ฝY0Tช Ctญ$`\ธTPDbผ‚๏vป9Ž7?~ขฆIw๔ื3dคฺgฬภƒฯ˜ฮยชคๅBัy'pศยuำ็~V๊ดีŸ(ฌ iXต๓J;้,?}ŽŠŒ”๛*Q7๋แVwvjŠ`"Q‡a๊hฌiฐแi3YI.ืk2ZŒ&’ ปษ่!HA{๗Z*VฐR๎4ผs{(ŠR…p„b1ŸEQ$ŠขlEtUWี|ีช —ษศ’(ไยhบe‡%[m๑้3EEEลg/hอผุ่ะžX{๕Š‚์์์H•ก฿rŒน^ๅ–‚อฦขญรวqœฑ€าi.อ V[Cแ{kO๘ ๔•f๘คี;Fใ€๑œบŽฏ˜v)wิ๏^๓aิK‹>z"ฏ-y๚‡ซผฝom@+ถL=ๅ่,f`ะ*ค›ำ3`-5jซ‚๎ˆk๏๙’ยdNํพฎฮtไNŠ๘sM\ร|.( ผ1tณ~ื+/€ iา›ฏNˆgใD —"Rํ~'’";DบถDฌw†[ —ล.ŠšE.ณถาิN]๚qS.QEฤมGku๚P’$!šหN5`กIRจ82’o(+u\ี๗ุŒ&~’สSW์ACoผ่7wปฺŒw—พูฆYL๋—ซป1ฦˆa`ธ…ภqeต™5, วqๅ„๙#๒ž{`ษ“ฤด>ำฌfัŒญ5ฦ$ข#๗6?„/์ฅ{Vฮlqtฦดฅ๏,™P8็๛&วกe๓[fญxO๛–n๕30่าhง-fเZชาZ'  ,?ด?tๆศ^mqตฟุ$E๚7Tร0๎ห ผ1t!ๆธนฺ?ž๖่๏VR6yรw)]ษOฝ ใ|O’=ะIfก์mG#i->Uฺ๗.™Jฤ„I฿พ5 wปรaภแpn_*แpนƒGดd"ฮีžฉฌ-M6ฎงี พ'ˆ๚,L.$ฬอ&' ภ ‰ๅ่/่ผEO}i0+ nKX‚,ฅrด„…ฒัJๅvฐI`ิVhBณ๏I–pxส‘wฅMlŒยaฑX,ดc~6žš "=;’ ภ›ท•ำS|บ3๋k๋TรŸฝ3ชศนท๗%๎tg฿IHK€$&2๚Sๅมฐ(* Š""(( <@\\`”็€ ศ( ข Ž0 ศฺู;Kg้}ฝห๏,,น7t“คกพhNชNsช๚ำu๋VMT*c๎๛๔h ปJ,zสฒW& RrFฝD\yฆๆพดcใฏ)‹_-ฝQIO` Hoซ3บ้y”ซช‚FฅูสŠKJฐ1c่สž็›†ŽฆQEE(ฝ่Xกไแผ 1๗ w––ดฐ”๒|0x^’รๅ %"ช!า46UD„”Dฦj๘8O5๚TGq1›I์=๕ญuหx๏•qย=G9เฦใ๓q รฐ2ใส ?@สณXฏค3ตต‰5a2‡#T†aญญ6k๕๙œr+M”พ8็Bmวƒ&ฺTsฉธมฟ์๊Qศ€ฤธ๘ไUGข้ฆ92ตZฮว1œ'ีจฤ‹ณ&7ํQ€ธ+แสืฑG20โล@ศ)ี8kMฝ'˜Žn4xลšฝO)ศฦ‚ฏ^{Žจ;ฒฃ๒ณ?? คMw~ืš7v]dฦ-ฺฟmชvgฯํx)|t๓๛ƒ฿xน Ž]wๆ‹๕ๅฌYW๋ัํ{ผj๋ืำด_ฝต๛ิคูpีึ_eฯƒโง>๛eC[Q)wฮห๏ฝฉโ˜สN~๔ฮwW/{tl{'{ืŠ้Oo8c๏ฑไ505Tฯ^ฦ“ูMฯฃDWVA์`m™ฝพญ6 DY]อj<€—OทŒ}๛๏_Nๅ[ฯmy~ษมฯฏ๘แ๓3/ผผใPฐศUw_oญฟ@ณ4ฤบa;๐B€€ด๙พ[%vิžปrC>kwฐ๖ปก๒RญQi+ฎA3ฑ~Nืฉ™Q0t่๋์C†eดo)L“N“ฎดคฮr๋ e“Jฤv›ํส&[*หฤ๑ฑCG๐i‡AWZ็aฮ†žๅ7".=Iำ“z`ฆศฆข3Zธํม#ญŽŽPญต•Šุธกi<œtYZตๅMพ๘าbBแ•_ฐ™™™hEขo23ง มp'ยปo๕‘๑Lzํฐ0^์์?m™š?นปpาๆ ทXฤm€q„0ฯKฒเํPpeBšฦ˜[ิDเขˆ”dnๅนJึ๎0สจˆ@B_ฉsศ##I}ฅฮD๖‰ฐ฿r]ฆŠๆbˆป wแŽ?น`๏กนn‚ฆi อ—wญ+r„ทRฤํq„๔ฒ$แ+(KKsXt๊ศˆ๖iยข+๗ล“i?# Tซ–*!Vถ0๕ะ_@sฑfะ\,@ |บก๘ Œร็siย้ฆ:?}#์ท นX@ ƒ&]ปๅv}่กฟ€๖(@ @๘(‹E @๘(‹E @๘(‹E ๎$ใ78qโฤ‰'ณณ?^–ัkญƒซ]็ฎYั7ฉ"zึ็๛ ๕]I˜ิx๎&ˆ=นŸ‡Ž|์ภ‡3โ๛ุฌ[‚พ฿>ši{sŒ—•†/=ูก7.w=แS?>zไฟวษผฏ‰ธEˆย‡Žˆ ่6๘กƒ3ฏ!A ภ K2"=#}ฤฐคH9@="3=^เชฤŒฬมกs ‹›ฬpe‡LO1$!Dโ๕ฉ-ฬ*}ข@^ฌ‡—Ž= พ€๓าึฟŒ C\๊uพ šไย{žž';๖ิใ{๋1ฑ ืgˆ#๚# ฟ~ฒฑษ~v+B๔๎ฆโs-pไฑ)!VD$„า5—ฮท81qHBBŒ2ฟด€#SHม`ฦdrŽิ๖7˜dWฦ$ฺK สฌธ"69!œW๛=าP‹ธ+แฏI‹ฝ๊,w๚Dษ๏›YO๒c๐ฐ๛^]๑โIdC๗ืํ8gyฺณซ^™(‘ ญบfŽv็Œ7[…ฬ:Cว.|}ธ$ัp๎ซwืYภฒ฿xœ=;็D|”= ใ่/&“XJ*3็ญzuRŠŠj,8๐มšํgฺXงฬXนlfz”ะ\‘s๐ำOvŸฎc;F9e๋คืน_<.ยœโี?6ฒxฤจ“ก$‹๑ hฆmvแ €{๖0:Oไb์#F;™ป#โพW—ฟ๐’ิc้ฯึฝ{ฌ†บๆวฬ๐ฅ‡ิ>๗์—๕ฬ:=ศะลทฌ2zมย,ต้์๖7W๎ื’ž๛ฮXใx8ๆใƒw๊G—;\พo๕ๅกU๏C'๕ฦ๎ๅ๘๚gึฮrฺ:vแ๋/Žค†ๆ&—ุ๕แตvŠฦm<2ๅ์ิy๛š`ภผฏ6qืืึ‹]gก•}2ใืC}ไ๑๗่N„+Hˆัˆy\.N8]˜ญ.ฏD๏ลป๑ผAร%อetpฌJHดU•5;02&>Z%ๅาNscEyญษ ŒBqฤฐก"€”ฬฐU็ๅ๋๚"mคIทซร)qDจิPS๊เ‰ล|sƒN€E฿๊ •I •ฐXr…ฬ\y€รโWงะ2บษŒLฉด5ๆš\$@‹ฎ92Q)ฎfOy=ญ(@•Pฆkตkตk๋ฮปhGŸ\ลn?า-O<ฟๆษ๑็~ฌxีณฉ„=>/mg>6แgvV่vฟ๐ๆa+‹E็+oฆ\\=ํ‘ ฯ}nŸ๖๖ฌdถฦต;žฬสš๙2พ๙YYYYYํ๙ “IŒ%๑ิ9ฏ*\๛ฤ๘วŸi™ฐ์ ึv‚'-z†๚fม” ำ—lฯIO‘๖ajšp๏‚I“7hGฯ|0‚อ#FL%™dข้๋็ณฒฦฟ{–๚ieVVVVV๛กฒŒ}ฤh'#/|=ฉpรฌ‰L_๙[’—xๅป็€ุ๑ล_ฝ4๑ฑE?‡/˜'ž7พ3V๗8žM•โ\r฿Š=ŸฬJupฐฎช’บ‰ะ S็ฝ–vzรฐฅฐา_Y‘\ฐ๎ษG™๚7D—ฐ›๖฿ฒฯ%ฆgHB32คงO]€๗หสสšํ5?‰๛ศใ๏ัˆ 8*ฤ]s!๗์™:ปCwัซถ\&็ิ_ส=ฏต+ย‚„ภ Š‰—˜J/œอฝXํR'Dศ€Ehซฝ“sกฦๆj(ฬษษษษ้›๖[ก!Xฃฎย้ข$ 0B.โ๑ฺ็ ƒ’+๘"นฬa4๙็Y่WปษWภ—‹OŒW‹\.Ÿฯ๗Eณ>ะ@๘”=ทฉ้xSsต@1˜G\จ,ฆืฟ๛%‘ ๚ำว/œŽ†Sฟœ$$จภจำYpรร9๒”ไH6!›ฮๆ฿Ž_ถR„—cนŠค$E๏Mb‚ส๊‹ฑไ78อ6iฐแQ$้4UV{ฃฉแ๒Eภ0Œ๎a4Mใฦ&ผล`ฒ@นฝญบ+_u่ห.่ตœ&)N๐ ฐฎwญฃ()ิ]Wเฦƒoฝ•ฝๆz7 ( ร0ฒฅไl 7ฃ(_L:ฃ,q—ย—D,S ฬีซ* w๎!AเœŽlƒรแ ™ธhT๖s.ฟฦkF!ซฮ๊ฏ—ฬฺYใ‘๒&“Kjฦ/˜n๛วŒ้'-”rสึoฎZล[๑๕ O=bฦŠตห'ๆอถู#๓z๐ˆI'ซ๏7—ึuถฮ๏ซใโ@fiตบiŠพ"๔~ยฃ—]์ƒ†บ้ฌชดLN );v$๘ูั)ยฺ‚j๐6t๖cซตฮ]๗=฿ญ9ษบ H’์:;›ฒO5OอHJU ฝxz]ทoฦ>๒.ศw|MŒผญเlฑOO‰ขi:“ิฎไ•Q@ pkRZ‰\FบV-๐คA จ7น€วใ๎ŽA‹ฅตู*pท9€ํ๑Tฟๆ:7€#Vช$คฉลุ>MDธ\ภ็sHเ๓๙.—/^oE+ w%ธlฮภˆxyม@ TkะhRgcoจ-ืgŸ,็ 5ฃ๏M%หห›x\~`PŸรแppผ๓:ฮ(dฆฆ\ซž)ฤM๙๚™)ฌ“ฉอ Cว ำ(‚ข"”“Krธ\กD„ƒ@5dBšฦฆŠˆ๒™/XX๔”eฏLฅไบzฝ‰๐njษ#fฌพwsำsXโy๕1 S x’จวึ์Y๛ ๊uแi๗$*U๑ผ๔ื?๕ธR–‰^vฑ๊ฆณฑช*hTšญฌธค3†ฎฌrƒ๗กs_ฺฑ๑ื”ล/๎aแt}m]h๚ุDฅ2ๆนO–๔lง.;™1๋ฟF”e็๔ด$‰ฑผ ๒Ža<>ว0ฬ‡sฃปM PIน8ฮW(eดอๆbธNn€"€ฯใ‹„ผ>อf๙Ržลzez—…ฤล„สx8Gฤ3šบD›j.7๘ี›]WธMQศ€ฤธ๘ไU็uิึ&ึ„ษxŽP„ตถ๚b!š‹E•เข0>2#ใ2่%M…wเถGฆฃ›7 ^ฑf๏S ฒฑเ฿ซืžฃ๊Ž์จl๗ฯฯiำ฿ตๆ]…q‹๖o›ช€ูs;@7เ7vฎ‚cื๙b}y๏ํฟ|บe์r*฿znห๓K60™ฤXฒศงฦ.๗รขึผ}—พ๛่†m๏ภs๓๓งu7ฉฎญจ”;็ๅ๗^ŒTqLe'?z็;๏ถ›`๒cิษ๊{77=o5 žWด|ลฮรjžต๊๗ฯ6nwŸ์ฮz{๋i๐๕ษGŸ๔Jcn2า ฿=']Yฑƒตe๖๚ถฺ€euuง๏…ฮYฐํ์]+ค?ฝแ ๓ด๕่๖=^ต๕๋iฺฏฺ}jา์žํ,ฯฮ–ufใๆ๗:wีฺ๊ฃเซ์yP0๖‘wAพฃp่๋์C†eดฟvG“N“ฎดคฮาห™YB_Y!OH ใำXZfb-ตUสSC0าTuฑจฉฯ.˜T"ถlWFฆณกขR7 5„C9อMeฺึn~cทh’ุ—tsภmท8iutŠษ–ส2q|์ะ|ฺaะ•ึ๙ไ)(& ป“™™™““ใ ตฟ็›ฬฬ)h0‰๐๎[}d“^;lŒ;๛ใd[ฆๆO๎.œด๙ยํ6@ \}Cม• icnQ €‹"R’น•็*๏ขฦzƒ@H่+uydd ฉฏิ™ศ>๖[ฎหTั\,qwแ.ฯ๑'์=4ืMะ4 ด๙๒ฎuEnƒ๐v[Š@ ๎@(KKsXt๊ศˆ๖Uช4aั•฿น๏&๘Ž$Pญv[ชt„Xูมิ7Bอล"˜Asฑ๐ ่†โ+0Ÿฯฅ ง›๊@๖ฐ฿‚ๆb@ štulถ๕กo„ฺฃ@ แ ,@ แ ,@ แ ,ธŒ฿tโฤ‰'NœฬฮnpxYFฏตZ๐ฏvปfE๛ภศž‰ž๕๙EC๛ผุ Ÿ๚๑ั#=Nฦ\๏ๆzr?๙ุgฤ๛Feทะ ]|๐๓ง"|ฃ๛ึ{‹fฺววใC…pKC‡ธ i๔๐QฃFสฬ.บถx.TลJMหศH1$!DาžZแ’เ„!#า32า†ฬ.”FศLW`ธ*1#spจ_รร•E 62ฝ๕>๑ผค็๛D ธฝX/{†.>ธธi์/j}ข๕าึฟŒ C\๊uv7~dc“ผ/ท๓๔<ูฑง฿[‰wเAฤอaฉ:{ฤŒŒป–‚เ๘h~sQ^‘“D$%Eชš‹๔Oอo-<_oวDก‰)1๊ึยF7“€#SHม`ฦdrŽตืŸภ•1 ๖า‚2+ฎˆMN7็UณlœๆyIoš๏ตยมcƒl‘UF๚ถ!‰ใฅพ๙Qุมร๎[ฒ๕๋#ว๚bำœŠvก<ํูพ8p๐๐ฑ_:๐ๅC๋ฦKุ„ฬ:Cวพฒ๙ซร?๗?ฤ€ZWfฮ๛฿ฝG:~dฯฯงถหฎž๋พ๔๐gO„ฤอู“ฝ{๎๕ิฒณณณณ; 0ฯˆ8eฦ๚:หฑ;๛ฏcย๙ํvFทdหW‡t๔_Ÿ,‰ณšฤศะลณณ๖รk†๔jแ็ณ2zk็แฟ๒๏วa'šiณณฏผ6oฯฟr๔‰Aฌn*งl=๖ๆc๗.๛์เฑvฟ`0›™,ก,่7v9žu“:์๔ธใ˜dจฮิบfฺว๛ๆ'w้ย๏[}lีฝ๘Mน)๕ฦo฿ล~^,cไuฒ ลv78๒ลช๑‘]ทร๎กc`ˆ›% fไะฐŽM>eฑiCผyไส#’‡™–1*cDj๊ศD5ง]gธศ๖Œ›9t9~zฬ‰ทfฯZ{.~แ_ณxเEว1ปษTฉ๕ฆส qH.นoลžOf%ƒ:8XWUI„›ยิyฏฅ๐?ฟ[ุŒd๕:Y๛=ๆแ‡ธปๆM||แb^ž•ณ…Žq€!n‚เจwอ…ณg๒๋์ล}๛๎P"†S)7๗r‹0:<ฐ}€INm•AŠี–๋Aฉ่›ล \.ฦลa‰รFฆงฏa–šโ&W{ฑˆOn6!a0Pr_$—9Œ&๏กพอp|pน่€๐ฤxตศๅr๑๙l?๒~ัเt4œ๚ๅผ !AFฮ‚ใฮ‘ง$Gฐ ูt6vฒ•"๔ฟหU$%ฑM’Ry›g.ุQะๆฐึ‘Wไ ใม1œ RI1“6g฿๚อ?ถDฤะŸ๚>ฏูแ2^ืฆ5‡*๐›•‡ถํ/1SŽ’s…ฎะ0%x:๏tไ=ZeงฬE๙—เ๕29๗Ÿ|~ชฒฉ๎ิ๒\!กJ๐ขใ˜๔ธzeU]HHP๔ deฬ๐$EppPuU๗n๒Rๆผ–๑๛๚-๔๐ศ‘5๒ื๋dํ๗ช#wธยF9สฮ_ข##Ulกc`ˆแฺ่ิใJฅ]‰ฉฝฉฆัJะ”ีhก‚๖ ษl0R$EฺŒ7งชBb IDATI‘7sฑ€.“าu…็ฯๅ—›%ฑ1j^ปศ4‘๑ษฉฉ1ผฦชFGBงัภ‘ซUrา`ค๚ฦฦ>วqšฆ1พD&qhšยqถผา๓’€ึล"๎Jh๎Mฤ…(ว ๚ฺ่vปแ๑ธ$ูqม'‚วๅญหื\ถ๛๋,ึฦผw฿; ภ&dำ6yใžเ บBึ฿ำโคษ+—NŒ็nL =จ๔ยxF๊๗o๚0๊ฅ%Ÿ &j๓~ตๅฃใUnเ๑ธัQZ~๚ค/Lบsž„ข)รม›ะ1rC7๋๗ฝ๚‚๗vv้$IฒNฯ;˜๔ธzSeUภ˜ุ่–Ÿ~ H Q:*ฟs{๋ฆh[๑๒mำฮ๖๘l๕†‘๏าษึ๏Wปษๅvป‡Žq€!nNณM7lxI:M•ฦ.9}ๅร-พขำ@›ฌ „ฑกล>L*&G38Aแิ74–Vฌ๎๖ไ”Q`5EIก๎บ7ฮบ€จ?BQ†adKษูn0FQlSษž—๔”ล"๎Fxสศ—4’s?mใ<”4xฒ_ฝ๊ AเœŽ฿ป‡ อฤEฃฒŸ{t๙5s\ŒBVี_/™ตณๆF5ใLทcฦ๔“J9e๋7)ํRšขปLบๆทxWบิ“๑,ุŠฌ_xxฒ่3Vฌ]>1oทอWWวล ฬาj d4ฉwx:Fผp“nกckศณŽ๓ฒzทึซ*-“ำHสŽ ~vtŠฐถ ผuำ~l๕ขึน๋žฟ็ป5'Yxyๆกx5\.ืMฐgฆL $๑พ?ษ–{์L๋†V ฎ@ึ‘gb^็›|MŒผญเlq?:d๊๚แLำ4์ชฮ-jบ๚oŒB ,ญอVปอฌ๚%„ห|>€>Ÿ๏ruฝดส+UาิbtP7(ู ะŠฤŽaเRพ0Bฆศ!ูรa ๅํถชจ-ืgŸ,็ 5ฃ๏M%หห›x\~`PŸรแp๐ฎ็kŒBfjสต๊แ™‘A”ฟญŸ™ย6Eสแr…ี i›*"Bสวกก^žvOขRภKำU๏A574 3LฃŠŠPrXŒg‹žฒ์• รฃ”\ทQฏ7‘TG๕1 S x’จวึ์Y๛ŒอคแE่๑ุMvบ…Ž;ฮห๊Zoฌช •f++.)มฦŒก+ซ7แฆ๛าŽฟฆ,~y4๛Tฯ#ฯฺ๏‘ฑ>ฮSพ7ีQ\ยRy€DO}kฒ7{eœฐgoืเt:…๒@ 'Š ๔๖Zรx|>Ža˜๗pA™V™&Dยลq9F…฿จdo@sฑˆปgkNƒxZ่€ญ๚ฯ/]<8M%•๋ wr7ำัอ›ฏXณ๗)ูX๐๏ีkฯัuGvT~ถ๛็g€ด้ฮ๏Z๓ฦฎ‹ŒยธE๛ทMm_2ผ;{.”}2c๖ตๆฃ›฿ฦ๛฿ฮUp์บ3_ฌ/g›มช?๒้ฑห๖ฐจ5o฿ฦฅ๏>บa;๐/ฟ๛dwึ[๗Nซ๘๗†ฏO>๚dWq๛/Ÿn๛๖฿ฟœสทž๒’ƒ Lฦ3ำVTส๓๒{/Fช8ฆฒ“ฝ๓]k‡๏ƒ–ฏุyXอณVูฦร-ภhR47‡.>๘ัไ๖_6_eฯƒโงถฟŒี ๆxz~/๒MVบ…Žฑ”วว k๕nญำ•U;X[fฏoซ QVW฿œ›ฮ‚m๏d๏Zฑ ้ g๏vžGžy(คอ฿๖*ฑฃ๖•๒ฝ`†สKตFฅญธอฤzƒซฉZ˜0hxˆฝQ[฿ช iฬˆม!ํหT†eF‚ญ:/_วธใ”C_g2,ฃM@štštฅ%uฌ3๖ทgcyฅ(.15’K;-๚2m3ภวW'e^y็ขฅ$งิย$ผv๔`~ถภlฉ,ววมง]i]ืณทโ xคีA฿จdoภ„ย+ฟ!333srr|กแ๗|“™9 †;}ซŒcาk‡ญ€๑bglหิษ…“6_ธฦ๚Œ๑Dกป๔:๒พ\ั>ผกเส„41ทจ‰ภE)ษสs•fŸ(๏”Q„พR็GF’๚J‰๔™ะิViฐr]ฆŠๆbˆป wแŽ?น`๏กนn‚ฆi อ—wญ+r„ทR€1žทจป๙ปสาา:2ขี<šฐ่ส}2ฉ็p$jตRฅ#ฤส๖&฿ }yพหญอล"˜Asฑ๐ ่†โ+0Ÿฯฅ ง›๊@๚N่Sฑh.@ ยกIWวnน]|(๔Cะ@ eฑ@ eฑ@ eฑฤ€dฆ'Nœ8qโdvv๛‡รห2zญuะ‚ต๋5+ฺF†/=ูก}คœ= แS?>zไฟวษ๚จaฯธY฿ลƒž\ฯCว>vเร๑พ7ซgขg}พัP*ิL๛๘ุ›c|จะ†.>๘๙Sทฉq‚# K:2##}DJจธS( IIOK๒ฟ7vpIpย้iร–tคV\Yฤภa#ำำG I‘pXKJฃGdฆว+0\•˜‘98ิ฿ฮ“ไJ#gdฤจC@zฒOด ˆ‹๕๐าฑ‡มื[`^ฺ๚—ฑ[a่โƒK}ขฮaHรฏŸllฒŸ๗วj@xฯำ๓dวžz|o=&๘โLHโ†เแ‘ผๆ'เX็Yhเlญึบ(“๗ง0฿fxš่h~kแ๙z;& ML‰Qท6บqeLB ฝด ฬŠ+b“ยอyีVฦ’™B 3&“หp`<ํกฟ"ิฤว…สqซๅ†ืฦ€๔”ล"๎FC}#+จศ]ี่A่;รฃC๔Eณห ิซ๚xุ}ฏฎx๑ค@ฒ!o๛๋vœ3€<ํูUฏLŒ”ศ…V]3Gปsฦ›‡ญŒBfกcพ>\’‚h8๗ีป๋ฟ,`o\œ2cๅฒ™้QBsEฮมO?ู}บฮ%y๘ร“~Ÿ:oŸโๆ๎๙@ผaาๆ!‹.nY๛e๔‚…Yjำูํoฎฏ%๐ˆ๛^]ยKRsŒฅ?o[๗๎ฑŠฅuาLํยA๗์๙atQฦุrสึฝI?ฎs?พx\„9๛ฝลซld Sov7)nฮžsข>สžฺภู?Ž๙๘ร ๚ัๅv]๘}ซ๘๓/ญ๚xo’dิป—ใ๋ŸY๗;หมNŒมจ“i0\q๓OAmฟ}๘ฦšร5ํ,่7พ์~ตแ๗m{๋€–duw/ะม#ขฅราฃฌU็ ๊1#SBx`ซฮkต๖xฐW‘ฃ๓ธ\œpบ0[]^‰^32ึ]ฆEว๒ cMIiฃŒฯP;*)e8ฏฉ\/ŽŠ0–ิXผ?๏ฦx\ฃ^o%(kซษ,ธeJฅญ1ืไ"Ztอ‘‰JqตีฦT’ฐXr…ฬ\y€รโ_งะบญm๚*]ซM‘ค๗\’1 ฝmšA6@xO›ษคH เˆdฒX .Lw^ }pั๒ฤ๓kž?q๎ว๚‡W=›Š@ุใ๓าถ}ๆcใ~fg…n๗ oถฒYtพ๒fสลีำ™๐็๖ioฯJfm=xาขgจoL™0}ษ๖๔)Xหฮ˜‘!ฮศ:yฑฆ;~ข๘ซ—&>ถ่็๐ณฤ€€‡พžTธaึฤGฆฏ-nษหHุZ—>๘สŠไ‚uO>๚ศ๔ืฟฉ่i‡ษ$ฦ†๐ิ9ฏ*\๛ฤ๘วŸi™ฐ์ v/!วฒฒฒๆ{๙ล=๒<ศภI ฎ฿ดๅ„y3xŸฏ;B฿;:šฅ7}๗ธšพ~>+kปgฉŸVfeeeeตŸฒหุ€05Mธwมคษดฃg>ุำs๓๎พ3™ค๑dVึฬ”้๗อฯสสสสšE-4UVˆCBpษ}+๖|2+ิมมบชJ๊&Lฆฮ{-ํ๔†aKa{่Ž๋uฒ†˜‡โ๎š7๑๑…‰yyVFวํ4r๔˜oอžต๖\ยฟf๑€eิลธ๊/ๆไœญ0า-%99999๕N0Wๆๆไไ6๘`dApTˆปๆB๎ู3๙uv‡๎b‰พ}›(‘Fรฉฟ”›{นEุ>Bคงถส ‰ ลjห๕ Tˆ๚ฦ%KM~qS๛OฎXฤ'7Wภ—‹OŒW‹\.Ÿฯg) „ม@ษ|‘\ๆ0š๚"ฯ๎;Hkซ`๗`ง.ๆ€๔–kฒXฝ^#•ํ_1ฤอTH€ @€ำฆ;p"๔ง_48 ง~9/HHP€Qงณเ8††sไ)ษ‘lB6อฟฟlฅ/วrII ถ’8†๓T*)fาๆ์[ฟ๙วVใ้S—Sำำx๒QaงN^่|ๅกm๛Kฬ”ฃไ\ก+4L ๑๔งพฯkvธŒ—ตiอก œญ๕จฤ้cnทฅJ[฿ำ4ฃIL Qy›g.ุQะๆฐึ‘WไMุู<๒<ศ@‘๋ฐํๅฟbทy<Ko2๚๎y1ยุ€#๏่ั*;e.สฟ์€žf<บ๛๎ฑI•Uu!!Aัƒ’•1ร“มมAีUu›ฤK™๓Zฦ๏๋ทัรKึ๎ธ^'๋`จ:๒‡+l”ฃ์%:2ฒร$๗Ÿ|~ชฒฉ๎ิ๒\!กJ`uˆ›†ptํnŠqฅาฎฤิTำh%hสjดPA{†d6)’"mFƒ›คH ว˜๚\ ำDฦ'งฆฦ๐ซ8Žำ4๑%2™ˆCำŽใ,%œFGฎVษIƒ๑ŽผA้ืฌ(จฉฉ‰ŒŒ8p ว๓n„rืf)4ัใ”I|q ŒK› ็vฯ็แ๑ธ$ูแA<.h]พvเฒ_ฟ`ฑ6ๆฝ๛Y6!›ฮฐษ๗<@W่ะฒžฎ฿ฟ้รจ—–l*˜จอ๛yื–ŽWนšNช™1M™10็‡ณ]owฮ?P4…cx{Cั๑gk๙้“์ญsนW์F“'M^นtb<pcา`่!ฌt๗ศ๓ 3ยุ›Œพ{Gž7t5๕๛^}กG Œฝ้™IM•UcbฃCZ~๚I4 )D้จฮํญIขqooลหทM;ใฃูvG—Nถมpต›\nวํดหN’$}g" nงู&6<Š$ฆส c—œพ๒ก๏ฒUF8๒˜ม งพกฑดฺ`uSEaFถ”œmเcEณ”ซม(J uืธ๑เ[kญ‚9 ฝๅš,–ขจชชชชช*(F ๚5TกษJi’Rก‚ถษ`ผq„ œำ๑{—รแ ™ธhT๖s.ฟf’ŠQศชณ๚๋%ณvึธจญ๘ภ๚…€'‹1cลฺๅ๓ๆ  ห>ี๖^FRชrศ๙์ต=อฏ6*0Kซีอุ:I’WJ๖๛žษ$ฆ†ว/˜n๛วŒ้'-”rสึoRn์์๑"ศŒ0๕&ณ๏^๔‘ว ๕V“บ๒Nช*-“ำHสŽ ~vtŠฐถ ฺk“์วV/jป๎๙{พ[s’uA็กนแ`เrนn‚},3@็๛“lนวฮ eฝƒฏ‰‘ทœ-๎G3x`hฐซ:ทจ้๊aIธ\ภ็sHเ๓๙.—“ฅ$–ึfซภๆ!pฤJ•„4ตK@z ฺi q—าj256(,d8ฮ๊•P/จ-ืgŸ,็ 5ฃ๏M%หห›x\~`PŸรแp๐ฎ็kŒBfjสต๊แ™‘A”ฟญŸ™ย๖ไ‹žฒ์• รฃ”\ทQฏ7‘๓UงฒษŒูS†_>™ำSเkหตมcฆ๐$Qญูณ๖![๋๕ตuก้c•ส˜{็>=Zยฎ’ู$ฆ†8\ฎP"ยA 2!McSEDH๙ฝฝ\zdF˜z“ูw๛ศ‹†z ซIอ Cว ำ(‚ข"”hฌช •f++.)มฦŒก+ซ7a’๛าŽฟฆ,~y4๛9ฯปƒu0Dฦj๘8O5๚TGqq Kuึ/DO}kฒ7{eœฐgoWƒcฯว1 รn๑Œ++\.—vนฎOLMmmbM˜Œวแ•กAXkซญ$ะฆšKล ๕fWˆB$ฦล'วจ:ฏœL้5hฤŠอTH„฿ฯ็ƒณฌ/พKำัอ›ฏXณ๗)ูX๐๏ีkฯัuGvT~ถ๛็g€ด้ฮ๏Z๓ฦฎ‹ŒยธE๛ทMUภ๎์นP๖ษŒู_ิšn~๐๏;Wมฑ๋ฮ|ฑพœu ชญจ”;็ๅ๗^ŒTqLe'?z็ปฮ๕€ลงN)ŸšRถ~mWlำัอ›-_ฑ๓ฐšgญ๚ณ‡[€ฑ๕ึฃ๗yีึฏงiฟzk๗ฉIณูu2šฤุะ‘OŒ]ถ๏‡Eญy๛6.}๗ั ็ๆ็OcHื_eฯ๋|อŸๆศ{~ืb๊Mf฿=๏#ฯ๊%ฌ&ู๙tหุทๅTพ๕–็—l +ซ vฐถฬ^฿Vขฌฎพ9“œษตbA๚ำฮ0~ม=๏ŽzฦมP6wซฤŽฺs{Wnศg5‰๕‹`จผTkTฺŠkะL,@ืฉ™Q0t่๋์C†eดฟสG“N“ฎดคŽuสึ€ฎNสTwฟฅ$งด•lฉ,ววมง]i•ญค๋:]%9๗E\z’ฆ}๓ื™j ›Šฮh เถ[ด::ฟŒ้-˜Pˆ~"๘&3sสปFส๏“๒0พ์‘p5่๒_ซปƒ~}ซŒcาk‡ญ€๑bglหิษ…“6_่ƒ๖น<อ๓ซฟิ‹oโ“ห˜Ÿภ๙พ 2โฦ๔บ;|ป7๓Žo(ธ2!Mcฬ-j"pQDJ2ท๒\%๋~weTD กฏิ9ไ‘‘คพRg"๛Dุoษฬฬผ๚4‹ธKƒศฃ]ฺํ‡บป(…wแŽ?น`๏กนn‚ฆi อ—wญ+r„}าผไต_nธ|่ท๎ชX"ปบ{AแงP––ๆฐ่ิ‘ํ๏ึั„EW~]J8’@ตฺmฉาbe๛S฿4‹`ๆฮž‹E ฤ-P|ฦแ๓น4แtSศพ๖[ะ\,@ „A“ฎŽrป>๔ะ_@{ @ ”ล"@ ”ล"@ ญ‹ล$กใ‚8€cึšmซ๗{฿‰ย‡&๓*n~ณ ฎ42iPจฝ๔๒ถA@X\Lˆ\ฤ!f}eyั ธ$8>.\!โาn›AWกmด๖t^q7ธPฉ’๒1ยnะiหฌ€@; R%แใ4้47V–ี{:Sฆ›N๏Jz^แ?๐้๘จ{bšศญบธฉษ7m”Œ฿๔๒Q€แ8MQ`๎ต๑๏ัGอEฯ๚๏ืๆ>า‡ ๔ไสๅOคG -—?[๒าWๅ>๕ใฯฺŒ•วฺ฿ดเ_ŸLำ†W}:๓้^ur" 2โฮ‡œ2TR{NkคbFฦบ ๓uwฬ4ะม#ขฏ>uฃฅ$งด•)‘Fฌ1-7ะ€ซำ๘5็/2o–๑8ณ ˆ™ยํ<ท™ิ_>ซํf>สbิม„.ฟจE14>Hะชป•ัjโใBๅธีruฃ กtอฅ๓-NL’ฃฬ/m%yš่h~kแ๙z;& ML‰Qท62oฮจSอo.ส+r`’ˆคคHUs‘žk"Uฮš —[ Mฎl0v;Yฎž—๔ผ:ยS’ยb—s‹*›มb๓๏ƒอญ‡—Ž= hห~…๐žง็ษŽ=๕๘zL,่๚โ6๚ษฦ&๛๙ฎซ๗ฅญป†.>ธ๔๖X‰@>AjAKตัวj๔?Mล็Z:0เศcSBฌ6`N$82… fL&—แเW™ผ็™ุk๒/๘vveฑฆสผ๖k2MST๛x ˆ๋.ำ‰ขc๙„ฑฆคดัF€@$ๅQNc}…ถL€8bุะ@Jfุช๓ผ๚5ๆถถ้ซtญ6E’R)ใ‰ล|sƒN€E฿๊ •I ี$เqzฝ• ฌญ&gฐPภk&x€Ljึฺ0Wœi—’„›โ‘$$I‘n‚uv—Iง%=ฏŽ๐Yฬ็ƒB``Hภ(ฌ4\ฐ๛w"หv฿ซ+^ผ?)lศบ็ ฌ%Cว.|}ธ$ัp๎ซwืY`nฯ‰[ึ~ฝ`a–ฺtv๛›+๗kษธ9{vฮ‰๘({*@ว๙UŒีA9e๋คืน_<.ยœโี?6ฒดฎฬœท๊ีI)*ชฑเภkถŸa}ุpลค?ต๖แkืP, 1๚ŽG๗๊๒_’šc,yบwีPฬพƒ8eฦสe3ำฃ„ๆŠœƒŸ~ฒ๛t‹Eศ€fฺ๖oธgฯ๓ ใ@ฏฎSพส>™๑k kW๔Mˆ~†0Hอkพj>ใ+ใใ‚๘nCMiGฮภW‘ฃ๓ธ\œpบ0[]^‰^ฬrฦgจ•”2œืTฎGEห j,ท*eฆIทซใ…qDจิPS๊`K$,ท\!3Wเฐ๘ืๆžgV}‚๏ึลŠCS†$)ญบ–ฎซบHฃแิ_สอฝ"Œฤ€ฃŽ‰—ZสฮŸ9{ฑ– .[ํ…œœ 56WCaNNNNŽทHkซ`ฟvsย้ข$ 0B.โ๑ธ`ฉษ/๎xhฬ‹๘มh&\.ฦลa‰รFฆงฏaฮ๚’r"|DzZZฦ`ฅแฒถ•5‹eา้EIฯซ#<ภผCซ=bฆgkตkต6‘ฑ•>ธhyโ๙5OŽŸ8๗cรซžMe=ฺP๚เ+oฆ\\=ํ‘ ฯ}nŸ๖๖ฌไy์๘‰โฏ^š๘ุขŸรฬ@ปใษฌฌ™(ำ๏›Ÿ••••ี>๏หV„ฉiยฝ &M =๓ม–ฦ๑ิ9ฏ*\๛ฤ๘วŸi™ฐ์‰d–rํฤ<wืผ‰/Oฬหณ2:ฏab๔=เแ…ฏ'n˜5๑‘้+‹[๒๒6ใƒ'-z†๚fม” ำ—lฯIO‘ฒ ™h๚๚๙ฌฌ๑๏žฅ~Z™••••ี~&m๛eeeอถ•ญZ'}dขฟ!Vซ๑ๆๆ+‡ว ีกขถาr“ธ#g`Dโฎน{๖L~กปXขoฟzwO9คงถส ‰ ลjห๕ Tˆ๚ุ%&pEhึจkฃ€-‘ Jฎเ‹ไ2‡ัไ_SำžgV œžž–6"5e@ฐฤ' จoฒX\ฤi)),(hฤGศ:ล๖ฆšF+ASVฃ…๘ K\†f ดซตูศ“Hx>iฟดกถย02#mไฐ‘๛สCx\ ำDฦ'งฆฦ๐ซฝK—1ภeRบฎ๐นrณ$6Fอ^PlŒธญไbAมลJ{P|ธิฯ@พ[q[N45]pกmm:ิ”k๏iด฿™ ?}ขม้h8๕หyAB‚ช‡’อฟฟlฅ/วrIIŠvyๅกm๛Kฬ”ฃไ\ก+4L้mupไ=ZeงฬE๙— `ฉMๅmžน`GA›รZG^uPPPNU๙ฟร6สQvู้Qท†}ˆ ?๕}^ณรeผฏMkUเlฦใฮ Pฉค˜I›ณoๆ[Mxห่]ˆ~†4(ˆา7ฎœ๚๊บ6ปหัึjขsFGืฆฆW*ํJLปงfƒ‘")าf4ธIŠฤ๐p‡ๆjTฝพรOฦDœFGฎVษIƒั๎EfVึฺ‚๓๒๓๓ .Uš„ัฑมพธX]ณขว๑จจจ   .๗ฦ+ ฎ>;ขนั5…sฐๆš+c’พ๒ก}่`&Nฆข็หFTffๆ [gฤก/ป ืrpšค8มƒยdyฬเ…S฿ะXZmฐบฝ)4ะฦฆ+Aalhฑ“J ษฌ ด7•š์4€ณพ%|จZVm1zฉธืฐE้&ธa`~ว%ษŽ >A<.๋๏F6yใžเ บยŽ[H็J| h วX๖ฒU๏ข~฿ซ/ฐ)Nšผr้ฤxแฦคมpถgงฎ6ฉ๛ตชซ!F฿y<.AtญๅงOฒ_ฟำ‡Q/-ูT0Q›๗๓ฎ-ฏr3 oฝ 2ัฏ "๔…W?=ง;ฟ4M๗”8อ6iฐแQ$้4UV\นใvK9๚˜,Pnoซ๎œLcJ$ซม(J uืธ๑เhฎ๗xžYQ„หู๑ณกล*๔๚MŸk๎‘‘‘Bกฐ  ภ้ผโ๋ำ&‡พ๔ขƒๆhšv4\ฮฏ๋–ชำ@หฐ๋žWyด๑คA จ7น€วใn vU็\ซ๚๊ IDAT1ผ}ล+UาิbtฐwA\[ฆi วm๏pฟ๒Kฯ–deŸ&‚ภ9ฉ'‡รน~_[ฒ๚๋%ณvึxคท[J๋]๕๋ัŒ_0๖ำOZ(ๅ”ญ฿คxXหๅบูŸ^1๚~ต*0Kซีอlผญ๘ภ๚…€'‹1cลฺๅ๓ๆฬ,์#zdIŸ๏Oฒๅ;รฒvธ`rตสฉฯฟ‰$†ฏ‰‘ทœ-๖“E`นŒ46t&=Œ‰–ึfซภๆึ'fฯ3+AP|,ฟกHg฿าธfjEฅRUUU0…ํป/Sq\?0Lฺูพ้ไ(๘<พHศ๓kธ,$.&Tฦร9‚ภะ žัdเrนดหลt… HŒ‹OŽQ๕ดภ‚2ญ2Mˆ„‹ใyˆJh2[›อ T pภ8โ @ฑอf๗Fง—%/ฉ-ืgŸ,็ 5ฃ๏M%หหYSฎšrญzxfค@7ๅo๋gฆ๔ธฺงนก1`่˜aEPT„’ใu๕๋แpนB‰jศ„4M!ๅณ"c5|œง}oชฃธธ…ญฃ๏ตๅฺเ1 S x’จวึ์Y๛Œลx,zสฒW& RrFฝDP,ย>ฃ—AŽž๚ึบeoผ๗ส8aฺˆ@ธBhำทฬฃ รx|>Žaึf\YแHyซต๓ฟŒ‰D;ดฉๆRqƒฝูdVnš#Sซๅ|รyRJlฑXjyีแ๓๙v{Ÿ†ะWVJใ“GDr1าiะ•:๏dKm•rภภิŒ4U],j๒&‘Vฤฅ'i800S dSัญกกขR7 5„C9อMeฺV€ƒฎNสTwUl฿ผ v‹ƒเ‘Vฃฮฦ๒JQ\bj$—vZ๔eฺfฬuๅM๑ั)#ในดfจฎh์ดCž—dซŽ@ฐc:บyำเk๖>ฅ  ฝzํ9ึืฬG7ฟ?๘๗ฟซเุugพX_ใํลหง[ฦพ๗/ง๒ญ็ถ<ฟไ`ƒwีฏงศงฦ.๗รขึผ}—พ๛่†m๏ภs๓ฟฌg.6wซฤŽฺs{Wnศg๕ˆัwำัอ›-_ฑ๓ฐšgญ๚ณ‡[X|วฺŠJนs^~๏ลHวTv๒ฃwพkezAื_eฯุ๋ธ eัmS/Kปณ็vnGฝฒก๒RญQi+ฎA3ฑˆ~ฎP+ฌ๚Š›Zใะืู‡ หh‘&&]iIๅ•n˜T"ถฎฺmมษ”H\[ฅ-‡๐3+ชตถR74‡“.Kซถ'[ดcBแ•๊™™™>˜๖ผd/al่–ต๎/๔E@พษฬœ‚‚Œ่w  qใบ 'hเpe๓น’–›x˜+า4ฦข&Eค$s+oศ$C ŒŠ$๔•:‡<22ิW๊Ldo…Wเศยbิœถšš›8ผ๊Vq]ยƒb#ธepU๊ƒพํๆึใP––fnx๊ศ#FŒ1"5I้ิ้}๑dฺOเHีj…ฎXูก๗ย+`"…Zญ๛่$[‚?ูŠ@ ๎z๒฿l๖ํถ@๔ข้๒ูฆ›ฎํjี^ผต{๕'์บห็›h‚ช๒y=ฒX/…W šKฯ0ขNฤveฑ@ ~Mบ:vหํ๚ะkแUn&iๆ&WฒeฉŒ กEฑื‚@ โnญ‹E @๘พษb๙ฑฑกlส๐€ะุุ๐@ึใไ่ฃ/hเ7™™kBXถ€็จWff~ำ/๑†‡ข24๓›Q พ6๒ภ๗ฺ–/;7Ÿญšš,ดเ_'Nœ8q2{ืฌ่m_=๋๓‹†๖๎แK๖DhEฤƒž\ฯCว>vเร๑ย๐ฉ=๒฿ใdgํŽพ4่—pคa‰CGfdคH w …!)้i Aw'โHC™ž‘>rXrิี๓A\iไเŒŒ๘ภ๋+ˆย‡Žส์ณdV~W1pุศ๔๔CB$฿”๔ผq๖?๑4ััึย๓๕vLš˜ฃn-lเศR0˜1™\†C๛ฉjŽ๚ข อเb[L6—_0ปฑณ—์eCจบ๚ศ๏ ฬหหณนŠiั*อํถฅ/ ๒ทW#ณdึR-่ส]Tดmล—ถe์Vบ๘เาmŽ๐žง็ษŽ=๕๘zL,่:ดฅแืO66ูฯ›:บ่ ไ5็็68วบ๖rถVk]”‰๕ค์Š0$6kผ˜ไเHฃ’“"Mgห ดP*วญ–๎ว8๑4ักืี[0dV~ฎŒIด—”YqElrBธ9ฏše็3ฯKzAYฌ€ว5๊๕V‚ฐถšœมB! `ฑธๅ ˜น๒‡ฅใ /Štปh ุัก)ทหลg/J๖ฒ!T}ิoะ(c^Š Jเƒแช+žL67:d˜ˆKบ,งk+ฏูNะŽ zธ\›ล2””ว๎Jจ–gชศ/Ÿูfd*y‹]๕แIพ{้rซ ภทง็?3<Šหโกcพ>\’‚h8๗ีป๋ฟ,0€2sชW'ฅจจฦ‚ฌู~ฆ @9e๋คืน_<.ยœโี?2kdฎ>t๑มล-kฟŒ^ฐ0Km:ปอ•๛ตคไแwO๚}๊ผ}zˆ›ป็๑†I›Yเbฒ“Igœ=;็D|”= ๓๘+f7™๘ส›)WO{dยsŸงฝ=+๐ิ9ฏ*\๛ฤ๘วŸi™ฐ์‰ไฎายิ4แ“&oะŽž๙`‹Jึ๊ฑใ'Šฟziโc‹~_0๛O<๋oูy32คมฒS'/ฒT˜์dิฉ๑dVึฬ”้๗อฯสสสสj?ู‹ญzwKJ|eErมบ'}d๚๋฿T๔๐รฅ้๋็ณฒฦฟ{–๚ieVVVVึณ_ึ@๛eeeอ๖†๛Z๖ึxย฿pี_ฬษ9[aค[Jrrrrr ๊`ฎฬอษษ)lธ๑ฉด‚เจwอ…ณg๒๋์ล}๛CF‘Fรฉฟ”›{นEุพŸฟTเิV$QกXmน”Š>บ|;ZkL$`\ฉLBZฌn ญญzƒฝ๛PQX”สR]kพ๚สว”Y๙\\.: <1^-rน\|>๛5ž—๔†ž฿๎ย2Md|rjj ฏฑชฑcŽi4pไj•œ4;“าn2,Nึy>งล`09<ุ„์F%{ูช๎ƒ>๊'$18˜๊ฟlhุup‹0  fc๓ฏFร๗-ภ$ษR–•7Œ%]ๆ_›Zส ฺ™฿ิtผฉนศๅฮ †]} ้tธYฦ‰LHhํ๘e+E่9–ซHJRPy›g.ุQะๆฐึ‘WิUฺ‘w๔h•2ๅ_vb-ึ๊•‡ถํ/1SŽ’s…ฎะ0%OŸบœšžฦส;u๒‚Wv2๋๔ชzwKF%&่Oปhtป-Uฺ๚[ฝ ธ็ฦ#w„ฃkOSŒ+•v%ฆ๖ฆšF+ASVฃ…ฺ3$ณมH‘i3$Eb8ฦคะ7p4I™™ฃFฤ๑uEีf๖D”งŽก๋ชZฎ๛eฬY๙8Žำ4๑%2™ˆCำŽณพ~ใqIo่aEG38Aแิ74–VฌWญฃ()ิ]Wเฦƒ%ฮๆŠขfvMคกบจ‡'j^”์eCจ๚MW๏w`€ค้๋„\€uโ็*098Sj%o/๔5ฑภpœฆุฎ…<7l๒ฦ=ภ:t…|'M^นtb<pcา`8ฝVพW_`ožญz—UMแะt๊Tอ์Œ!๘oสŒ9?œe%ฃฬ:ฝฉ#ฦ’\.—$o[?{n<qืแ4คqร†G‘คำTYa์’ำW>๔aถสูT”ำ„qE๊ธฤpฉค…qR—EFŠ๔%ลN€๋G๎žY๙EaFถ”œmเc๋สDฯKz{‹†ปชs‹šฎ”†ฅตู*pท9 ๓…oก:>6ˆh(ฉjcผ่sฃC8อZญพ๛g๏J๖ฒ!T}ิ_ i.Žทk’ฆ s‹๖ตsปภMฐ<b-IS4†qฑฮ+ข็:o/&“I เธ๚‘งJŸ™ฟ๑”G‚ ชฟ^2kgอU2อ๘ำm˜1ค…RNู๚MŠ—ญ{U]—}ชํฝŒคTๅ๓ูk{&“์tKi=ฏฮX’$Iœำกฯ7s=ะ ใ@็๛“lนวฮิ๙ำั‘ฤอภืฤศ ฮ๗ฃนŽXฅไš๕&ะ„ฝอไŽUHกฅฉคH!็ ƒGuny"ห”ึ^(ฦฬส? \.เ๓9ํs;|>฿ๅ๊J"8bฅJBšZŒ๊%{๛ต™หๅา.ใj0ฺTsฉธแช๕วธP*—K๘l?~0พD.x๐๖F%{ูช๎ƒ>๊'ธ\zi`๘จุ…ก’กร\J@€T‘*'วญ”๐จL˜ชั< ’ส@ @ฃ-แ2—pีฺI๙ฤ˜ฐ๑aai็ลผโแMค dqM๚“9ขžฅhMนV=<3R ˆ›๒ท๕3Sx.W(แ P ™ฆฑฉ""ค|/๔ฎzีฉl2c๖”แ—Oๆ๔๔..“์474 3LฃŠŠPrผชฮXฒพถ.4}lขRs๏งGKุ๊๚†^=๕ญuหx๏•qยพ5่เฦใ๓q ปvีmE,ๅba \์pฐ]ูฌี็s:ศญ4Q๚โœ ตษTทฬสO0ตต‰5a2‡#T†aญญ/l‰B$ฦล'วจ๐•์ =ฌ(ภW'eชป฿R’S๊บฎDวฒีไ^ 4ไ0ัx๙๗&๖?{Qฒ— ก๊>่ฃ~‚ปyo]ะโPษHq๋ฦzKวฎ{”แŠซ๐่gƒ๘ิg๏ฬใ›จึ‡ฬdฒงIšฅi้พฺZ(ฅะRธกพ. €ข\\@-‚\. xธp‘‹หๅ (Š ›ˆpั" Šbูd+-K[บ/้’ดMาคYg๒‘า:“&4t๓|?žyž๓<็œ้ฬ3gฮœc+mฌฮ6R€๛MŒŠJvY ^Œ PWOVาi8ฯTeฑร๏R†>MYพoVŸต2i๖5ชฟY๙a๐฿฿–ฉd5—Ÿ๖ฮถซN€ฤ๙๛6Nqoฯžี๚{๓กต ~ํƒogIYf๕™ฏVj~ถฬ’=?ฮoฬูณz๑{ฝป๑฿๐œž>*ำ›_fR/8~\๖๔ไขU+^ฑ้โdฦ|๔ณฦผ๕ฏS8ฆ๓mัZฯอi5mฺqื๋พ~ผdื›OšUDปฒgท.\@ @WvฅJ/k)จD#ฑˆ~Kษ้aญ ะ)Z4ีๆ!Cำ\฿6:IซA}ญฐฺุsา@6T–๛วฤ "0สnึWป’QiTj|€kl่Žt%๕๙gJบžน‡๕ฦtˆn@6” ข#“R8N‹N}ญบm๑,ปูhqฐI“ลู•fwภxผ๖ง๗๔๔๔SงNB)\YXˆฟCSฆ6ะฟญŠPฒš*+ปบฦvฅูMGศs๓ฝ้้“o้d@ BฐูNŽ๊ฎWu๏๑_?๊“ห่๘๐†‚หbG่ฯๅื“8?$1(;_ึ์“ย๛>mทr‹$4ิŸtำo‡ฐฯrSฆ๊›wฃ,กฟR)ๅ3พญๆK•J™ภƒ8บา์ฆ#d๎ƒ>B บƒ๐‡Ž์[๛WฦQ ‹@ ผ…26h‰เไแ))))))ษ๑2ซZ๓'บ”ดส ฌํž~;„฿Œลb,‡p:ฌv†๔ลๆ˜รf#ป|a…f7!sฯอัX,@ |บก๘Šถ[9ีแž~;„}–›2U฿Œฝ9I›ี]ฅIปรžkvำ2ฟes@ ฝK๛ญผร=v๛ }๒kk@ ย-(‹E @๔?<หbqฟ ศศ`ฦ-o9!‘‘A~ŒŽuacŽน๚@ ขเa+๐WฉBฦIด„HฎR๙ 3ค.ฬ{ฬ2๗A!๚$ย๑kŽ;v์ุฑ฿ณณ]?ฒ–คuปิ;็~ใ*s[fธ‚D๔QwN]๕ๅwG~9ผ“ัฝ โO'(ฑu‘๏?เค‘้7ิ—…Nk—ˆยSาSฃฅ.KKฤํ…8oBrวะแฉฉ)Cb…n๗N๒\ำs็i‘ฺโ‹ฐ3nณcฉษฟจำคเฎฬ{ฬ2๗A!๚$ฆฌลcฒ iแ…๕sZืา๏6Wึuฬ:HZx`ฑOŠC๔Mx๗ฬl๑แงู]ƒ ธe jขภbฺูึq็DGIp“๑ฆฟ4–X*]3&–ˆq่Wwb\๋oพ–Wdยฅ‘ ฑมอ9 +Ÿyฎ้{ดœ”fณ3ฏ“E‘v›อN1๏สผว!s๔ั@A,ดh๐ฐ/ำาพ6xพJ8P็Rเƒ๎Yด๎๋ƒG๗ีš)R—P2bๆ‡_ํ?u๘ทŸ๗๏ส๑B&!}™Acฌ•๕ใก}๙ฏง†๘1;OZx`Kfฺุ7ทfx๐ซทว‡โฬๆฒษ๋ฟ๐K68ใ๖ทPนฉQศ=‹>ฺ•u๘็C฿lXr๕2้ชI[ฆวมำ:ขญQาย[žvm$รgm~*ˆฉHzMAโ“ซพ๎ศัร๛>็sฃƒ]งข,}๖w๚๙ศม-๕๚ myQฃฮญ๐๘ฆ์์#o>t๖Ž=๔มD…ปเ;๗&}#ำu}วัO ดBฯอ}–4*%%Z๊•ใส"’Gคฆฆ$ล๙นb#$! CS†H™–’œ<ห้คpœ๑๓5ฝมรyฑบŠ|›ใVmiพ๖ึอ{ฬ2ฟe๓†ณ”œฆ๚ฯ์…l6A’ญ|‡รม&ุเT็–ฑd๛ื/Mu9๏ฝ€IศTๆ วV๏ธฯฯขพ์๎yฺyน‰rRAxb^ณ็•ุ฿.y๎Hว™ตIส&Žึ™ŠOฮ\Mบ2ฝžM็ˆถFคf฿š๕a/-ฺ๔ดสQ•๓หถ>>RnAco,žอvุ1‘ Z{ƒถผช‘๛V๊๗u๏ุศัถ'm๐ด B+๔ั็ภ1wb-•๔m )†qU๑Cๅเ,าbdN8ญอ-ขจกรยHาj(+ีทษํ?๚ภ&ชธ84”ฏ),ฐx๒งfา้๙๑A๖๊<;๎fFU฿ƒข( รศ†ยณ „ ฃ'.zฎ้ ž]ƒYแq,mI‰†~ๆ?Oฉpิ–7ัŽๅuecŽน๚h`เค์|ืs9ื/CHิuืl๊=ŽG8œี๚ผหbฑ@ภฤ๙#ณŸh้ ฉ;ญฑฬŠฏenญ๔*‚ ์ป7ๆvC]•ฮ{[pฟ36š์tี์n๐ดŽhkไคœํšnG่5[ ๖ฏšทุโ๐”'—ญX:1gฮท๘๘นOด|๚ไฟ)ูไu{€ฉnญF๎[ฉKฺ๊๎น#ฆŽฃ žฆAดดB/ฬ„ัw฿r๎๐™j zJ[tล*ซ/j$œNงฅ๖jnu—_6q"$Myg ๚๚ซCพTยแrผ>O^œ.ชบxฑŠaา+ฦFญ‰koฒ€๐๔ › 8 วfkK"X™\H๔ช อnเูx.ฦJ$~\ฦepžH"r˜~บ2๏1Gศ}40ฐ‹ ๒๔L`เณQqฏฤล70็ลV—จา๏Mpxฃ๎N&‹‹ตl‚ใฏPpX, o{ฟF+คงฒธD9,=” ภšUำ3๘…Fppถ|ิษ–‚‚oอ้k4z์P9—- {x๙Žcล ี์n๐ดŽhkT[ฃ๑q2y๔}/=๗ฦโ4ฑ๐ษKL&#์zฦ@P,‚เ ๙8pๅC&Œh‘‡„ˆ88}yW#ฯZ‰‰ฮu๗m{าO ดBฯอ |ส›+—ผ๖‚๛yึq[pซJEญ฿vYฬ-ฑ”‡เ‚ภ่;‰_Lc›รม1 ร๚ภˆ+3ฆŠ งZ9Wf 4งSXp*ฏิ๖ฏ/ป MM‚€Ab6‹ล“)ฐฦฦ–ึภ˜ธจ่„9•fw๐l,ึQw๕t}๛คNดTๆžฎb>•y9Bๆ>่ฃฅRXษ ธ/,ŒEZ/ึT์ึ ศบญ]3xู๒OKษบผฝณโผ ๚เ็e›ท2ศ๕…mห_v‰V5฿ฦ)Jุž= Š6<9ซชๆCk?ฺ฿ฮ’ฒฬ๊3_ญ*v๗พึoฤœ฿ฟ-ฐT฿ฦปนN๐สœพFw.]ถ5Kษ6•Ÿผ:ซกš๔x๎ึm4฿oุž๑ึบ—๏ฏh*s๐ดšM๙ืˆ/ฟbจœe(๚ใ฿??fษž็7ๆ์Yฝ๘ฝ‡๘ox~myW#ฯZ‰‰ฮu๗m{าั5ญะssะ•]ฉาหZ *ัHl_jฎ,iJŠ—ไ–่I‡ฆฌLJ`คUง.našjัT›‡ Ms}๊$ญ๕ตยjcฯEMคQฉ๑ฎฤŽt%๕๙g๊oPภ๚ยt/ สŠั‘I)งEงพV๖ฒศn6Zlาdqvฅู0ฏน4==ิฉS4Z,๑ %ซฉฒฒ‘ฯŸ+ ๑whสิ๚ที]˜๗˜#d๎น๙๔๔ษด'ขŸรพ็ƒใ˜๔๗,`์ศ้Ÿ|(hJ๎c…“ึ^์ž+฿.^่อัv\ท๛ศs^o"zPpY์ˆนz็‡$&e็หš}Rx฿งํVn‘„†๚“ฎ{๚ํ๖YnสT=‹ล๘Rฅ’mญaสXBฬ?w" IDATฅาn,Wwžลๆ‰y9Bๆ>่#D?ว~๙ื#S็๎n–แt:มู|uส|ปŽFุ‘"n€ถใz;(ขงกŒ ฺAแษรC\๏ฃบxภ~Ÿ™ถ[นC kปง฿aมณฑX`ฑนๆฐูVลวXแtXํ ้{ๆ=ๆ™{nŽฦbแะ ลWดสฉ๗๔!์ณาX,vซปJ9I›ใ]˜๗˜#d~หๆ@ z—๖[y‡{๚ํ๖ไJ๏@ ˆสb@ ฯฒX/(22ุŸqOŽHddใ๊n]˜w('ุ]9v„ฬป฿G@ }ณXฟJฅ2Nข%Dr•ส_ภ˜!ua^ŽPแฎœn;Bๆ๏#D_eุโฌ์cวŽ;๖ัŸlwๆPQoGtฯฒo~าอาเ)Ÿ:๘ฯ๛ลฝQรgm~*จk=่5๊#$-<ฐๅ้Žp! œ–ํ฿ต๘มI#ำ[ๅข๐”๔ิh)€หใาาq{$b_ภ œ~ฑ2feBrวะแฉฉ)Cb…พูeษณฌ…ิ_4€qc8KME-ุ˜&we†น6bs9v„ฬป฿Gˆ>Lัฆฉำฟชœ4ญอฏLu๚—ๅฝRR๛†ี๕ๆ h‰˜ฎx5B &ผ€่จ n2Zปบ`„ฑlืตd‰ฅ"ะ5cb‰‡t'ถืœohง%‰L 41๎ศ…ห"bอื๒ŠLธ42!6ธ9งข๛kคy6๋ค์6›y,ŠดlvŠ้xWๆ€แ,Ž8—ำmGศึ๛h !™“šพwhhš"ๆรi_%วŽ้?พ]BYjฮๆUฉT*ภƒฦ,Xป+๋วC๛๒_O ๑เ฿ฟ๚่†) —nฬ์]๛ๆzMูไu‡_๘๎%›q๛[จ@๘ไช/ฟ;r๔๐พฯ๙่`ื4ZsZ่อณhื๎ซ53RคŒฃf์ศฮ>+F9ๅใ์์์์lื๘\ายููฟ}ปŸฯฅต@'-<ฐ%3m์›[ณ~๚a็ฟr=๘KFฬ๐ซฒ๖๓ปฟ[9žqวXOCjญ๛ฮฌรGฒv.}}+cฯ“/jฤ`ช๙ใมฏŠป žฎšxศ=‹>ฺ•u๘็C฿lXrซ9mh{ำ๓3„V“ Lq๗k[๙a๛?'„ใŒมหฦฏ9๘ู3แ+nึW{๓/๗ฅฤŸB’04e๘ˆด‘i)ษษรใ”,ฟˆแIมELาˆิษq*ัiqม1C†%จฤŠศมษIกขด-–ิค)ฟzตขูั•—„„๐ตๅต’Uฃั.‘๒D?‹ฑ_ํB๋$ํถVyHWUห˜ƒ‹eฒ–บjƒ$- j-ศdพุ๘ณ,–ˆOMฬ่P2$55>€i`ืcsAฐr|็™{k>0แ*ฦŠฬฟhM8OฐbเlฎŽ๓‚R“BkjkD,x=๑า;?8แ๙-ๆว฿สL๓ษ์๓qฉฎไ((-Mtโ๘ ื^๒๎น“{ทdิดB@5iณิน“'<ฑhSn`jข™w‚ม|าธ หงŽŸ8๋อธทg&_ฟื์ฝไ๓ฉำ>-า์™“‘‘‘‘แฺJ*๗ƒ‡322ๆ|x“ฏศ๑ป^š๘๐_‚็N =2็ฏM›ฆ=<~ณ[Kี_x=‹i,ภใ@๔ภ‚e y+ง>๔เฏ๎-u\7๗ด=i๑ผFLDŒKl›=๑‘yฟFผœ™vJO๔้๖?*ต๊ฟ]คBCdŒ}ไฌ๓Ÿฌ ๛SŽ/ใพHDฟฤai[ิ#Dขถฤิ\_Ygr8)“Hqนฎ ฉYงงHŠlั๋์$Eb๘m‹๕ถ2<ะY]pำญUฏcI”r ฉำ3ฆ}–€ขั0N'ภq้tbกXฬg9Ž๛b•,็ล๊*๒unŽ[ตฅ๙Z_˜ป/ว‡Žน—ๆส้k[g๊1gผr@๑งฯL฿ญXฐ{9_ๆY€อ&=ถzว} x๕e@ใ๑์ฒiƒฑS๒ดธ?Ÿ#Qณ5{^yม๕c฿š๕a/-ฺ๔ดสQ•๓หถ>>Rn๏ฺผฝs’lฝ196q๓(c›wฏp^jฃœŽแเT็–ฑd๛ื/Mu9๏ฝ–ูึ๓ข]ณฃน‡ํูอyขI7_้ผำV“อ&ŽVกฉ๘ฤ๏ฬ5ขํMฯฯZM&ฺโ$IาU#ฆ>r\ๆuO=_ฝ1ซฮM !๚-ึๆQิะaa$i5”•๊ไฮ๖ฝŸญาƒ‹CC๙šย+ภMW“NฯฒW็ูqๆฉF}L์/17UtžEQ†‘ …gFน™>๊9žeฑ,๐ธ@–ถคDC!Oฉpิ–7ัŽๅyl"‹ŠRŒๅ๘ฮ2๗ึ|@C ค1h{ฮWJwฮxt๋ปชGลื‹2ทVจTŸ}\;%->Yžt้ฤJW3hาัRฐีผภ‡ง<นlลา‰9sพีv฿gตๆd,หแธy"ู t™ม10qศ์็Z๊ม'ž‡D’d›f่‚ r›!ย๎`ฬ iซูQˆ ฅ˜ฑัdงฏ]ozq†ะš{\#ฆ>โ›6‰{น,uฺ”cซฺ๎”ย่ป๎o9w๘LตฆTD!iส;[ะ//|ฉ„รๅy}!qบจ๊b1``lิšธ๖& ศะWJฤคฆ)ฑ,L.$ z เฐู€รaภแpl6_คž 0ŽP"๑ใ2พrลy"‰Dศaz๘๑ุœล๕sWŽ๏!soอํ๗Ÿ05s$*‹K”ราCนจษX5-ฑ๕๑_mMห|4ฅ(๛T๋ &อN`แ“—,˜0,LFุ๕ บo^U\ขJฟ7AยแŒบ;™,.v›สhk๋’F *ยBd^ณl‚ใฏPpX, ๏โข็!ีTUฅŽ‰“ษ"๎ž๕ฬจึฏล๋"|ส›+—ผ๖‚๛ฮ๘?'8†ฑ9ร0ฌฏŽธ2cชธpช•seJSp๊bU๋ว\NCๅ•‚ฺ~๕eW;?hบqx€!ฟžhššƒฤl‹' R`nฆxŒgcฑŽบซง๋฿Puขฅ2๗t๓qฯอซrOWปQ๔#d๎ฅ9ขaฟ๘ีึ’3&}yzW๕กต ~ํƒogIYf๕™ฏV_“+ฮฮ?7ญnํ๛ื—qjfา์DS5bฦห๏ฟ*gŠ~๘฿฿7v฿phํšมห–๏~ZJึๅ๏็ž‰ๆฃŸ}4ๆญํœย1่o‹ิ&-<๐๑cฎteW๖l(X?eๆฮ:ห๊ƒŸ—mหL [ิถ-m%ฺ๛†็!5ฺดใฎทื}xษฎ7ทŸ4ภซกลใ1โ7bฮฦ๏฿Xชฮ๏~ใ\ฦเiซi8ดvอK—mอRฒMๅง7ฏฮj`จFื›ดBฯอ้)qห™^;฿V}แ›7W]t2OY๔จz๓3,—spยส9้ฟญp=ช้สฎT้e-•h$ถcัT›‡ Ms}้$ญ๕ตย๊†O•เzคพ#] d}™ญฐหขฐ>;‚L$˜[ZnผฮุอF‹ƒMš,ืลdCY‘ :2)…ใด่ิืชปฟฬ`<^๛sizz๚ฉSงhดXโAJVSee#Ÿ?Wโ๏ะ”ฉ ๔oซ=5ทHBCIฦr|็™wiพ7=}2ํษ€@๔[ุ๗ผsp“žeŒ9“ลMZ{ฑทใ๒9I ,ฌŸใZภ่}|xCมeฑ#๔็๒๋Iœ’˜@”/k๖Iแ}ฺ|้v๛,7eชฮ(เK•J™€qเ–%๔W*ฅ|ฦทีžš™ปr|็™{kŽ@ ์—="™ฑ๛ป๛๖ํ๛v๏ื๏]ฟํ‡ @xelะมษรSRRRRR’ใeVตฦ'ƒzฺ|้v๛ žล‹อ%0‡อฦฐ*>ฦโpงรjgH฿=5งบ(วgŽy—ๆh,@ >P|mพt;„}–›2UวHปี]ฅœคอํqอป(วwŽน—ๆ@ zฺ|้v๛ พXs@ ่YP‹@ ่x–ลโ~A‘‘มŒป๑pC"#ƒ˜ ๓ุœใ์ฎ฿9Bๆš#@๔)<ฬb*•Bศ8‰–ษU*c†ไฉ9!Tธ+วwŽนทๆˆ>ŽpšcวŽ;v์๗์lืฌ%i.๕ฮน฿ธส–๎ƒ แ™[๖อO๊5๗มS>9t๐Ÿ๗‹{-ั ยoP”ิดิ”ก๑ก’๗8แ'LO‹๖w% บ#ixjZ๊๐ก aฎ‘#QxJzjดภๅqi้ƒƒธ=ท ฤ!w žšš2$6P่vฯ5=w๎‘ฉ-พhป…้ธฅ&ขlL“‚=6งj๓/60—ใ;Gศ[sDว”ตxL๘zกะ+๋:f$-<ฐุ'ล!|@ํoVื›/บึD =„_Hlณ๒ส…+&Œๅ^klฝฒยƒXถถuy‘!Xฅs๕–(,!>ิpถXภKE kฦฤ1๊NŒห"bอื๒ŠLธ42!6ธ9ง‚aๅ3ฯ5ฝภณ,ึIูm6 ทกHปอษ|csง๛r|็™{k>๐‹อ ส'H›๑DU้ZณฃทCบเƒ๎yeู‹๗ฦ๛“ต9๛>X๙๙yHFฬ|{มฤhก„gRkY%[Ÿ|=หD+ค/3hฬผW็/uิž฿๕ชyL๋'-<ฐฐaลฮ๐น๓ขh:นตๅY•€l๒บ๑?ญด?ฒ๐ๆ์๗พ๓SCœxศ=ฏ,}แล+Y๚kฟl\๙แJŠมป ๑ษ7–LK ใ5—ž:๐ู†ํ'ชm Bฯอiˆšฑc๋Œ0€ณง@ั†'งUลP#:Gž6ี'Ÿ2{bf๏ZCฌxtฅถ ฝŠ6<๙[แ๕=€:—๐๘'๋๒๑ีV…{๙๑ฎฃc฿ี๖ฎDoรลD ’๐p‡Y__Uกnฒ0ฑ„$$6"@ภ&aตa-ี9…Aฤ๐H{‘šแฯq่+ ฏีต8ฃำ”–2Jฬฎ/ึยB๔Ey•ฦp›c œๆZูFMฃ-H,„F. แkหj1‚V]ณฎฒYkฆœ@5๋ŒฮPžkึhดKค|h&$~cฺ…V,“ติ3ุH€ต64N&จ0ัo-๋นฆx6ฃ€ˆOM,`:.’šภ”{l.v[Ž๏!soอธ๔นธฐQ,ๆ‚ยมธ่˜‰้ถ z`าธ หงŽŸ8๋อธทg&c0่‘9mฺ4ํแ๑ใžZชย๋Y&!C™ ^Oผ๔ฮใNx~‹๙๑ท21n,ฑm๖ฤGๆ๑rfฺ๕๋ /yo๗Iฝ[2jฺ!Lq๚›๗jๅw3'>๘ฤ'ฃฝ|Ÿษปjาgฉฝs'OxbัฆภิDฃะss:J>Ÿš‘1ํำ"อž9ํc45ขqไqำ™OfŸKMฅฅ‰Nฟน<œ‘‘1็ถiฅ)ณพฌTˆ ๏YถcCf(U*uyJa}ฎ*"ุY{ๅนœJG"b~฿ฬU…ฺ+/ž;{&ทฺlQ_*ิธ†=๙ฌš+็ฮ]mเ…๛ป–๎qญ%ๅ:aXVUฌ™๔๖\่V%”J ภธR Ÿอnฝี๒…ษUอํ™ณฅฑฒึ@FˆฤBาhrํMํะ้(‰”ร—ˆ-zCฟN"ธฐูœ~มqัJพอfใp˜พฏ๑\ำ<หbVฃNgฐ0พ้'อฮhe็๓ิœดธ-วwŽนทๆ ž_,อzํoz Fภ„ nฎ™˜ะุXอ‰#—tVKํ๑ฃธฑฑrะซีFว0ภp–$1!€IศTฆ๖ไ‘ซ&สก9z๘œ4>^๊&€๒ƒ_d•ถP–ข Wœกก๒Vฉ%็ะกr3ีœŸ{ี\ฆ8Cขc4วศัZl๚ซ฿ฌY])ฮไวpถŸ\.ย %ง๖ฌZ๛S#0 =7๗บuvไyำg_JNฮคฅž<žห˜„า•YV^จฟ3A1,^ชR)*สซฝฏq{'ฅ@|ร›G‹ฎถคLkgดwXฺ5ล‘จ-15ืWึ™Nสค7R\ฎ+Cjึ้)’"[๔:;I‘~{ถฅr๊ชJ›b‡ง>4‚oทถŠูส๐@guyรอ๏๙X๑้้#Sข8๊Š๋ ฎUฏcI”r ฉำ๗ฏ'NวN'ฦŠล|–ำIแ8ใ็7kzƒ‡๓bu๙:7วญฺา|ญ/ฬ—ใCGศK๓†~สธ-r'`,เฑp€—ฤณูIถVหแpฐ 68ีน%w,ู๕ FS]ฮ{๏Ÿ`2•9่ฑี;๎sมณจ/ป{žv^nขœA|ฝฉู๓ส ฬqฒู„รั*4Ÿ๘ู{อพ5๋ร^Zด้i•ฃ*็—m}|คN/๔ึ่XฃฮŽผhบฦใูe3าcงไiq>ว|jา•Y_V๎7:2<ฐแ็Ÿ๙1๑2Kู๗ทZ!ย็˜๋ r:ฆ“”เฌ+ฉเ…Gฤฅ,†Fuyนึฬ4๊bmnE F’VCYฉพM๎lัำ›จZ4E5%,IR,ีƒฤ€‹CC๙šย+ภ_{YŸช#๘สจธธRุ&ždฏฮณใชพ[P…aูPxถ€PaใฬDฯ5ฝมณ,–ๅศา–”hฌดวyส่H…ฃถฐผ‰๖ZมœVณMุ"‹ŠRŒๅxใ™๛ึ| แt:šJ^ู:1ั๎ทy‡รณZŸwY,–รแ˜8d๖๓-ฝaฦญฑฬŠฏenญ๔*‚ ด1]œ7qฟ36š์๔[ ๖ฏšทุโ๐”'—ญX:1gฮทZZกๆLPN วบC uไMำีgืNI‹O–']:ฑาอ_%m™ๅeฦวRc„E‡ชfŽJไUๅU\?"Œพ๋๘–s‡ฯ0LE n;N‡ีB๓iช+นRW‚|IPtlT€แrํIส ˆ4ๅ-่Kฃl‘BŠ๋5;ฐูl‡ภ—J8\๎เ‘Aญ:โtQีลKัฌ1ุภ้07์‘R4ุcฃึฤต7Y@๎ฦQ฿รaณ‡รrq8›ญํrลศไBาะ wอpvฃู <ฯล8B‰ฤห๘ส็‰$!‡้แงƒ9ญf›ล๕sWŽ7Žนoอ–ๆk๐I“‚Uิ๒;c ศ@ชŠKT้๗&H8ผ€Qw'“ลลZ6ม๑W(8,‹…ทฝ_ฃาSY\ข–สเFMวชi‰l7ส~ก‘œ-uwฒฅ  ม›8กชธD5z์P9—- {x๙Žcล ฑ๐ษKL&#์zฦ@P Bฯอ™ัึึ๙% U„…ศbh[ษซฆSgg[ำ2M)ส>ๅ๎ฺ2๋สห#GดbฃG;หฺฦ–รงผนrษk๏/ธŸ็ฎŠDฯรŒŠ๓ูธำaณ9 รศ๊Mเฦๆpp รฐžqeFE‰ู8‹๋ค`๋ &Sล…Sญœ+3Pš‚Sซฬ PD†ซDภโ๙KKzNCๅ•‚ฺ๕e€กฉI0Hฬfฑxฒ ึุxzลŒ‰‹ŠNˆใ]ivฯฦbuWOืทฟ์DKe๎้*ๆใฬi5…Uนงซ๘๑ย2๗ญ๙@ƒา}QPŽ‡>งเPถาฦ๊lcš‹ไ!†Ckื ^ถ|๗ำRฒ.๏๏ฌ8๏จ>๘yูๆํฟฬฒE}a๒ืถ]ขFอ฿ทqŠถgฯj$ฟ๙ะฺฟ๖มทณค,ณ๚ฬWซŠb๛˜ณ๑๛ท–ช๓ป฿x7—๑ข‹ ‡ึฎนs้ฒญYJถฉ๔ๆีY @็kสฟFฬx๙Cๅ,Cั๏๛๛Fก็ๆฬ˜~๖ั˜ทตs วtฃฟ-:PKซEJ^5gg‹Ÿ›Vท๖๋ซjตญQฐ+{6ฌŸ2sg m™ฮฒrˆ\Rdฎiช๒ ”Uด ล๊สฎT้e-•h$ัวฐMXHx|Ÿู[หK4LMตyศะดp’Vƒ๚Zaตฑ็ฅรZ[Z&ŒŠIdQึๆ๚ข’Fฆbฒกฒ?&nXQvณพบธึ pใ๗คXO‡่dCY‘ :2)…ใด่ิืช^ู่อF‹ƒMš,ฮฎ4ปฦใต?“งงงŸ:uŠF‹%กd5UV6า_๚ธฒฐ‡ฆLm [nNซู&ดHBCIฦrผq„ฬปiพ7=}2ํษ€่็ฐ๏y็เ๘?&=ห;r๚'Š?š’๛Xgแคตป็สท‹ื"ˆŠo(ธ,vD€\~= €๓Cˆฒ๓eL๋ 4h๓ฅ!์ณ”ฉz8ฃ€/U*eฦ[–ะ_ฉ”๒฿Vท›ำjถ ฬ]98Bๆพ5G ์—="™ฑ๛ป๛๖ํ๛v๏ื๏]ฟํ‡|ZaoGŠ@ 7CดDp๒๐””””””ไx™Uญ๑ษ ^€6_บย‚gcฑภbs ฬaณ‘๔o1‡C8V;C๚nNซู&คบ(ว Gศผ›ๆh,@ >P|mพt;„}–›2UวHปี]ฅœคอํ๑vsZอvaๅxแ™๛ึ@ D๏B›/aa@~—@ เ ,@ ั๐(‹ๅ๘GF๙1๋rC(t4งีl๚ะ2๗ญ9@ DŸยฃด…*T*ณ.!’ปQ่hNซู&๔ก#d๎[๓TผxHสถดด/‡%พ$‘3}ษRพ‘žพื๕/๎ึv5แ5)}๏ศุ4 ุŠ;๖ฆง/tท*}cุโฌ์cx๋ฎžqบ๙ฉ e๒ว>>๐๊๏–ปธs๎7วŽ;๖{๖ถฬp๗ย%Š๗ฟˆแ้้#ฏ3"สีฃ8Oyg๒ˆดดิ”!ฑBDแ)้ฉัR —วฅฅโ๖fเBˆC๎:<ีU!7{'ั7Hw{ขdฎอฟุ6ๆ9ฟ–š‹ZF…ŽๆดšmBสwŽนoอ}K63.4iฅVcๆ๘ฅ††ฆ7่ณhืบฅšgาวรๅ=`ืเœhฯn6T๔•อk‹6MํลYƒt๔ใ๓4LบแสบฟŽYI ,๎J๘'แฯ\w_P๛†ี๕ๆ †ฎ5๛ :x/แ*”† €oว\™{ฑ๚†ํธธช่pŽ6?'฿‚ CโใCๅฺ| K,ฎKฤ8X่K๋›เฒˆX๓ตผ".Lˆ nฮฉ`^๙ฌsƒtฒX'iท9b>ฯ(ท อi5„>t„ฬ}k๎{๘ข8š๋+ืW่`+›อถˆลƒf…ๅคอxขช๔ ญูแด\ิX€Kป๏—lšฏอ}qึถr™ถธ1iแ… +v†ฯ๗Eำษ๕ฏ-ฯชคd้ณ฿~eRขœชหแ๒MgšภตmK3Ci8ป้๕7๖•xะ˜yฏพxJะึๆฏo๐2vœ์๐ป]-‚‡๓สา_ผ’ฅฟ๖หฦ•๏ฎค๐ฉwิu IDATA๗ผฒ์ล{ใษฺœ}ฌผฮป*นณc‰OพฑdZjฏน๔ิฯ6l?Qmk ~ฮ๑RGํ๙]๏ญฺ™วฐXzิŒ[g„|œ= u฿2Lq๗kZrฏRwzใ?฿ึ ”ูอ4i™!xzswฝู†ำf๒บ๑?ญด?ฒ๐ๆ์๗พ๓SCำŸ t!ัถญ!NืgEžญPws๐ฯdฯ๛พšŒํ้Ao๒๏_}p๒ู)ณ๗h f๖ฎ5ฤŠGื]ข žฆฬ€ว?Yฏ๘๏”ฏถ*๓ฮw๛๖ฏ}๖JฤOกdkK\๙บ_ฤ๐Hๅ\ตฤ‘#ย-yy5Vz3B `๎ฐฺฐ–๊œB bxคฝHอ๐็8๔•…ื๊ZœัiJK% fืka!~๚ขผJcฏฆฬธŸXิฌนโ€ๆŠผ3ืๅFฃ]"ๅC3!๑ณ๛ื.ดb™ฌฅ๎œมF4จตกq2A…ษ[หzˆGฏมCRSใ˜3^Aˆ;…ŽๆดšmB:Bๆพ5๗=Vs~ŠศฅกCy,าn7.}..lKฟน ๐€E0.:f"ŸมœV—N อตฉฌฦ๓จภฌฌค๒()๙คค๔73ƒ9K–87~WQuย฿n1ณweทฒmF8@ใมns>5!Eะไ+ืฏ;บOcฤธฑฤถู™๗kฤห™i8ž<ใี‘—W<5‘™[–<•pฝฬศ๑ป^š๘๐_‚็N D,X–ทr๊C>๑๊า›า่qc9?xีuŸ๐7๏ี๘ห๏fN|๐‰7NF-z๙>!ˆ˜ฟ4๎ย๒ฉใ'ฮ๚D3๎ํ™ษ^ฝLdŒณS@5iณิน“'<ฑhSn`jข\มฟžx้วœ๐๓ใoe&09*๙|jFฦดO‹4{ๆdddddด r‡Ž"โุ›ำ3Wœž๗\›2ปฝ&]#ำOk๎ถ7oฆs#๐’G๐vฯ๔ุป%ฃฆ= ]ฬp2ะ„DJดBZr?x8##cฮท7o#๙Lฆƒฑ฿้ชI฿žž๕ฆ๙d๖๙ธิ4@PZš่ฤ๑+Lมำ”Y_V* ฤ…๗,ฑ!3”*•บผฌ]ณJ%ฎีzฝy,Whฏผx๎์™jณE}ฉPใz$แฐjฎœ;wต์๏บฐˆธึ’r0,ซ*ึ€LสtGนM๐ƒงฆŽ‘’œฃโ@l'.7txjjสเhๅ๕:%‘r๘ฑEo่WCำ—6›ำ/8.Zษทูlวvง้6BZ :ัสฐคูBGsZอ6ก!s฿š๛ปvร5๕E;'-8๊อไแลFโ<ฟXš๕ฺ฿๔บŒ€ D “lh5yขXŒM๊m55›ห*ฒjk1lอฟี7;œึ๚๚#๕ฺ|ƒ9WCsSอฮฺฺ๎7ƒแษŸŽˆ˜"S„+ยfDD<"๑f-_9;&f~‡S}2ทhร“ญ<๓y98+๗'+่…พ”ใ‹ิvo,?๘EVi e)บpล* rึN›๛y^“ลT๓GN…BกธฎY๖ฦ}…อ”ฅ๐e[ะ „ลลjNพคทๅ%57ˆ9๎๋ก‹[ฃ9CŽึbำ_fอ๒๏Jqีœ8rIgติ?z๋ีTgฦ8;ีp g๛ษๅ"ฬPrjฯชตฎส‡ฦฦjOนjขšฃ‡ฯIใใฅ51€๚‡ [Ž—ีW5ว$๓ชฬn†DซIศž›ป๋อNtndKฮกCๅfช9?๗ชธภะลL'C็h[‰V่ฯd๏ ซf็เ=๏Mใ๑์Kษiรู’ดดภ“วs“Pบ2หสซแw&ศ"†ลKU*EEyตืU๊mD ฅัz?l็ฐด-jŠ"Q[bjฎฏฌ39œ”Ioคธ\W.ีฌำS$Eถ่uv’"1ผ'gเšช๒.\ฬอออป”_fเ…Gชธ€.9ซ/_8Ÿ[,ŒŒPถ^๛ญzKข”KHพ=Žเ8๎t:1ŽP,ๆณœN ว/Aด า]<|ณjK๓ตทฎะ๑(ญfปะwŽนoอoNMSล๒ฆ๊@ฑ์ฐGd/จš^5`€Ÿ2n‹  x,€๎ีFง‰แlๅงฉs7‰(ฝ9ฦ ไ๒\๑ุ@ื,Hว”ู๋ง๗xz,G๔…BะAPfฎัt›fื:.๓ฟบงžฏ˜Uื.lซ$ๅค‚Aco,žอvุ1‘ ฮาjโ˜k0 Iฺืฑxาธ๛ ‡ๆ”_?›M8ญšฆโฟ_ถ™;6แ]๏Iœฎี์[ณ>์ฅE›žV9ชr~ู๖ัวGสํภfƒ[ฝใ><‹๚ฒปaZฺ‚'Iาี ž—ูอh5iูssๆคกs#฿Pป=ฏผpQ็.f::‡DJดBฏ่|&฿ซIžž`วณหfค ฦNษำโ8|Žน่สฌ/+๗ุ๐๓ฯ˜๘@™ฅ์๛พ2=฿c ‡ๆ๒ญผ=ท6ทˆข† #IซกฌT฿&wถ่ ฿‹Q›ต๕๕†ตถม$˜œเิืืšNp่kฬCEBจw˜tz~|ฝ:ฯŽซz3joก( ร0ฒก๐lกย(ๆฉ‰t ย0iฤs<สbนสจ(Y[Xฤ๐wฦSFG*L อi5„-2Ÿ9Bๆพ5๗=gืกถตอึ ม Rrนเt:šJ^ู:™ฬ๎`ธ4ำj๒(;฿๕ดอ๕หuF5›ภI90Œภฎ_็hอ๙N'c@`n/‚๚าgN•7่฿รnž+Tฦmˆ€ำ๘Uี™>]ๆ=wุดIหeฉำฆ„^u๓๕… ปร0~๎-Ÿ>๙ฤ๏FJ6yD7’$‰ณZ“€ป‰แใ๎V๘\M›ภแpดk ฅ˜ฑัd๏(dฑX‡W฿u็๕ด์_5o?ฐลแ)O.[ฑtbฮœoต‡ฃโ๋E™[+=๒ๆYพใE™ ‰V“ถ‘iƒง5g์Mทด72Cœป˜้d ฉ;]+ั o่woNฐ๚์ใฺ)i๑ษ๒คK'Vบน™ำ–Y^f|,5FXt๘ jๆจD^U^ล๕#ย่ป๎o9w๘ ำฬแพ&QสญšŽ๕vย๕๋ฎ๋/' Bา”wถ ฏo2ลUDGrj๓ีฎแ”ึฤ๚ๆ ž๓๚ำฦFญ‰koฒภญญฤำ[8l6เpXฎแ&‡cณต๕)K “ ICƒB04Hท๑่ขลโ๚I$BณGœ'rฃะัœVณM่CGศทๆ>‡„ฌJบ"6๒™ะ—"”2p\2˜ภา|อ~"iฒ@ ŠZ~g์C"0^r@ภ}r‘ธ’๛F zM‹ฑศ"Aฯ>๗J\ฬ}ญžถ*3 ™1h A#ธ@onณiDมณย"็ oญ^!‘€ลCฑn?b๚V์3 G๛p;;ฑฉ๓ฦตฝF๕  เเl๙จป“- ,‚เ ๙8pๅC&Œh‘‡„ˆ8 W‡šช๊ ิ1q2YฤณžีN์๔ฑcŠ~<าะฎYU\ข=vจœห†=ผ|วŠฑโVa๚ฝ /`ิษdqฑWนcœj„…O^ฒ`ยฐ0aืk4€€สโๅฐ๔P.7j๒?VMKt;ฌญญ๓K=4@ช ‘1. ใq™ ‰V“ถ‘iƒง5g๊MZ:52=ด]L']HดญD฿tท‹n๔ปW'˜:;š–๙hJQ๖)wฏีiหฌ+/WŒัRTPXˆํ,kšŸ๒ๆส%ฏฝฟเ~-ิผ็ภฅJMC‡G!ซีส“๘ ูl",ุ฿อzM8†ฑ9ร0๗ƒ ฝษ+•ŽแlQ€\`4šจfฝI($pœ+ ”๓ อm๏ †ส+ต๋ห.CS“ `˜อb๑dA ฌฑ๑๚ษฬŒ‰‹ŠNˆทJhคx4R•{บผhmฉฬ=]ลจะัœVณ]่;Gศทๆ>วaPoจ!Uศวหpณีtดฌ‹F@๗EA9๘lœ‚CูJซณเ~ฃข’]fย€ฃิีฦ“•tš”nKa%'<เพฐ0iฝXSฑ[ื:๔zฆฒ(‹~—2๔iส๒}ณ๚ฌ•ึ\ปปZฑ0H8\ะธบฦ˜ํ๏}ต๐>ภzXุืข˜ูปฒg_ฯฯodผ๕k๐”Eช7?sมาx้?'ฌœ“ŠS-เ7bฮฦ๏฿Xชฮ๏~ใ\'@อมฯ๖Yฒ็ว๙9{V/~๏กw7žŸs™ฮKใกM;๎z{ื—์zs๛๑Iำ[ลผฟŒuๅว4uะ4Zปๆฮฅหถf)ูฆ๒ำ›Wg5ด /[พ๛i)Y—๗ฟwVœw@โ}ง(`{๖ฌึรi…Lqvชึ”˜๑๒๛/†สY†ข฿?๗๗ะ|hํƒ_๛เYR–Y}ๆซUลn_รš~๖ั˜ทตs วtฃฟ-:PKซๅy™ž‡D[wZMฺFฆ žึœก7้้ิศ๔ะv1mœt!ัv}oาา๖™?ภฎ์ูPฐ~สฬ5Lส๔tฃ฿ฝ;มŠณณลฯMซ[๛๕Uตhƒง-ำYV‘ƒKŠฬ5MU~ฒŠถกX]ู•*ฝฌฅ ฒOฤโRฅิค)ํุ:ถ๚ ต์รอu%5ƒm-šj๓กiฎu›คี พVXํ๕'bทชฑชL•4‚“6ccIqฝ ฌuลeจธไPยi5jŠJด^Fa}b:„็ eE‚่ศคŽำขS_ซnKMํfฃลม&M–ึK}ƒtŒวk`KOO?u๊Tนฒฐ‡ฆLm‘„†๚“š2ตDย/tฑ7=}r‡“แยg‡ ™`+{๑r-ใ@U๏“ด๐ภย๚9>^YV4vี๎Œ#“฿๘น7V:ผ-5Bjdฤญsำ …ฅธc˜L{พฐแ†ิqY์ˆนz็‡$&e็หืง`๔p&ะน)Su7ฃ€%๔W*ฅ| ฬ๕ Bฤญƒ๓CธŽlu}Nao’76้ไูjฑnั+rฅŸNำtkณB(cƒ–Nž’’’’’’/ณช/)3ฐ@™ภMธ‹ลXแtXํิ๕$ „.ะX,@ |บก๘Šฮ๚ 7eช๎ๆล:I[๋ขlm?๐O D ัA™ภM๘d๋@ ขGAY,@ ขแ.‹ๅ๘‡DF๙แภ๑v@ย?ƒ@ ข๏ใ.m!Dr•ส_€!Tธ~ แŸAุปHลม‹‡คlKK๛rXโหA9ำว’,ๅ้้{]โnmซ_“า๗ŽŒM๓ุ€ญธcoz๚๒@7๋˜{]ฆฏŽ_s์ุฑcวŽžํ๚‘ตฤGQO๙ไะม/๎Z“Ž๐ฬ-๛ๆ'๙&F๎œ๛ซ๎2รoฑ๏ใถ8k๓SAท่ฎ@ื๏Z)iแ-O‡xTždXๆ๊ญ=ผหี/ฮH^t ใIปyZ0+่^`๛รG}ป้ฃูŒง๗ฐลYญu๑ึ]ะA๘ัŸlwๆP@โ}ู?พ6Šภปwีั์M>๊9ฬo๐฿6>๚่ า!คฌ%ร}โ1p๐‹žž>๒:#ขฤ OIO–บถ†’วฅฅโ๖r˜^AˆC๎:<55eHl ะอ~tu๏พs7ว,5๙ต`#ชอฟุ6 ย„%›š๎4Rซ1sRCCำ๔Yด #SอŠ‹ณ ้ใแ๒€žŽฒ/bสZ<& nหขžตฟmX]oพ`่Zณืธฒ๎ฏcึAาย‹{;’„๛}ศฬw&4ญ๙ฤำอ๒มใ6ฅ๛ฮ/ษjฬyแ1๏฿|าLz}i๔ษลำ—•P‘Oฎ๚๏฿9โ7๔ง๗0€ขMS;ŸํญBœ4ญอฏLu๚YŠ?"-Nๆฒ’ำ’Y”g;ป'dฒWงŽไไี(/ฬ3_–๛ภb€bฎฬฝX}๓พ8,ฑTบfL,ใะฏ–,ฤeฑๆkyE&\™œSมผ๒mป…ป,–"ํ6'PNp^ัฃB‡ี์ฺำขWผ๛*๘ถ5; iซ้ผ›ปjไ„/Š# นพr}…ถฒูl;€XAฺŒ'ชJฟะšNหEธฤƒ7fฑ4š.a˜*Iภ{หyu้'u&›$r[‚J _š. บzfฃž<@๑R˜"–บN›ฌC™ฝ 4fซs๎—:jฯ๏zoีฮผfM^ท;ง•๖Gาœยw~ช๚แซืฺฦdสฟ_๕}ไ์YIผ3๓ณ+w^฿Iจhร“ฟ๊\E&-<ฐฐaลฮ๐น๓2”†ณ›^c_ KŸ๖+“ๅT]—o:ำ5cวึagOq2ซ*๚h$>๙ฦ’iฉaผๆาS>ฐDตกFžืน็•ฅ/ฟx%Kํ—+฿;\Iy'4fซ/งด๕6๙kฦ†ooฅฟ(šNฎmyV%E๒๘ {^Y๖โฝ๑dmฮพV~~^G'Ch[‰Vุ™€ว?Yฏ๘๏”ฏถถุ=๏xืัฑo7.่๏ ญ˜โ๎ืตไ^ฅ๎๔ฦผนฟ„Y˜;(PV}์|ญลี็๗พ>ฦ-dูCำ’๒พๅjฃเ๊ทŸnภ๙m1Ieฉ9›W5'DP฿0"-rาซ *บ2๕„ฆข“Y๋ท+๙ล๚ข<„ว’ุˆ› p‡ี†ตT็jร#ํEj~x„?วกฏ,ผVืโ๔NSZส(Y0ปพX# ๑ำๅU{>G‡ัh—H๙ะLH,ฦต ญX&kฉ;gฐ‘ jmhœLParทฃฒq๗ Y2$55>€Ap๋žถ‡ั}๚#v๖“์-+:๏๛มรsพฝyทฯศ๑ป^š๘๐_‚็N Ož๑๊ศห+žศฬญฦ KžJ(๙|jFฦดO‹4{ๆdddddธ’ฦ:กš4Yj๏ษžXด)705QไถFžีoผWใ/ฟ›9๑ม'8ต่ๅ๛„^ล)z`มฒ„ผ•Sz๐‰W๗–บชˆqc‰mณ'>2๏ืˆ—3ำฎ_k;ตผ่๙Kใ.,Ÿ:~โฌO4ใž™Œ1ฤIm+ั iจ/+โย{–ํุ™J•J]^Fั๖;}+@่๘'"Žฝ9=sล๙่yฯe0Mทฑ^ศ#~๖‹งŒŽ๔รมI1?2KฅRซฑนukาๆ๓{ฟ8ฎvำศ1ณweทฒmฦMำIp^PjRhMm-@ำ้ำถิด€๐ดไช?ฮ๛ไญ“ฉเ่'ส;:…g~z่ะกƒ๛wn๘วฃq<CD7แชยํ•ฯ=“[mถจ/j\ส`ี\9w๎j/<ุ฿5Mฤต–”๋„aAXUฑdRฆ›GOยœš:bDJrbŒJุzap่t”DสแKฤฝกOๆูL\ุlNฟเธh%฿fณq87ฺtu๏ฆ7วHณAง#ญN -ญ?zRุFox๗U๐ดํIิc๓nz๏ฒ‘{ปvร5‹iมQiม5๏ี–๒b hnะฆื๓8ฦงฅาkŸ™๎>Dซ‰‰b 0ึซที่1I)ธตถๆ฿๊ํสภะ4ถ5ทพ—น€ฮ$Œภกนฉfgญžํ<*aฅ-ณ— ีžpีD้่แsฏ?/…ซ:KฮกCๅf€ซ€ฬ๛ใœล<ส\|๚tƒ๙>3[ๆf๚oูw๗64ŸฟlK$จหY;m.˜Lv€?r*–&*n!คNเฮ๖“หEXuษฉ=ซNykNซฃ9พ>Gkธ๚อšๅ%8ใu”ึ<,.VsโใKz;@yIM›€—"ซด ่ย็฿BๅpJ@ำ๒กฑฑš_าYŽฝภ+‡-mœด!ัถญŽฒ๒๊ภ@Eธ,A/ฝ RTไUปฏU'ิ?lุrผ ์ื A2€:Zต๚KŸำLyๆ‰yg/.i๋ืํปJฺร\้‡๐กี฿/N ฏู๑ทฉ› ผท w zึถฃ3E€กไิฎ๗๖U@V๛วiaๆC๗ ง7Z&ฅ2ี&z๚—ฆ ๊ ศ่๑Eš˜ิ;q๕ณ็Ÿุษ\6แี•‹'šตซฦck„G8,Vฒ5ล‘ˆ๕V0ืWึ™ฝ‘’p]—๊fž"ฅd‹^g'$ฦ๎๕mฉLUyj0ภX|eT\คJwฉภชืฑ‚•rฉซคT’^าpw:G(ณXN …3_T้๊nํฎwYฌU[šฏ€ถ=(ค ฃทCบ…เ™*โํQ_z๏ช‘{งฆฉbySu X๖@Hุ#ฒˆTMฏ0ภOทE๎Œ<@—ลbtšฮpPNpš๊?wณU!ฝ9ฦ ฝžเ฿l61่ฑี;๎sมณจ/฿œ„ื์yๅ•Wลถ5ๅคp Aco,žอvุ1‘ ฮv'ค๖ุ๖ญY๖าขMOซU9ฟl๛่ใ#ๅv/ฬi5ูlยแh=wLล'~๗2N‚ HาำผŽญD7_kฏท<ฐูํe:6มfŠ“6$ฺVขาQ_V๎7:2<ฐแ็Ÿ๙1๑2Kู๗๔ŠฬดO’ค๋d`ภ^srวฟO๎(d๔ำห^oฎzา๊ำtพœญํf:ธ๔žƒผเ'ป๔๎D๑งฯL฿ญXฐ{9_ๆ]ฟM^;}&lอ“M_>งใLb4ญ๘vษsG:>ภY›ผšd7ิืดN%ฎูs๘ฺ“ฑ‘(‹๕5ึๆQิะaa$i5”•ถwณGฏgซLP›ต๕„ถึ6˜‚;€Iง็วูซ๓์ธw—ใ^†ข( รศ†ยณ „ s๓ž…ฎ๎ท5‹ๅ)ฃ#Žฺย๒YT”‚ฌ์y|e๘?3™wา$ฝ๏ึึ–RJ[ u๕ปจ(โลโญ ,ˆ ฐ๊z€ธˆ๛c๑>Q@tDŠ(ฌ,X”ณ\miKฯ๔H4Mšs2ฟ?า ๚L&iาห๗‹?†'Ÿฯ|Ž™ฮ|ๆ™gžงดช Zcษ`จพfp Fฃ๗|"๚†เแ๐]w๋Cฦ ็ป๔6ฒมdุT-๚cz˜†ฯŠrtดTญฆkคำEsฃEJ N!Ž๐ฅ๙bขัlผ่ (7€aึ}๑Cช ) €ภ1 0ฦ+cฟ}3.—ซ๚หล37ใcohงฮฟป๓ร{๎ษ์VMk{Z๏/=u๎\๊,ูนzมNเสbฒ๎yvีฒiงๆ}์ป:Rาๅrแœ.wp‘R™[-N฿$IฒWพหแ ‚ =g/w‰รแธ\.:?ัฑฃฒ„nDQUiพ3'Q\ถonฮฤ4AํฏCF๛eษwpwป”ต๖๐‡Ÿš>+F G›‚&S;_"ๅznํ|ญNึXŽcยy๊๓ฯ.m}วฆ_ฟจภฮWึ๚svฒำิXภmก7}qศ—K6—EA๏5Cœ๐ง?งt฿๗zˆ2‹ฯ๐ดฑ๒ถ3วJ†kไภIˆใ5๋=)}ชm ฬญอพณอ›tgธp9ภใq<=K<ฯแ่)L9"•ZLšZฺmn/ฑ„ท๋.ศๅbพิณฤFFC= ถกมh๔žO$พซh1ษร!\1vURƒ‘QOฤjTเ:kฒ€ญใข คEฆH”ช‹_yuาอ0AฆV;Y-‘_>Yซ(&ะ’6s™ $ส๐CCŠO~:9qฒศcอQk%ไำbรง†‡g๓ญ๎p$สˆนัq ยฤL๔็0SS^ก—ลเวO๛๊๛ำผ AฤB๘๊1ทdk;ี‘‘ž็โาะ(อ˜4Vซ‰ŽTqq ‹™พ๔ฉ[ฦEซgปม`"~E„”ฌ-ฏะMบqฌšฯG฿บrหชป็z๑อฯ๚ฺบฐœk’Uชุk็>8‘แtFลiy8W=๑ฺL[II Xmy….๏ฯฉrž@;๑ฺLฒผผ™ฮO”Kศ,กS‡คฑช*dBvgYIi)6iUIำgK—%Ÿันvร๓wdEJy\Iฬไว[ฮž3 %ํง~;›q๋ฝ้!jฬ=wŽ-:x˜๖>ฏ4๏ฐ[{฿ฬ =CSษSฮ_พา€vๆ#F—xอ7ek\พ*mฺล_8ฑ๋—˜/ผฒ๔™7Ÿบž)(8†qy<ร0ๆ~…‡“โศ49วpฎDซ™อ=ฏ)Sอ๙’†แšย_Lmm"mธŒหแTa!Xkk๗ง]ยะฤไ๘„ิXuWก้%๖๐ึYStด(  ถ่h]ื๋ฑ 52๊u F#C>‘ฟ๚ฎ uฆ$#NF[ IDAT.“ฝzโŽ๕Tnต[TV}าJ?)ฉยcBJแน—Z๋ อnภฅำโใ3=jbํใ๑Z}๙—”คธฑด†ฃอ!ํง๋ซทปบ^ซ)+เฦI๕€ถปCฬŽToVฒ(L<^ิบฆœ› ๔A}vฮผำฑwฺ๔gึ~=Wมฑ๊๛|uนฏ‹3บ็(๘ข๐1(y{ฦœญศืฃ๕{>ฺyอาฏพ_ุz๊ซ5Kธ๙ี๗_ƒฟฮZ`=๐ั๚k^วึ<ห‰๕,ีเปKmล‰ูOพ๙x”šc*๛้ืvทาE”ถpว๛34ฐนpnืXIคคi๏บืฏ^๖์ฆ ืRu๔ใ5ลฅo~ถ๎`หŸ^z๋หป*พxa๓แgyอž4{๛ป_ูjOl{ี"ฺ?.ำuฏง?ปr ฒ๑ฬ7+V ่Dน„กฒ„lDCUVA\zE™ตพญVชชฎ๐r๛eษk๚าธ{–ะวฌต0c,$FWTชFpฤJF!ฤ€ฉ<Ald4,—|7ฤ0ฝ;$ˆฑ๛ฎ๎ปu–aวmni&"2วgeeeeeeฆจ์zC0Lต0•€ทพXŒรใ”ห๎twoมk์[่#%ั๎ฆ!,xazw)เWฟb๗]‹uถ/–…………%(ฐ7”`1จ…c!1ธขR๕6.–"vO(=Ald24—|6D/L็5˜ึ™bgaaaaaa na6 + ,ภยยยยยยยยย2คฐU, ห่ร[หSFฦล…Iqเ)#<Ald4,—๊4ษ†ลลE(y‡้yF๋ฦ๎ปบ๏ึYXXXXXXXFชXBขึ้”"qˆg#ˆŒ†‚ๅR&"ฅN"&ำป๓ŒึŒwu฿ญ Yฤ’1YŸๅๆ~:.ํษ0นš๎cIŽๆ๙ผผํžษ[๊D๐—Œผํ’r}Vเ†\ต=/oe(อ<๛xศณyyำย๒&`ฦ-)ุ๘€g Eมี๓6}ฝโบ๎ดDฬxw๏ž—ฏ๏ž฿ฎž๏C‡๚ฉ๐ณ™1เต1@‚ฐฯ˜™w,ฬ๐Gc’‚๏  นQภ•G‘ฅŒEปบO&ไใfฎูดk฿};?]๓ฤไ>@ๆโ]žWx่ะกC‡>พ?€๖ว'ืnตoฏ?๘๛ด.อY‡VWM๋ภ ผย:ฒ1@d๗ญฺ๐๕?|๓๙๋ssh/!,ร Gžœ1>77'+-Lิ(MหษN ;‘ฟเb]า˜ฌœ์q้‰:ฑ็ห‘„]•1>'7gุิ่๎N"\ Žป:3;77'kLRจILV^N‚ยณ”‘:97/=l๘—ฬ๑Byีุ๑9ž€ผฌ†"Ÿ—7ก›์xฝจฦฝfซ/>  ลง[ภAณ‘ัPฐ\Bชฃ!›หO›ภi DpTs’ฃ๒(๓ +Oš•ืา^€œูฑซผผPฃึต—#๙ฟ4ุ้สนบ'๔o8๘š&๋ษžu5ฯฟ๕—k‚ŒEป–๔ัB6ศ`์๓ž+f€Œ™ณโ–ถื™vดC>ๅ‘…OL>ฑด ๕ิ›ท^๓ๆ•SjonYย/Kf=[แŽปg๕ฟvัวป4l฿ณฎฅ>dŒ™ฝ๒๊ร…3๖้น YนjAƒ/ิษฌฦ2ฤเสˆ(nsั๑;เXฯฺr๖ึ๊ ‡ไNฯWรk=wฒŠ ร’ำb5ญ็‚ะธHฌ๑์๑&Gše:Vnค๘บ„^s๑ฉb&ŽLI‰R782…Œ˜L.รaธ๏ฤ~ซb“”ึ‹gส,ธ".5)ขใT5ฬgึšขำuA]Ÿฬ[๋& PAld4,—๊h(ทำแ๐`˜gด`์พซ๛n}ˆJ’ ่hชyปบ6qน\'€L>7&tฌ ๆŸk/}าluQถำ๐‰›.ฏb’žฦh]†ˆ ฮฮ๚K๏6Z๒ธฯRu"๕ฒ<5๙ร…฿oGซkUฑOD‡$๑ภ่๓ฅ5:2cm$x๙ฉีห ,lฺ๓‹#ฟY๔ไ)+@ŸE˜สป็`ฉ186Di๗<ฟ๔œhAวฅ#ป>zo๓ฯu<์šห็]Ÿขp5œ๘โี[ฯะNBŽ”ฤ#ฏ{zูฃ—ขแด_๑WุWใŽŸฝeำ์h€w gxB˜๕y-zุ5 –?~ีhnrˆฌ_า๚žฑhืข–U[cๆ/๘CH/o?ณฒ ฦ  šึถ”^qถ่๚ศŽย7ญ๘กฟ๎้gsŠ’l8ตcํ+Nั~าD„ฬฒฑ?ฺป};ไ_3นะ•ฑ๋V|ง7พิ๚TฃI“%ภBฎ}ๆKฌ1}๏/์ฌ@?แ๒รCUu‡N4ุPwb๛K๏ ]ซ–;67ใฬ๎ง/ด:.|แ{ธฐ๗๎qลY7ฌ(Uงฅ7ภ…๏6;>~:5^ฑ๔…–ž#PŽอ‰ฐTฮYฆฦฤ*yฎ๖šา‹”2!Wcซtซ"ธMๅQtคดฝ์Ly0ns|.ัn0X\nKซษฎœ`5ึt4[ธ;Œf*JภpIe’รนNtTŸ๙ญ{fณSฎB!—ฺฬรgไ2•ชณ๑ธษAด่›ฃ’Uขjห>7zQ Š“““ข%@ัตฤFFCมr ฉŽ†ะฆไไŒ‰ฆw็ญป๏๊พ["์ึZ7HCโ–Eiว 8คำi\๑pr๔DN๛ว%ฅปlข) ‰ำ„4๊HI\1+9z฿ถฟฆๆ'‡เšธฤ;Dึๆ*j~u€๙ปŠŠw+.ดาจsT3Cำq๓ทีต?[iWฃฟ ฎๆก0‘ซฃ๖“ก.a›๘ะหณœ๏ผฐฅฒซเ.Z{k~~ผฏฝญแ้/บ>ไ>๚-w/ (4'M นแฉ็าฮฎธ๋ฆ[บัzื‹3Siี‘’า) –งœ{uๆด›๎~—๘ลONTlธ/?ห _อหฯฯฯฯ๗gHuษ O=›zๆ•๛nพ้๎ๅ/1Vกฆ!>,ด8๊ฯ9r์R;ีRzไศ‘#Gฮิ ฃ๒๘‘#Gฮ50_5๙บ่Pgอ้ใว~+ชณฺ๔gK žg4กVหฉ?๘…AL„า3”DยทWTลัaXmนT บ›G€˜kŠJบึS%DBžหๅ[kMƒ‰Œศฤคูโ .…‹ย“วŽฯษษJOะtฏ0เ2rO(—ฺูMรไŸ%HNะ็ํ๛aDzNNvvVfZฯธ‹๑ถาj2อv H[ืF ห%ค:สn6M62๐0ฝ;ฯh=ภุ}W๗๚แl~๏ขด“—Bๆ๘๕ษกq8€@šD@G{๓มvใw-fภฤฉš‘7HI$‰s›ณ๚๚+ซ ๊[0›Zส]”ฝจฉiSsฑƒF/Žลกฃญ~kCร6ŸVˆมวEEใXฟฉl๐}‘๙ ‘8gี\ž๖๕"ˆc8WชVK0Sล‘ฏVฏ๛ก *)ฉ๙—,n—แภพใŠ”ฺา)™h8ฉf›ฃยฟ__๙ํ%ฺ+R=:9ษ๐๓พณํNงนชขžam๎ช=Ÿ\๊tสNžงขขบNํ[euw]ฐ฿cศ๐๓ณFปญแ๐“ค$5ŸH—YB6ขจฌช ‰น:U;.Eกำ…TWีyช๚๏xธฒฉ๎๐O9BรTtbMป–=สA์ ฿นewคŠ้1ฬsป฿ผๆภ{pห#Wภu ณ>woชDKบl|๓์ุ—ฟ๙แป]›Eท๋cฦpูz&5ล‰คง0ต6ี4Z\”าnv๓๙žZชรุ๎&dgปัIบI ผณ็หดQ ฉ™™ฑฦชฦ๎1mJ^„ฌxžพธบƒ p™„ช;w๒DQy‡8.Vำ๕„io7rไตœ4ถ๛ึ[2Rภqœข(Œ'–ษ„Šrใ8ํีR{ๆไ้ขขข3g‹+M‚˜8]0FzQ`oพT =Ald24—๊HHcuฑ1(a28ฯdA=@๋HI&๋Cehซ^ูV*S}›*๖Q]rFH5ษี`ppTมก$1œ เrS@Yš6x)Dั๊€ค|พCKฃๆKฬี๛,C<]๖แฒฝ—/ž๑รฏj๏BXฟใ๕ทฃŸXม:Wํฉ?[ฮ*'pนD๘kถLv!ฐ้ฯั>Ž#%น\ยๅ๊:ค–๒ŸขทŽT'‚$}}๋9–nสMW^๋ฟz๚ัnC=๛tน\\‚K็'า%d–(š*ซค“โbB[๓abJจสVน฿~็I’ฤ1/ฮ๚_ถผ๖หึ๕‘“x๖น7ๆ๋o_se‹๊ส›eฯฒ๋๖@ๆS฿๔tฝษYW๕า‡๗๗ํPถทตำˆบk๖ฎธ‡ีBiต‰๏๘ืcGUว‹/ุ;:%๑cวE“คTyฉ๗L z7†๘ู…#MORุ ซg๏ูT|ค #„š๘ไD8_ฺPํM ฎ๖†๋X‰š\cป0%ฬYwฦ‰๋†ึ๙ภpป†‘-ฅวZๆๅ…Žๅฐwฝฐฑ7ดXยD"{ ๖ฝUฑMB\ˆซกดชSB6”Vต‘Akl# ๙๎R|ฏ†ะ๛็(c’C9อ{€azwžัz€‡cฉcด>D`ผpพKo#L†Mีข?ฆ‡i๘| (@GKล฿jบ†Z:]4wtคคภํzม๙า|1ัh6^tP”›ภ0๋พ๘!ี…@เพ๔๊t6๎t„ฎะ*mุะ1ิฯิdีถdฐrฮ้G>,ดแ %;W/ุ \YLึ=ฯฎZ6ํิผฏ›].W๕—‹gnชaิFJบ\.œำUiแ"ฅ3w ŒsS๎หK0ค:I’ฝ๊๔=W@ํฉtนKวๅrั๙‰Ž•%t#ŠชJ๓9‰โฒ}{ts&ฆ jฯT{‹ค_–|วqท @Yk๘้ก้ณb”pด !h2ต๓%R.€๘Zฌฑผ @Csึ9Mต>~ะฆLฝq"ุžS- Tฉฺ{ฯล ๚sJ็๑}ฟกG#ณŒxฺXy™c%ร๊ฐธ2L็จ>^ิwP GคV“(—ตอไŒSH ฅu๙ธ›๎งCภภฺlแ;l0ฐIw† —ร<วำณฤใ๑Žž"‚#Rฉลคฉฅๆเ‡$ฤ๑Š๕žฎค`=ixป๐แ‰\.ๆaภแK=Ald4ไปK=๘n ฦหๅR>'๐0ฝ;ฯh๗ุƒ•:F๋C!\1vURƒ‘QOฤjTเ:kฒ€ญใข คEฆH”ช‹_yuาอ0AฆV;Y-‘_>Yซ(&ะ’6s™ $ส๐CCŠO~:9qrื่_Gญ•O‹ Ÿžอดบรa(#ๆFว-ฃ}ฺ i]YWN๑งฤ„†jฒะP๕฿พฒถๆๆOŽฌ1ฮXฬ๔ฅO2.ZE8  เ€š๒ อธผ(>?~๚฿W฿ŸF7-Y[^ก›tใX5Ÿ+Žพuๅ–U7vOมาะ(อ˜4Vซ‰ŽTq่ิ๋k๋ยrฎIVฉbฏ๛เD†ฃ$Šำ๒pฎzโต™ถ’’:ฑฺ๒ ]ŸSๅ<vโต™dyy3Ÿ(—YBงIcUUศ„์ฮฒ’าRlา$ช’ฆฯ–.K>ฃปsํ†็๏ศŠ”๒ธ’˜ษ7Žทœ=g@KฺOv6ใึ{ำCี˜{๎[t๐pฯ|ƒึ๙`๔eO“ฉเ ร๒๏พ>ไฤ‰‹]?ฤฬxแ•ฅฯผ๙ิ๕‚a๕%Pp ใ๒x8†a#fดA”รqๅธpQH\ŒNB`R.ฒูl๎Žv‹L*&pœ/U L=ฏ)Sอ๙’†ั๕e€ฉญMค —q9*,kmํดKš˜Ÿซ๎*4Gฆัศy8†s%Zตศl๖eŒ๚b;kŠŽึEิญ๋zดF&Cพปิ๛ซ๏†ธ/m๒`˜ ฮ3Y๗=๖`ฅŽั๚ะเ2้฿ซ'๎QOUแVปๅ@eี'ญ$€๑“’*<&๔กไžqฉตฎะ์\:->>ำฃ&ึ>ฏีื™ฉAIบKkx1ฺษััา~บพz›ฑซ๋๕ทšฒnฬŸ4Qธmป;๔ว์H๕ๆmu!‹ยฤใEญk๊อน 4ฃ๑๚@ู>iิญ x0ค้๕ๆกเฅํภšWr6}ษ5ณWŠ๊žฃเ‹ยว ไํsถึง-๑ l.œ๕U;ฒฝโ‹ฤ์'฿|—ๆๅๅ9rค็ฟ|UtคาeจิไQQJาPฉ7‘Ak4๕ €’Dโ]’ง๒ีzYxฌ†ำVSำ๊0L๏ฮ3Z0๖จ๗ทพ=/ozŸ“…ๅwมpMbสย๒?Mo(ธ*)[~ผธ‰ภ…‘iฉDๅ‰Jฺฉ~g jaฦXฦŒฎจTฝ(เˆ•Bˆ!Ry6‚ุศhศw—z๐LจะhT""๐0ฝ;ฯh=ภุ ฮh……………eุq›[š‰ˆฬ๑YYYYYY™)*ปงูc~' jaฦXHŒ@ผ๕ลb \vงป{ƒ ^c฿B)‰vืซ$ๆณ!šsธ|s9$`˜gด`์P๏oํ‹eaaaa ์ %X jaฦXฦŒฎจTฝ๕ฝQคฃkRถž 62๒%ฤฏŒ†ะฮ๎Ÿ “มy&๋ ๊ ัO๋,,,,,,,รหเfL…ฤ$(K'ฐฐฐฐฐฐฐฐฐฐ )lหยยยยยยยย2๚๐Vล๒”‘qqaRxสฯF ๙๎RŸhคaqqJฃ!šd ิฆw็ญ๛`จณฐฐฐฐฐฐฐŒ(ผUฑ„Dญำ)E8โฯF ๙๎RŸhDJ.DL0ขIB}`azwžัz€ฑ†๚กE,“๕Yn๎งใาž “ซ้>–ไhžฯห๎๙—<ฐฅNษศ>!)ืgnศU๓๒V†าN่?ผศวอ\ณiืพ๛v~บๆ‰ษ1๔+T_=฿‡:๔Sแg3ch+fๆฦ 3จ<8 K3ป็ๅ๋eฬ’>แ฿แ™ทคเใ{รผIŒ ?YX†B•ž‹˜S\‘1!ฏป];>/oB7ู๑2ฤdๅๅ$(ฐ0ฝ;ฯh=ภุC}ˆเจๆ$GๅQๆ Vž4'**ฏฅฝ9ฎปcWyy!กธ+Fญj/G&cๆฌธฅํ๕GฆํPงOydแ“O,-@Oชญฟ\๓d,ฺตdˆ]ะp๐ฝ5Mึ“>.ˆส{8XXF;mB|˜ท˜๛ฏำภีฦ„q}ocึšขำuWฎัล‘)$`์ภdrร}'๖ \›คด^๓]าผUฑnา้ ภMีฝ„F—ฺoฅŠฦ>’พปิ ๅv:žV7Jู่]}`azwžัz€ฑ3จฃฃ๚!”$ะัT๓vu;lโrนN™,|nL่X!A:ฬ?ื^๚คู๊ขlง 6เ7]^ล"$=ับ œ'๔—mด8ไqŸฅ๊D๊eyj๒‡ ฟฝ฿ŽVืชbŸˆIโ‘i.น,โ๑X]บ€cต[Šš๕[๋Œอƒ”จ๐รCUu‡N4ุPwb๛K๏๐ฌnŠ‡]ณ`๙ผ๋Sฎ†_ผฑzฺ๋นม‘’xไuO/{๔R4œ๖‹?พส๛j๑ณทlš ๐Nแ ๐พ~ำฯ>็%ูpjวฺW6œ0€j๚[R~xลyข๋#; ฿\ดโ‡F?\สXดkQหชญ1๓ไkLว>x๎๙$Kศˆ|ท.Jป็๙ฅ๗็D :.ู๕ั{›ฎs๔ฎžU๖=K]’๒์9/=5-A)– ,๚fNลฆ{ž+H@๘  ส{์ฅงoOSปฯ์็ส~k๓zLฏ€.LT’}Žศ็$wI>~ีhnrˆฌ_–Ÿฝึา๖หฯฌ,จqำ8ไ>'-อ้Lฒ‘eเHยใรๅemoชญึทู่Vh&ไ‘IฑZ— p—uึ*5ˆbวว9ห๔ย˜X%ฯี^Szฑฑ“R&ไjl•nUทฉ ŠŽ”ถ—ฉ1ฦmฮii3T้[;)ชหWaฦๅ‘‘ยๆสQข๗ี™อfง\!„B.ต™Gื*ด2•ชณ๑ธษAด่›ฃ’UขjKg€’~เmD(rLNNŠ–QDืFเa”dุ'กMษษ!๊+‰TGƒRb˜พ[0๖มฐ>Dุญตn†ฤ-‹าŽpHงำ ธโแไ่‰œ๖KJwูDSง iิ‘’ธbVr๔$พmMอOม5q‰wˆฌอUิ๊๓w๏V\:hฅQ็จf&†ฆใๆoซkถา.{ฒ{“ฃr๓ึ‹e›อBฑฮอAม~ฒ๐ื”วึ.™1)NŠๅ๖<‘Hnx๊นดณ+๎บ้–ฟnด๕โฬTZ}คคtส‚ๅ)็^9ํฆปŸ%~๑““ล๎หฯฟร2รW๓๒๓๓๓๓ฝฌƒ%นaแฒไ“+๏›:m๎ป†)/อษ์"ศฬl›๛ฏVLผ†Hฟ\€ธฉำD_<1ํึ…?FฬŸ๕.Kดฑ๛f]w๛ย‡็Oฟๅ๎ล…ๆคIŠึšŸŸ?๏๋ห:นรo›๗—ถ๎ฟu๊”‡6]าo~๔น ฺOึ‡g๓{๕งผˆ๘2วฏOรา$:ฺ›ถฟk1&Nฅปพ!%’$ฬm๚ฯ๊๋?ฎฌ.จomภpptlj)wP๖ขฆฆMอลuพ8‡Žถ๚ญ ผฏƒRฦsศช–ฺืJ๋k#EomO IDATด4ํZ๖๐+ฑ?,x็๖w—‘*ˆJJje‹e8ฐ๏ธ"%EAงŽ”ŒLH4๎Tณอั~แ฿ฏฏ๖’“šD%%~ึhท5>p’Ÿ”ิ=€ูvj๏*ซปฃธ่‚ h€ั9_๙ํ๛;J;ถา็aแ*ี}ดŽc8WชVK0Sล‘ฏVฏ๛=: ]ฏ7ใ8††sไiฉQํtŸZw gฺl–๚_OU‡„„ะ๎าh“์[Dพ'9:9ษ๐๓พณํNงนชข๏I฿€ช=Ÿ\๊tสNžงขขhOไ>‘'-2LdB|?๎,E‘‘{)Z.†<.ฎNcCEeณ“V฿e๋™ิ#$’žยิฺTำhqQnKปูอ็{*คcป›t“ํF'้&1|H—ฅโjbBฉบช–พฯ|–ฺ3'O9[\iฤฤ้บ.A๖v#GฎQหIcป๗’‘ŽใEa<ฑL&ไP”วi?๑Yาผuฺ›/{^ˆ๖l่;“$ร>Icuฑัหฎ๖T^˜พ[gPgŠ}0ฌ”กญze[]จLuCd๔mชุGumหM ี$oTS€q@ภมP7†’ฤp.€หMeiฺเฅEซc’๒แ!Œj๛ขย ŽV฿x๕เn4ึณTq(ฏGฮ๚_ถผ๖หึ๕‘“x๖น7ๆ๋o_s”ห%ย๏\ณeฒ MŽ๖ู)ษๅ.WWฆ-ๅ?ไงC\.A’]๊.—‹K\๙]\WO?๊U้|ฯมpSnฃฝ2ฦ๎zŽื฿Ž~b๑่\ตง~l;๛ซhnซ”พจโชฅ›ฟ|ิli<๕ฦ›วzฺ๛๙)Jน๓๙%ำธ.'&ัม1๔๎„1ษ#๒=ษัkhPผย:A\y›๊9pศ}"OZd˜ศ„๘~YŠตฑคจฅo9้vบจฦŠjAL\z8฿m3ต๊ซชšญt—]{Gง$~์ธh’ด›*/ต๗ดSฝ#`U\%4”–ุ๚œ์n—รUีฺZ,a"€ภblฆ„9๋ฮ8qpธ;Pn7†adK้ฑB‡นiG&๚.้ชX&!.ฤีPZีฉŠ!Jซฺศ@ฝรื0H2์“ฃŒIๅ4WT์=’}ีƒฆ๏ึŒ}0ฌ/œ๏าศ“aSต่้a>(สะัR๑ทšฎ1N]9’ธBฯ#8_š/&อฦ‹ €rSF`?คบข๓~eคj ๅห —”"้คศ๘ูช่ฟจW†ฌ{วqท @Yk๘้ก้ณb”pิๅrUนxๆ&ๆnaคคหๅย9]e".R*0sซล ภT?ขิ9Žหล4ฐุ—h้็’๊้,ูนzมNเสbฒ๎yvีฒiงๆ}|ิN[8ก๐ฏ7/cLA;us๗Ofทj๚[ำโ*L_“ŒŠศ๗,‘$ู{20vขโg‚ sงู'๒คE‡‰<ฤดว]œ๐ง?งt฿๗;P6@(—†8คฅฑโ|cFๅa I๑ZำนFdฆyฺXy™c%ร๊ กBฮใ๓ำ'tOๆ!ห“ิž.ถ…ว๑Š๕žหEŸjskณ…๏lณมภ&.\๐xOฯวs8zŠŽHฅ“ฆ–vฯg/’เํR„ $rน˜‡‡/๕l่FI†}b<ฑ\.ๅs๚J"ีั ิƒฆ๏ึŒ}0ฌ „๙้ไฤษ]ฃตV@>-6|jxx6ะ๊‡@ขŒ˜ท L์อ{Nศ฿ฦฆฮ Iๅs€W›c{buwฎ๐Y‘RW3๙ฦ๑–ณ็ 5ๅšqyQ|~๔ฟฏพ?ถ )Y[^ก›tใX5Ÿ+Žพuๅ–U7vฯ.ีะ(อ˜4Vซ‰ŽTัž5ตๅบผ?งสyํฤk3ษ๒r>v๓yคKฉ_ 3}้SทŒ‹VฮvƒมDะL.มS†„๐8๗พ’Cฑพzฬ-ฺูNudค„็๏+ต~a๚œdtDพgฉพถ.,็šd•*๖ฺนN๔๚งŸาจ8-็ช'^›i+)iกC๎yาขยD&„ธวฬxแ•ฅฯผ๙ิ๕†ะY†04>V+rqสๅpธ Oฯ๊เฦๅ๑p ร๚†K๕ษ#]ฏ4น %GNืZGฆัศy8†s%Zตศl๎yฅL5็KFื—]ฆถ6‘6\ฦๅpชฐฌตต๛ƒ-ahbr|Bjฌg’ o}ฑ5EGkขj‹Žึuฝใ ฐั;L’ ๛t5^8ฺไiํ•Dช#Aช/L฿ญ๛`X\&{๕ฤ!๊ฉ*jทจฌ๚ค•0~RR…ว„>”ยs;.ตึš€Kงลวgzิฤฺวใต๚:๓/5(Iทqci /F;9:šCฺOืWo3vuฝVSVภ๙“&๊ทmw‡˜ฉผญ.dQ˜xผจuMฝ1`/–Ÿ[7k"ศ'(ง๕็๊๒ฯ‡0Ÿปืm }|ม๚วcd.CษกO—}|Žุ่ปnm๚3kฟžซเX๕ฟ}พบ i wผ?C› ็v}BŽ”4ํ]๗๚ีหžT แZชŽ~ผฆ ปžฐ๘h5/c๋ žๅฤ๚G๏j@๚dฺป๎๕๔gWn{@A6ž๙fลชๅ้-\๒Oฝmล‰ูOพ๙x”šc*๛้ืvท๔ฮQ๐EแcP๒๖Œ9[๋๖lจx๓s€์ิŸlๅ3ŸEํฒ~ฯG;ฏY๚ี๗ [O}ตfษ7ฟ๚k๐ืyEw!‡๏a๚žddDพgฉu๏[๔า[_U๑ล ›฿>ห{๚๐คู๓฿’ศV{b๓ฏัJ"๗‰ฬคHปIฑดฮyt]`๋“๙1G›t:(pS@uo๘ีุ ๅv:ZQ0I๚nศ@6@ุ}ทฮ„๏ฮ†: หH€z๕8qsฅ‹S \m—Šหšํ_›ฃ–”ฝฃ๑Ryญษ ศFQไุŒH!@Z^(tVŸ*า†ฬw™Jีูxไ Z๔อQษ*Qตฅw!VสilทZNฟไ๕ˆƒฯ%ฺ ‹ห `i5ูu€ %„ทืขศ199)ZD]~5๖BhSrrฦDˆ˜a’๔P$Rับwu?b๗:พ;?๊,,,,,,#\&็ิŸ?~ฒยช'$6Alบx๚ุ๑ณีMRค h;kO9rบฆำัp๎ศ‘#GŽ e @๐yเpPาˆไะแp๐x—}‚qๅrกีา9jJX0ื•4y$DBžหๅญ„Fค็ไdggeฆy{เJ*าj2I;คญkรฏฦ^(ปูhไุ|˜…ŒIาwC=’HuF๋ีˆw๋L๘๎`จณฐฐฐฐฐŒฆfƒ•0›,nB‘ุัVmvบฺZฺ๑HLdใฐ๚ใ8EQO,“q8”อใ]ฅœ(jln$`8eญ/)๎๔พ“ฮ—…h5jตRไl,kค}*ฐิž9Yฦjโ“ใtฦณ๕๖@m{ซbํอ—Š› gรŸฦ^Hcuฑั'w˜$}7dG ข๎{์พ[gยw็C……………e„aoธp0 ฃจฎnŠขp ฃkVn7†adK้ฑB‡นปว๑uึœ.า็ฉโำR#Š<:„pไฑ้I ปกก๑bตัโ๔า์v9์.ฯฆฝกล&\ลz๋ะhRSc”เkโ=~5๖ยQฦคฆฦk|๘์ŽIฒวะ๐ช#รDว๎ปu&†7v–‘ EQะ]ค๖ฏศF (€แ(i]๐x]7b็p\^ฦนฦvซPœ—ํCฎ ำ9ชฯW5ด^YยrD*ญF.่Ž…’.๎‘ Rฝe Hไr1_ู๊๐ซฑŒ'–หฅ|ส7&ษCรซŽ ป๏ึ™ุYXXXXXF*6k'_ก–8ฮSจdTgงƒฎภiทR…”วๅ !ญfMmm"mธŒหแTa!Xk๋eฃ0œฏ”‹œv๛่KๅpธฟC“ใRcี]…ฆ“โศ49วpฎDซ™อ– ุ๗6ำ†a@QTŸ ฟ;bvˆA’แ๗กRG 2F้{ขุGฺฤ(,,,,,ฃ”เPธกWืZึท„ฤ%Dฉฤ\ฐw4V–ีด;้0‘.)1J!ภHSีูโฆ€฿k๛ใฝ<*!V+ๅQ6ฃพขขมBศโฒฏึ@‘k‡กบผฦ8„_๙/,=+Fางกฅ๔ศลVBŸฏ$KฯึtP˜Hกsqาanญฉจlฑ  ๒cฆ-พ**R้2T๊m๒ศ(%iจิ›H€๎J‡ง๊mค‘์†# ‹ีpฺjjZ™†U3I๖2!?C*ud˜}2๋L o์,,,,,,#gร๙_๛5RถๆŠsอ>4PฅEƒไŸwœํ5ลงk.k2]:vไ’oฺ|Utwีง ~ฃฏ8๊ฯฉGโjญ8ีฺท๊l*?ืไ๓ž}รˆŽXฉั(„"•gฃ/}ฝK&Th4*‘SL1I๖^uฦ„ ฤ:ร; ห๐‚ฌCฃqดเmDฦแ๑สewบป7๚V็XŸF๏’.Ÿภ\๓ขU ’zCญฮ˜Yg`ˆcgGฐฐฐฐฐ๖†,uศ`4ŽXQ@‘ป'”ž ไฏL’คีŠ‚A’B๏ศี™2 ๋ o์,,,,,,,ร ฒŒฦัย่™อ………………………ฅถŠeaaaaaaaa}xซbyสศธธ0)พ7l$<ด๑๛o—a Oง่ิๆุำบ๘~† $‡ูy–‘!‰JฯอMP๖4`|eLุ๊๑9นูY้‰ฺ— ร!‹ผj์๘œœฌ1Iกbฏk'๙.้ปq/ฟู๊‹O7ƒƒwC๑้p\1ๆ—l.?mงอ/I˜${ ี™^็YFีŸฬบobjD–หi8๘š&๋Iำp๛1๘ิ์๛ืซๅฦ"vh?๑ ๙฿9—X‚ƒ@›&ว-ๆพ -๐t ๑"cIQI'ˆย’Sใดฦs ฃๆฏWล&)ญฯ”YpE\jRDวฉjš5น|—๔วผ—฿คำแpบ) บ7.ƒr;'I]&้ฒ[ญ๖+็z๊#ษ“ค้ษ๏C‰แuže”‚‡_ท๘ญ/๗์฿๗ํ็ฏฯฮRxUำ฿ฺ๗ญื.xืพ๏7ฟxƒฮ๋ฐkŸูดgw›_พ%ธผƒถทSMž=็ŸŸ๏Uฐ๏เvn๖ํ+Sลt;DZวรฎyj฿๏ๆำ;F †fๆ๘ยฆ‚๏๗|าิ(ฏˆโgo),<7Q3ใยยยยBฯ‹v๚ํ—ฮํ]mฆืะ฿mว๑ž.?"ส{์_๖gž-|$G้mŸxุ5OญZฐoมึ%“D^ฒŽŽ:DB„ำ,,,,,๑ซฝ{lฺm ๛ไฬ\Ÿˆ*6—Ÿ‡e†ฏๆๅ็็็็ฯ๚ผŠึšŸŸ?๏๋ึ+<Š›:M๔ลำn]๘cฤYเ๚ž9{๙„sซ๎zœMๆ[–›JฟOษ O=›zๆ•๛nพ้๎ๅ/กV๏CุiR‡Hˆ๕ล๙๙๙๙๙๙O~ำณCd’ฅS,O9๗๊ฬi7/๑‹Ÿœ,ฆK_ \ุ‘ฉC[G:ฏป}แC๎ํ๓ง฿r๗โŠBsา$ด ฐRx"9วS†ๅๆJ~>|hฮค!”$}๊ฑฉแrEโUั` พ.:ิYs๚๘ฑ฿Š๊ฌ6ูRƒ็%ฃPซๅิŸ?~B‹ &B้น2H๘๖Š*ฃ8: ซ-7€J!NวHKซมhฝญ(Ap)Ww'’หิP6”+โม็รAI#’4B‡รมใั=M๚.้ชXาj2อv H[ืฦePvณัhฒ‘}%ั๔‘d€I2@C#Z‰แuže45๋ใ๖>๓OKR’แ็gv[รแ'๙II๊.Qฉฝ{ซฌ๎Žโข 6เ{ูง~๏‡›ญiึ|๐ด;*RE'ึฎื›qรร9๒ดิ(๏Ž๖ณ•”ิห ทหp`฿qEJJWkีžO .uบme'ฯSQQ๊ D„ค๒๗w”vธmฅ'ฮ9ยยUDไ>ต๎๙ฮดู,๕ฟžช ก฿gtr’แ็}gNsUE=รรฑำฅ~ “™h8ฉf›ฃยฟ__๙ํฅเŒศ๋๏<*vฺิ๙่<Žแ\ฉZ-มLGพZฝ๎‡+ŸM0.<›™;ž ฯอ ๅp‘›N2@CUW<ณjๅย7~๊<.[ฯคฆ!‘๔ฆึฆšF‹‹r[ฺอn>฿S!uค›์l7:I7‰แ#ณ“ณห+Žๆช ฦFัพ๙qเ8NQฦหdBEนqœ๖๓Ÿ%ม[ว ฝ๙Rq3๔l๔…4Vฏ”DาG’&ษ hu&†ืy–ั@อฦ9WŒ‹ๅr ’์บเป\..มฝBฅซง๕บฯu’$ ‚๖‚A้‹*ฎZบ๙หGอ–ฦSoผyฬ7‡{ฌsนD๘kถLv!ฐ้ฯu=ฃS]nสํฑxDh๛ย1ฏˆD)w>ฟdZืๅฤ$:่์ฟO‚่u/—๚gพo๊ผ'คd’น\ยๅ๊Rท”“ฮ๙๏<2vบิ๙่|Žื฿Ž~b๑่\ตง~l;๛ซœxูzธฐrvn:vD›๋พใ๔G&PC?ํeญ{Gง$~์ธh’ด›*/๕พn z7FfตJG—ใคกไWศbณโจั3บฯํvcFถ”k t˜›vเข๏’เญŠhโB\ ฅUช๘๘ฒกดชญ๏_9G“สiฎจ0ุ{$—>’ ๎0IhhDซ31ผฮณŒN\.ฮ้zๅp8.ร[l/แt9€rS=๛์~˜ึN[8ก๐ฏ7/h?“หๅชr๑ฬM5Œึ‹จง~๔฿#าNw็‡๗“ูญšึ๖4/ข$I๖K3=ฑ#๑=!ศ$๗UวEJfnต8|M๊d@;Š>uฌฃฯฮ’ซ์ฎ,&๋žgW-›vjืžgu^๒”๒รญล{ถเลฆยรอ3rS2ีg~ลฅึ t๊$1“l+๚้D=๛m`๐ดฑ๒ถ3วJ~?ฏ].Fp0O5‹๓x\{็จ๙ถ \๐xx<žรั๓—ฤฉิbาิาns3H€ท‹.ศๅbพิณqO,—K๙œพ’h๚H2ภ$ กญฮฤ๐:ฯ2:ฉ-ฏะๅ9Uฮh'^›I–—๛6@ฉโโIืณ_,m€†z}D๖“U๊„ษO<ฯ‹/.มS†„๐8ศ;ปš๒ อธผ(>?~๚฿W฿Ÿึีก(Šำ๒pฎzโต™ถ’’ฟ#jnh”fLซU„DGช:ป}ˆCฑพzฬ-ฺูNudค„Gsaญฏญ หน&YฅŠฝv๎ƒ๖‰๏ A&นถผB7้ฦฑj>W}๋ส-ซn์ž3สทิกNด๓จุ้Sืฯ:สy,f๚างnญ"œํƒ‰่x#ณgOีZ s ๚ยB{๎ฬ;ฒส tาKy1„™บ˜้+^{ลuปž๘ Pp ใ๒x8†aุ่๊qฅลa4KuแŽsฅa:™ฉตmเ CŽฉญMค —q9*,kmํS†&&ว'คฦชq&ษ@๐ึYStด(  ถ่h\ูรํjผpดษำฺ+‰ค$L’ั๊L ฏ๓,ฃำuฏง?ปr ฒ๑ฬ7+V๐๏_๚~ใo>นแ[ะQw๒฿/ฌ>M€a๗{›๓_|k]—พy๕หŸnพ nฯ†ส78ศNษฯV>๓ูYซฯ†:๖ฎ[›ฬฺฏ็*8VoŸฏ.๏๊z”fฯ{๗K"[ํ‰mฯฟZD๙‘๕ภG๋ฏy๑[g๐,'ึ?ฒxWCฦข]๏้๛EแcP๒๖Œ9[๋QšพGTฟ็ฃื,๊๛…ญงพZณไ›_}5๘๋ผsจถ๎`หŸ^z๋หป*พxa๓แgyอIุ‘xOŽsTWษ…Lฒi๏บืฏ^๖์ฆ ืRu๔ใ5ๅrฟิ!ญฃNด๓จุัฉZฐŽrk+พHฬ~๒อวฃิSูO๏ผถป{ผชโชซดไนuN3vื•สพฟq›seกฮค!ฺs ™:cuI}‡ฆ๓bํ่้dฉุ uึ1cs=ฅRคคฟXZgfง|GŸ“ข๕<\•งฒฉ๘ท ccY?>aL8sš ๅฟฌ #dKe™(!.#‹GูŒ๚‹u=๏ฏœVณอล%-6ŠI20 ๗‹ษผผผ#GŽ๔—ฏŠŽTบ •z›<*JI*๕ฆหFศยc5œถššVGค ถบW’ม&ษ hu&†ุ๙ํyyำ๛œ ,,^เ^ทbฯิ_o[0nฌw)[๛บำํ5cัฎEM๓๐|œˆ|'ภุนฺธhิ!7๗ีๅผ๔โOCzSฮ็aย๒ฝ/๒q็ŠC์ห๛Bo(ธ*)[~ผธ‰ภ…‘iฉDๅ‰สŽ ์|ไƒ,ฬ‚ี8ฐโdˆนขฤภ้บIDATR๕6ข€#Vj4 !„Hๅูธ LจะhT"ขฏ$š>’ 0IhhDซ31ผฮณฐxมy๎ฟ๛ๅณท}ปsวŽ_o๒k›>๛ฎxธ ˆQ‘ๆš…ฺผ‹๕ีดโยัิฏ"R’vl.dKุ฿%nsK3‘9>++++++3Eeื‡&~@fมjx๋‹ล8<Aน์Nw๗ฦๅe:‡ห'0—รARZ!ษไƒd€†Fถ:C์<หยยยยุJฐ@fมj ]ฑWVช๚(าั5)[ฯฦeฮ๎V -€d‚A2@C#[แuž………………exAfAk…g†k–ก„ญbYXXXXXXXXFCRลโาฐธธฅ+ๆ2I๒”‘qqaRฺ๕อFณ:รk…………………eDแuŽIุUใsrsฦM๎.pฑ.iLVNnn๖ธ๔Dลeg„{>ร%ัYI๊หื@ฤEJ.D์ร๗๏L’„Dญำ)Eด•hVgbxญณŒx2ํฺ๘@$โ‡˜™w,ฬ๐ฅ18จ๏|gื๒lย‡ฦ+ˆ˜๑๎=/_/๋ึฯOฺ0๛แปd๐๐%L$จุ‘ โ Cฝ ๑๏d๙฿C3nย„ ๒๒ฦF‡ฟ‘ฦŽฯห›ะMvผ็/U/!‰JฯอMPvW“•—“ ภpurn^zศCByีุ๑99Yc’Bล^W—๑]@ ‰U3eยหๅV‰5ž=dใHขSSขLวสWรk=wฒŠ ร’ำb5ญ็{งq!”qIส๖ฒณ-—ฯ์B6—Ÿ6ำ‡iO˜$m๕ลง›มA7 yTซ31ผึYX|$์†)a9แbnผ’†ƒ๏ญiฒž4yั๘&’ั;’'„ๅsีษฃU ?ž kMั้บหึEAึKmB|˜ท˜ฏX}•#SHภุษไ2Fี$qธ*6Iiฝxฆฬ‚+โR“":NUำฬ|ๆปคŽH.'ฝ-! เฝ/ึjฌั7[ๅ์0š)ก€ |.ัn0X\nทำาjฒ๓๛ฬำ|mbœ ฑดบ฿ผน”้p8™งูb–t“N‡ร้ฆ๛}Tซ31ผึYFXศตฯlฺณป-ฏฯ€๘ู[ 7ฯMิฬxงฐฐฐฐpใ‘4ฑhืฦ™น7พฐฉเ๛=Ÿฟ45สsiฅณ๚ำo๗ุทcรหOŠ่ฐ"ฟv๙—ป7>šู๏i:๒ฦ)ช}{Oป้ๅูs๙๙ฮ]๛g็ึm฿พ2U ฑhWaแมฏ฿~๙แ\IทฺOT˜—๕๓[R๐๑ฝaWHn~๙–/;<๒บล๋ฟ(ุ๗Ÿฝ~o้๕]ฑใแื-~๋ห=๛๗}๛๙๋ณณ“ž๗๒ฌ[ž฿๐ีป3k๒โถ}๚ืซ๛v\ฆ*๏ฑm๛Ÿ{ถ๓‘œ๎>ี๔ท๖=w๋ตK?ต๏๛อ/ ๋rพ_์ศฬำ$แ'MD(๋(?1Dw† O†+‡†ะ็'ห่D;พ๛-ศโฒว๘๓Hศ#Sวfฯฮ›•™9>Yร๑์3B’˜‘“™ฌa LศMŽะ&Ž—ช“…ฤฅgfDI†rNTdฝไดดช.\จ๎ธูฮlvสB‰\j3๛พ๊แH@ฆRu6ึ™$ikั7ƒJEปศฒ๏’~เๅR`kญi0‘€™˜4[œ`ฎ)*i๒ฌ๎Dˆ„<—ซปืE$GPี๕ึuกMษษแƒฟL’ขศ199)ZบไQญฮฤ๐Zg DMฝ;๖ะ ณfฎ:‘ฐเแ|.@ล†๛๒๓๏ฐฬ๐ีผYŸืา4ฤNน‘๘์ฑiท-๘o์“3sqะพ๐!๗๖๙ำoน{๑Eก9i=U–"65\ฎHผ*Zp… Snไ๐Šพ1ถyi๛เ[งNyhำ%ๆGŸ+ฐญฝ5??ืญ}ดh์&}BnKฤž{่ก—O$.xpํ๛+้”หSฮฝ:sฺMw?Kโ''‹@rรยeษ'W7uฺw S^š“้™ฆ๕8v›ๆ˜Œ=Ž#;Žวvฅฉง#'•d‰ขHKโ  ‚8ฤ=๚$Hป(๑ค๏๙๘v฿{ปุ?พ}K@”~๗.;ผ้ฒf๚Ž๘ฅS^๏žฆษ”ฬึิรsƒก4ภล_=๙ˆ‹$ภ๎t๘‡ั ภ;ซธวi‚A~๘ิ™t๊ฆิไษ“แิํ)ฦธD4S|ๆฏพ‰Dเิเิแๆ|ถ๔เัฃžภศะลดRvJ๖ศ‘ชgHฒERฅหืณฒ‚Jีณจ3Tx:$ ฉYโฐ k—ฮ๐หั(Akต*,Oผs €[ˆ zลR„ด]xŸ\ˆๆx3O0[4›˜>;KAฉ,m[๔รู ศฤK’2 Qชัbข๘จWฐ้ทฆ–[‚$IQ VฃำQ”˜HR๖้ŠsnD™(–Œœดสาึูฦย9J฿ฺใ4d‚น๑ฉh"—ฟS”๔Ž mŽบะบ(PโฃS#ัŠชS.g&ti$tn^ฮฮ–Žชฯ๓๙Hbรโสฟฎ 4Mภ์๋O>ืตo็—l๔เ๏^|๖๙w=หw_]วบึ๏€์ฬํฑฃ‡<%E฿ซ๋—^น7ž˜|๊้ำญๅFšน6็R‹$1 อqห9“<พ’˜฿œใ8†.5่[Lu๗๎ํ —#ด6hๅ์ซxฏ๎ไผDๅ‹๋)ู"ษาหึณtA๒๕”่ •Ÿษ#_?ัu*ณ˜ิถํูืฬ๓™˜๛าB>]\a›฿ฆ*pูฬ๒Œ?œจWซ2r๑’ดDtAี]Ÿ›ฮ‘ถญฏ๐ๆ >ึ–chR6^’B@|>”Pไ"i0maM7—อหR<ฐ,›อๆcJm4i๘Xx!-”ษY(š™3๎๎0ฒj-“ ŽอH‡ฐPr^ฌฺ์hฑii€Rึ๊ี้t€ฆi1›•9%™ภค;mq6๋ืO?#X^_ฃ(ปชB๙œคRซืkXน^_ี›—ณณฅฃ๊๒ฯี๔ผวj077ฉ‰5v‡•%ำMทํMŽ†ˆ–ƒ๗๋s๛štn!Œ๑+_P[>ฤƒ=๓Oฏ™ˆอ๔ธuโุปแ‚ย‹šญ5›YŠข(’,฿%+_ฤ?๋kงFS๛ํ_๛๒-š|บฆฎษศŒ๙ๆO๎หŒญTขๅฎ๏๓฿{๚[Ÿ^™ิ;=้ฒ|`Iมhš‘_” ป&๕ฝํŽุ๐ฤฺธ™›ปx2ฐz;จ„r9“ก“ำ๒ฏ๊อหููาQ๕Jฝ๗“go}่_^พ‹M <๛ท฿~ำ/—Xณะ๚'uzzเศƒ‰Dddœส7ž{ป‰ŠM‰ทVูฃSฃณ‹–ไ๘๔๊Lxๅ-nบp์฿"e'ฮผ๓3๗O_๚=ภ'}g_|ไ{/~่ผ๏อ็ฟ`€_พw0๚]๗ผ<+[๙"มทใฅ?๔ร#q้7ฟrŽฟ€Kว~มฝ฿๘ูomช์ฬู_}ฑs+?๊พ0ฝ`LŽzW*;๚ฬ“7~เ…ท-Lยs๒ง?x;ผœุ๓ภ#Gพdเ็†๓๐ฃ%wŠ›9๛ฮOธ๕W}s~๐ี|๗ฉ;ั๐ีC/K =๔Jด/{ไ‹ˆd=%[$Eฆžณ$ืC$:ƒ์้จฌE ั?Qตสฆ|ตฮ๖ีฅๆ\ณ๓ึะถ๖๕ิ-Mfำo‡ไิเOr"i:8“๚ศž?YZ”Dไ31฿๘ุL|›ช.M˜Ÿvmฝ๛’ฯฦ็]“ฌlผdh๛hทu)r๏๊ท๙ Pฐ3bปงC\!>์žPท;z๛X1๕ฯไ๏ณๅR๑4ว๐‰4Sูœ„ไ์่(ำm็cโyชkส5ke๕๗๗Ÿ8Q๊9‚หD้Z-Tฤ๋—|๘k9ฦๆฆZ.่๖ญๆU›—ณอฅฟึ฿p+:บJ๕๗ๆ}C๙u6L{เฑ#๗เƒ“.™ศ|๒แw>{๊๓฿y;ใ๘๋WณŸๆี}งIถzถไJ๛'ฺY›xA!ฮึ…3#€T5ํEป‹›ฒ๓ซ_Ržึํตา5}ณ//8ูf๋"ีmYญ„P,ฃบ‚ู๘ๅrRšZ‹ล ’ฝซ^อ›—ณณฅ#T’ฯ๔฿ฑ๗ำๅs็ฎ+G~๛ฦ๋ฏฟ๋ื^y๊ถภ‹5ฒฝUt’mฟžแA[Hˆ‡Ctใ๛๚๚๚๚๚๖v3พ`…ำ์ฏ๙K9ญ6ๆฏ้›•Xถe,(FA\6[ลerหา"—ษษ|aจ๊อหุๆาq,!„ะฆภ สfษ_ส…5ื๔อJฌ†กุ๕‘๊๖ฌVย็2œ29E>[๒๏Uฝy;[:B!„vึ๊ฅ|อ5}ำซพ!„BWฏฎยujg|%ฅc‹B!„ชFฑ!„Bจ๚เ[B!ดmด-๛vืฑ@i๏นs3ีทฮuŒึ5ต;l:VLG}.—?Q8–ฑํ๎ีLธ๒™ซ{{ํสะ่ฉษ@M๋ป๋่•e๋๙เลำฎฉ4ตดูMZ–เRQŸkาฟ๕ฏejด ญB!„ชHs๖คjZol้š  !ญฮฺิ๘๐D‚48v9งึ.rฆ0[แฉีkK=•]ป†}ส;ด๎{‹ยึย†FGา„ฆฉปn +แFฑ!„ฺR•,EJi๋;ฺ๔J’K-ฆง|‘๔†ฦไะึำษน3ฑ,๖…์F๕Tb๕-ฒJณ… นb๙฿I}S“*ไ๖ซ;ิR;[ฮTฃำ.ฯ'9Xœ`รu*ˆb9ŽS(™Œิ[ัu&ฦqV…"€!„ะฐ*ั\ฎ\.…ญตQ๔Ÿslฉฮ ฅ0Šฝฺะ ฒYฑฆฑำš๕zฒYVหไฃXตลB†ฦV_ฌjh6ลง™ฮ5ปP5๖|ดAy.›uปๆM3"ฉn่ดื๋Y15๏tS%, P(r…}ฉเ้ฎ`0ฺฺุชีjฏดฉจ๚ฝ ำฺฺ…!„ะๅjRฉ๎s: •ฯJ4หะภ%ฃ~—;T6์E$IQ Vฃำฉ(QHrMฉ5›…`(ำ2––:qฦ^;9 1=|๖ะะะ๐‡#๎˜ฒลaSคN+ฮœ?;04นจqดZู๒U*•ำ้ ๖ฅ‚ฑXฏืkทปบบF~7่š–%ฦ/ฝปํ๖ร]]z์ !„.KŒใ…^๐xสeฬฬนฆ”-Žž…Žอ๛<žPม˜.ป๓A ‚ะ6BVฯPูฬฯฏฬx%uvป*86šX@\6ณีfแDฝZ A\๘œ‚?œฺฃี@ บบอฺ๓ฮq\(๒๖ฅ‚(Vวใ)฿ะต/+/x<|๔ „BWŠOฬน.ฬนZฅฏowถYc็็Vž :oฏฝpู,ฐ,ภหฒู์ส”CBo1e‚C๙ˆ*ƒžU(z>Vฟปฎ_;}n$เ`#พฅยฤฅษาW๘(—(ฎ๙๎RษyวงปB!ดณTum6!4Idนl–€ณ#ัฮˆE"m๕ บˆ/A้๋อฤุ๒า`ฉMฝซ“@SgOL-ศิฐO3{j2ค‰าY,๚P*ฦQซI%„ล…DซตN›KQ5u&eฬ—(ธŒbB!ดmดญ}=u,์้ทCrjpศ—ฮลDSKwณŠ!rษy+ˆcฏ:|ุ=กnw๔๖ฑb:๊ŸY8Iƒล^*wย„๙iทมัึปŸ!๙l|5ศ@fnาญj๋kงลL<8แ md™- ”Jๅๅด!„B]฿(sื>ch`,ผ#kJเhB!„ะe M–šh0ฒSหขแX,B!„ช>8‹B!„ชFฑ!„Bจ๚?dEFษb้~IENDฎB`‚aristocratos-btop-d43a485/Img/icon.png000066400000000000000000000020441517514752700177170ustar00rootroot00000000000000‰PNG  IHDR00W๙‡ pHYs฿฿ฯEI…tEXtSoftwarewww.inkscape.org›๎<ฑIDAThๅ™ฯk$Eว?U™้IO61Aœธ."$ž ส"xX=ˆž=๊มƒ๋มƒ'๑๊M=ํ?ฐฐ7‚ศ‚'o"‘ภšศf#:$‡โd’๎๚ๅ!1ฬf็GuvโL“/ Sรซ๗^้๗ฃ^ xภม‡E||๗ƒ|RฃF้ „ฃ~€ฅฅฅO„–——ฟ-ช?rY–}™็9FใP˜ภศC่เเ€+Wฎ`Œ1็ั9$Iฐึž[ไž^9‚ัB€s–๏;aH๎้๐chv่฿ิšฦฮฑO}๏6เOS€'=p.่%ฟ#„—ร็ญeชƒภGZC’4RธIAฅกาZX\\๔ช&“BซีUถQฏฟ๖๒ยยŸRJฉ”บฝบบ๚๙ {C#`ญลZซย0l๗@หo‘1ๆน4M™››{มว๏P;qตZMVVVฎ๕๓"s๐F7Yป&Ifggฝ}–>JOภ+„ึ!ืBไFˆŠs๎ฑF๖EžฟOอ)๘ซŸญ฿!ฮฅดคต–ซีS™‚ภ๒<'ห2ฏณ‘oTB็*ก๋>@ีœญBฯ4ึQญฺg`]ค”pา๕แr„ะEฃ^ฏŸฎkตZ!ฑ 0??ฯกC–eDฦ‚@–eฬฬฬญ”๚Ž฿‚ึ๚kฑ  ต[[[{ฏจๅHโŽ””‡ZˆZท>๐ซ”Xฯy`มฆ;~ฟj ณiJ$ex๓ธ็๔๘4ึ๖ฬชปaศ‘'๗ญ%์่o)ปปอ=๘Œ‚JBฅ'0ด*ิl6ฝ๖U“ปสvkต๋ Wฏฎ !„R๊๖ๆๆๆWƒ์ ตŒjญm†ช฿๔x๓&1 ญV‹้้้—||•@Eื๚ํyฆฯ@“eiš255ๅํณ๔9Pz^!๔ดต”๚x ฌ‘ฝฎแ๖6žพฟ๔ณต ฺAhญๅ‡JๅTฆa-J)„^—}^,LJkใJyี9ศ๓ใ%ผ2ะiวE๔ม™| !zน{—#„.]ื> FƒรŽๆ–็9ีŽaฟฦ‚€RŠ8Ž๗1?DQ„ึ๚ฎ๎XะZ๏lmmฝ]T๏r$ฑ€Ÿทใ๘ว–”7ดึ(ี๗ธSJ)œs็2๊Eเฌ5gf~SJศ๓œฃ\็…scLฑ๒s‚า‡P้ ชBฮ9โ8&Šขม›'z•J…sก>Ax}ฮโ_Œ–$PอซIENDฎB`‚aristocratos-btop-d43a485/Img/icon.svg000066400000000000000000000052731517514752700177410ustar00rootroot00000000000000 aristocratos-btop-d43a485/Img/logo.png000066400000000000000000000017641517514752700177370ustar00rootroot00000000000000‰PNG  IHDR]bHgAMAฑ a cHRMz&€„๚€่u0๊`:˜pœบQ<*PLTEXXXืNNNฏDDD‡:::_000&&&veœvtRNS@ๆุfbKGDˆH pHYs``๐kBฯtIMEๅ 3ณ๋๎kฅIDATxฺํุฝj@p“+œไ ^„-฿ุ}เPo8mภ… ห€_ํ.Uเบจ9ธึญnฅvs’ ๐Wffg๎wc0!I‚L›๏‰œ2ฝ€'=xแ…yผฮฮ†ผ“€ธโ|ศห= ่}฿A/๗$ 7๒}ฯ‡๏ห< ่ม /ผ๗ๅu“ฯขหกp-›ฏRงจ_‰4Mข5ฮฎึ!‹zผ๐ย oœ7อจ๙ฏํืหd๒‡K{\อม /ผ๐yณM5ฟูDะXฏ^ฤ๐šŸ'Tป๑สqว๋Wˆัผฮตื๚ผR๕kฏ0๏›Ysาฬฝo ๗:๎žZŸ'Jีฎฝ๋พ™9ง—C๐&\ศ-ค ^xแื๛๖‘'๙๗n๛xฆv1ูnฏ˜qต๚iนdฝ๕แ}žฬปeSทวแ…^xใผหชชBผีf<ุ[5!ผ‡FˆW~ฑฏธbฦƒฝ๊ธžWีCผ๒ซ {ซพ๛6ใกJล๓ถฏ3K{๙๑PoTเ…๙ผษb%ฌV๎ณพi์wใช็/ƒ^xแฦ๛Lฤ๗๊„ทผํ๋T|ฏj์"ฦ}หŽ๒>“qŸต๕]ฤ๘ขo‚ ศ่๙ ฏไžrฌ/%tEXtdate:create2021-10-15T15:22:25+00:00Oˆ aristocratos-btop-d43a485/Img/main-menu.png000066400000000000000000003451401517514752700206640ustar00rootroot00000000000000‰PNG  IHDR’†t sBITแOเtEXtSoftwaremate-screenshotศ–๐J IDATxœ์YR[ท/๚‘…jก T•ฑ๑ฒฝ\|‹ˆ€‚ฑ_oฤnภnสnภnภ>qžฮรiย๐็ฯ6–ฉ ช ค”R)eq์HHF„ไฬœ353™#Kฦl6@ุAWF๒่๒่฿ฟY1๎๙๗๒ืํŒาฟyภoฤฺsณS. ฏ5kฅณรXบชถภรK/‚โงƒโmๅyGh.๊wตz้,KU"โ์ม๙ูI‡™U%!?ˆะ€a ฟSีUv>ฯ๗'…`ฬ™i7ŸๅชZ_fฟ™มฟฐ4Vฺ๚{7ž.๓…“ษVUณonq~ฦญŠชE;?-ึg=ณห>้`s7žkบขQ[%u$๓ไณSๆ๛฿{๑lี^tKษf๐ˆ่๎Tuw•๛‚แ <ฃฉฃ๗+pNฯ›ซeณน™พส๓xt๑ู|tzา็2ห•RM&‹ผ[ฒีณsaฏญy^ธ Z‹้ŠLDŽ่๛EK>#Žtห=๗ikำY๔35๒-,N›„LนAd๒DŸอGร ;ีฮ…†zณž>ปR.T›WO€buๅxฒ"kjS6O •ไyC#Fซ$9ึ0Tฎ็ผg๖๕๒ฌซfส9งๆอ…ำฒขษbYสฉr“7˜็้R]%ตAถษq-‡]%<บ;U]eวAป๐•ณ—žออ„;ืฌ u๙ึ`lๆฯEKก5ˆํƒ~p฿>nTœŸˆฬฺ„ุ๚็ฯ฿๖J–่ฬ8ืŠ[ผ^ๆ๔๛็/›Kdสล๔i๙ฒ›คุqษ6dNฒไqYˆ8odฮ.์ฏ๋๓฿'jp~ส~1ฉล็ใ’›_พlๅอ3S๎ฎ'ภC๋;™ึๅEผีb”ๅ&)ีBถ$๊ ๙ ป‰7Xํๆ‹ผษH†66ต8็ต4 ฃัHD๕B"UVˆˆแํ›"T๛t๔ `่้ํTuw•Iw๘j๒Gฆดิๆื/฿ถeฃำฮ=l;๛xรOฬVkฃx\nจDB๊p฿ACp1{’ขฺน M› Dyelฅtฎ*.ฅv^j* c`ˆ,V[ฃ"ฅ;ŸŸดHh‘˜Iคซ2‘|.จN“‘Hzภz<ึไ˜๐yววึfz?}๋•FbzงaUส…‹‚eYMำฃอแเ8ญฎฒ์ๅ!)ฮท๔aึฅึฒ‡\ำ #อ:๕๊ๅิ๕ืฅ•Vท3ํฒS5๊ํ*u๗ŸบAMw๘Jฤ0ผัภSฝVJลJฟ%t#`Yvzzzbbข“‹š>~xํ7kpiึg5ต/Œว›'e"†a4ํโ฿†R+ธO๛๑a๎:ฎฟฒฒrw#บจ็ฏ†1๙—^ซDฤrJ]ธฌา๕zน”๋ ๐0ฎํ9gไๅ‚Kสฆา{๑RตฉQRฎณตฟชชส0Œ’฿œ'โŒzuiญ’ู˜ax‹wvqž6w๓—gฑซ€Q๑cW)ฆwึ๓ืว‚jณe@z;U]e็A}R:7ฯD_Nšิzนpv|œ๕งฝL~–ฅWL~:ู'หฒ\(ŽŽŽT๕วˆyB86›อ’tวม๖_–WKnผั4.ำ†3๐$7•-cFฝH0ฎM๙๋Pฎ ซzJำดzjkด“๛๛~[=ฦฝ"๋๚๑/™ฏˆๅ,nทMฉส’JD$7d4rD ฦFC"โฌใพ’-7H“ลbนuู)ํNุUภ๐ปฑซิdฉู^Rwงชปซ์>พ3y่L]ฌ™c–แ,พ…ื‹ฉ gถYb .CฉVD$I’ู้ถ ึ‰้)๗_ภEuฑftธฬ,k ฬ=›ดทฝ%dฐ๕่7ž็ตFฃใ้,…g๓๓/ข—๛ฟrฑh๕M: g๖'˜BกFDึ‰่Œ฿ฮ3Dœูํดึ๋x๚<๚;U]e็A]–ภlฤ็ฐXMn-ฐ™ M–๊๕zฝ!kšจื๋๕†าEฅ’$ํ๏๏{ฝ ฝ‹ัhEฑซ™ถ'gbถูนื๏Œ,–Nbู‹S%ผs๚ๅปyNญŸ'๗b"ขF&~ๆ^x๑g@Lว’฿dŸ*ะy=์sฯ฿†yF‘Jgตถ'๐[O€พcˆ๕.ญ๘ฏ฿ธW ื์‡%_+Gxถโ%%ณฏX‰ˆš๕ช$•Zr7ฉไ๖ญsัWoZฝtถwZ%"%Ÿ8vฯ/ไต)žŸค๚๕_`ุ้๎T๕v•บ๛O ฎฆPeB3KำำฌŽฏ†ูฟ…$I?ฺภ˜อ?nYYY้๐ฬr็S4ym|_?๋๘pิ}ิŸโCธ €^ vg…]%Œ„'ฒณบ๗ศฟ_ฯo€ว๏๗=ฟUWๅ่ห๚ร.๚็ S๗ผž๗„:๕ภ๗Oภ}™ห„‡฿๖r2‘1๘๒ํŒฺ฿[oqั3yทเต‹—‡)ูญฯฑฒnqAwžzล‰XหฤL4ไฑY,%S‚าฟถ>œ=8?;้0ณช$dใ๑ข๎›ขฏฑLฝz6็v>Mย˜ำณำvฃิJ'ฑXฆฆ’#๚>"zMย๕ฯ‡`DH…xฌก–/_qฬ์|อ3ญฯœ3บจถ}c1‰‰๕ตำ๋ฏtิ-vžฟ'“.b.lฏoื4ณwลยde5ัgO•9 1้ฟฟd๊œ}๚๙Rธ๙ t;  พ™ ืธ=ว0๚็fญฅ๕Yƒ‹ฯฃพา๗ิ]YI!~c‘wหีโ฿ ีึ๛†5ฅูธ8โo ํฅฤ^Wว›๕‹wLVืฎ฿ฦ๛d฿J|ใ‹ใฌใพ’-7H“ลbนuู)_ผ๘“gฆ”๓็u•ˆศโrMฆ—/J:V์'kk'โฯณ'’e™นZ๓ฌัhj๖ฃzรฤlฤš฿/๋œ{ธ™Lฆ๙๙๙p8||||{๑€‡3>>~|||g๒ะใ˜ To๐QSใ^ฏำศ2ฌม๎ท ยี๔บล ๊W…ฒ0ๆฺ ,ห[~ท\๐@#ร:๑y†ˆ3ปึz2)ณๆg็žGฦ/†ใี๘๊ว _Žสjv็ฃn๒@Djฅ$Œ๙'ํF–5ŒŽrก๘Kฦxษ่Xr๑๒——I’ดฟฟ๏๕z๏lฮ?<ฃั(Š๚รย[]=‰่อส4UW7Z700v›Uฌีnป˜ˆH-œนขณฏXฅ!b™หกพn๑Ÿƒ๚ล๋ฉƒ#stuศHฒx~บw*t฿ฌGOษ'Ž๓‹yFmŠ็งฉห/ฟ) uู T๋ทuzค๔~ฬ4;๗วค‰i ูุA๛{ฒ9ืธ›7ำ๒?‚Dw?I’คN.ซC0Zฯ_าก๖?้ฟ3๎ฦTตฬม๗Lงล ๊Wล\l3ปsแOšVK๏ญงu b฿ฺ|qอิๆงg*Žท 7/3*~^ๅ๓ี๓—๚ ื/@ง?@ง?@ง? ฃ‘~้HWพGฃา๖{ื๙t ๙t ฯoึ21 ylFFKษรร” #๚…Ÿำ4"M‘*™ฃxฉIŽ่๛ˆ๔๗๚Y่ฦgธ‹1๘๒ํŒZ ฟ๛qฏๆ]\švฐ\l๋จิ๖ๅkรฮ2๕๊Uุœ๙tP$"ึ<>3ทY,ลRU•ˆXk`~~สiาฤ๑^,/้๗บ. “.b.lฏoื4ณwลยde5Q%ขZ|mฌNฌมYžŸ*}>*wYY\|ใ‘า yrูุ้๙แึ™0Bษ‘erz\ˆซ/นณ}ึ g๐ฮดำใ๕Žม๋ฐkง฿WฟฎTlัˆื@Dค•Nชo๙ํEGๅ8%\Lyอฏฝ๎N80(ํFnึ๐๋„4าIศ๎๏๋\ผิํ‡)ใ——้0&๗ฬBˆO'2Ž๐๒ˆ”=MœHžฦ:ยaKvwG"บvฏˆFฺy&U•5’ฯSy๑ตF™‘ZKํฎงn”๏ต๓ Y–Yžc.Ft๎น“ีต๏)"ช%ึ~zผ’,หวต>s+ห#2ึ6งC9O]ฌS3ป่7ไภS็{kB๐ญ฿uržดฬโrMฆ—/~wฌุOึ6๊7{„ฆตkŒ~ฏkด™Z๒€Q…ฒ๑ํๅTM3{nน’n™๕&ญ žp$E๓Œ;ยYปAำT๕ๆ๕์Šฆi4ยม6 ํŽqฬn’—๗ฆหฅฃอขขhd!FำTUSo^ิ3ช๑ี๑ึGCเลŸถไงƒ"‘้ผ๑lๅดศฦอๅณvTา๏u]@0(๕ิม‘9::d$YวสDฤZ๓๓SN“&ๆ๗by‰จ]ฏ๋๒€A1๙็"ๆย๖๚vM3{็_,LVVUึYp‹{๛Uึ}พ0U๙o๗*a่€ี—k[๙&™ƒKฏง<ฉ๓ฒ'`ษo}‚o}ฎใRN#–็I–ีปg6D พ™ ืธ๊h1ฑพv*˜ˆqM…น์ฦื ?ตผเท็ใB›^ืล‚qภ€ฐc{%“šช*ืา้"๏p˜ˆO-}Zn(J=–#ว:่zŽ6EnชชขจDชขจJSVI#ab""ฦ่‰<_šดึฐ˜u†B–qช~๛dœWลj]Qj5ษ`0ต๋u]ภ๙€แyƒ*+WœP้๐KIU‰wฉัะฦฆ}ฤqฃaด‰jญ็h“’ปำ‹o?ฬฃ๑ญฝ‚J”OV฿xคtBž\z6v~ธu&Œิูหไ๔ธV1,^Nฝ0ฉiŠ,–“GฑtU%Rš2๋ถšXท˜šr“จMฏ๋๒€Aน๑ฺaญ5ŒcYVำ4ฦhs88Nซซ,;Zฦ‡Ža"ฑw—k`vnJุˆ R`#ฯZ|s๓Sฤฮvฉq๗l†‰ม;ะN7๒2ฎbี“ี$CD g๑ฮ.Fฅฟ“iฅำฤฤ๒&ๆ๗"า๏u@0(šNLUU†a”๎็<๏gTUo*่็šp‹™ฝฒจIษิ+ฏ#.œ3&๗ฬBˆO'2Ž๐๒ˆ”=Mœศิฌ#ถdww$"รจ*7ค‹Hฉ|5hตIDj-ตปžบQพื„|เ้2{็ž?Ÿqsƒฎภ“%ห2หs—‡ƒs–F’ 2/6LฃัุhHซเcภฐ,i—cf4–eˆ๗ฬ.๚G›๛[`์|o- ๘]ฬํ๓—ำh พkeeๅ]ฤมzŸญผYLsK“ถหI4j฿^ื œxบXณ้lFๆ&ภฃฃ e!โฺหฉšf๖๚r% RŠลูเคฃxVๅœม ฆฐ‹›z!ืjอ)ฯธฉ”o0ึ ทตVInmE# 1šฆชšzหx{่Tใซใญ†ภ‹?mษOEbว9‡ื๋ฬ‰e™ณ๙ฦญBฎ#•๔{]?<]ตฤ๚?OHรฅSO™ฃ๓ฏCF’ล๓ำฝSˆ”ัพu.๚๊ญQซ—ฮ๖N๑๐ึTN2s3ห๏ๆxญY+ลำ)ญ7ิ ้๚ณ็๏|อ\,>ฺ๛BตprไŠฮพzo`•†Pˆdฺ&บฝฎ ศž.“'rหูฃณ2^N0 ช˜‹mๆb?E›็‰ํตฤ}็i๒Lท6ํบ3v+ญm\7๘็˜Œxนb"Qh.ด้u],'ญž.Ui6Muด฿น 0สุ1‡ฝ’I MU•k้t‘w8LDอj1{ผตฏŒ์q๑กง‘ฦ0 1 c๔Dž/MฺGkXฬ:C!K๎8Uฟ}2ฮภซbตฎ(ตšd0ˆฺ๕บ.เภำe ๑jชy๘y3Q ภ@๐ผA••หพt๘ฅคชDT-d‰ศ่`อหิห“šฆศb9yKWฅ|ฒฒธ๘ฦ#ฅ๒ไาณฑ๓รญ3aคฮ>X&งว…๘ทŠa๑z๐งfชDJSfV+๐SSnตํuC๐t)bนTR$œ˜ฏึบฦAgช'ซI†ˆฮโ]Œ๚K'ฅมFžต๘ๆๆง‰ํRใฮน ƒw& nไe \ลt›IZ้411ฟ6ค‰๙ใ}ˆz๏uศž.)wธt%ž4ค๏@•าลIV)•ฏญV"‰1นgB|:‘q„—฿Fค์แnโ|DNลฒŽpุ’‘ˆ ?ขบอ$Rkฉ๕ิ๒ฝ๖บับะ ๚ษ์{|ฦอ บO–,ห,ฯ]vฯ}XZกวศ41ท4iปM#†ˆxฯ์ขฟqดน_ฑฦฮ๗ึโอ€฿ล2“กbq9ฆเหฟVVVEฌ๗ูส๋Eฏ™๚z๎u8๐tฑfปำู,ŒฬL€GGสBฤด—S5อ์๕ปๅJzฤ.คMsxฝฮœX–9›o*ไช$หG›EEัศBŒฆฉชฆ2:ี๘๊วx๋ฃ!๐โO[๒ำA‘ุ๑_›ฉฏ็^‡เ้ช%ึyB. ˜z๊เศ2’,žŸ๎ DDฎูKพึ™มg+^R2Š•ZฯQฆNŽ\ัูW๏ ฌา ฑƒLƒˆ”ึ“ซ๋…tู๓wพf.ํ}ก~3u้๗บฮ!xบLžpศ-gฮสxภ€จb.ถ™‹ –b๚ำŸพ&ฯ๔ฏ›๖Uฐ๎ ‡สฯ>็˜Œxนb"Qht>e็ล{ ๖FซeพgฺML๏|K฿^wดจ_อlฆ6?uะฬŸ่๖บฮแ€ง‹ณนฝ^—e„ฮฺ@t7ํซ o๕่l๘Œลๅ๕zฌ|WSv^ผวเ`Ž a3;ว˜อๆซ_VVV>~8ภฺภCb8ฃ‘ืdฉ‰ำๆ†[บ›๖UPี฿๐9ƒ‰gไFCั:Ÿฒ๓โ=๋wดh›ูข? โ๚%€งKSาห€ัด๕7|ฅyํ|สฮ‹๗ฌ฿ัข!lf็pt ๙t ๙ภำet‡ขัเ@วpภำลวf-‘ฌจƒฎ ภSลZ&fข!อศศb)yx˜"ึๆŸ›rYxญY+ฦาUlฃ๗g พ|;cฟศ๏~ซy—ฆl#:*ษซ[,Sฏ^…อนOลถAึ˜ŸŸrš41ผหKDmz]็?<]๕ไ๖ZŽฃv๋ภ#b๒ฯEฬ…ํ๕ํšf๖ฮฟX˜ฌฌ&ช฿ฬŒฑ๐}5)2–เโrฤ[๘žnบฆฃซ™ู๙šฟx>*็Œ.ช52{–ึW!๘ึ็:.ๅ4byždyดา4ƒo&ศ5ทืT˜หn|อ๐Sห ~{>.ด้u],'ญž.Ui6Muด฿น 0สุ1‡ฝ’I MU•k้t‘w8LD&žอVeUmV eษtํa๛ะ=Mi6.๐ใA{้$U'4†aˆaˆˆฃ'๒|iา>Zรbึ Yrวฉ๚ํAฮภซbตฎ(ตšd0ˆฺ๕บn๚ภHฒ†๘๐aษ‡Sัƒย๓UพzB้๐หfR"๋;™ึdj1ส2N>๔๋ ˜๔YQ%’๒ษŠs๑อด1—'—ž๙ว[๑๒H}ฐLN ๑“ŠvGPiสฌูjbY‹ลิl๕$^ืำxบฑ\*)ฮ? ฬืk๊ี–59&|๑qทต™Oื-]ใพ๑zvญFDDR`#ฯZ|s๓SฤฮvฉqGแ!c๐ฮดำผL;‚Z้411ฟ6ค‰๙ใ}ˆฺ๗บN!xบคแvnะ•xาtำwฮyนเ’ฒฉ๔^ผTmŽิa๑แล8Nฑฟ<าฮ˜3 !>ศ8ยหo#R๖p7q>"7RณŽpุ’‘ˆ ท‰HญฅvืS7ส๗zะ๙ภำe๖ฮE'ไิ๎qอ3;;กคv‹ธ—เ!ษฒฬ๒s1ขsฯ}˜ฌฎ}ฯ8‚FหvfDFณ#ยๆt(็—7๐žูEŸxธy$˜:฿[‚oฎ“๓hœŽตธœF“้ๅ_ม‹฿+๖“ต}V'ธv"Z\ทืฅบ8ƒเ้bอvงณY`H2ต>ภƒR…ฒ๑ํๅTM3{nน’nฯ๓ZฃไกฟŒcvƒผ|ส\:ฺ,ย/y IDAT*ŠFb4MU5•FhXฏ~Œท>/ด%[jี ๊ะํu@๐tี๋Yq.พ™6ฆ๓๒ไา3_ใx+^ฉณ–ษ้q!~Rนqฤ2๕๒ร‡๗๏฿พYž๗Zฃ|ฅ)ณfซ‰e-SSnต๋u]ภ †ˆR/—JŠิๅ!aEผ(uฟโOูS^uWmp5žš‡›nœ|าิ#Xฮท๔aึฅึฒ‡๔^ฐ,ซicด9งีU–e‰คมFžต๘ๆๆง‰ําˆab๐ฮดำผLซX๕dc5ษรYผณ‹Q้๏คDZ้411ฟ6ค‰๙ใ}ˆn้uBCDสn็z(uฏโOูS^u๗๋lต08m3%ณ1ร๐๏์โ,ŒฤYวฝ#‘&‹ลrำํฒท) 2/พฃัุhHฤ{fฃอŠ-0vพทoฎ‘นษโrMม—ญฌฌผ‹8X๏ณ•ื!‹ibniาv9‰Fํ[ฃ๋บ†gs:mF†ˆˆ5[Ÿ{ vพ ๛UIwสkQฟๆ๙ปƒบ†ฐž๚Š๏lf็=ควฃ/้zฐž|ฟ๕Xฯ~5๓ฮส๋P…ฒ0ๆฺ ,ห[~ท\Dึ‰่Œ฿ฮ3Dœูํดึ๋w" ท+‹V฿ครภqfOp‚)j$—Ž6wฮ…b4MU5๕–๑๖ะฉฦW?^๘rTVณ;ืNฤฆฦ9ผ^ง‘eXƒ7n„vTา๏u]`ฬf๓ี/+++?~์ก5=b†ด‹งW_}๎1ุ๙‚๎W%)ฌEš็๏พn‡งž๚Š๏lๆํล๛ธ {๔%]ึ“๏ืขู๋ฏfYyข_†[ฌe" y์F’ล๓ไa,)(ฤX๓๓S.3ฯจM๑<ี BG\ณ–|?N๗(™ํลJdp†็"พฑk๏ธฤX‹ฯBc\3:,ŽUb†ภ‹?mษOE"ฦ๊›NนmVi…D์(_oท=๋๕บ บ้ภOAŽ็ …NNN๚ู&€˜<ำ‘I›Rฎh๎p๋ƒค‘ษ3=ำท *xื‚:Ÿาv๛”ึขอ๓๗#ค๒ลw4ณวึฟฮ [>ย๏Xz฿ัƒ๏ฐ๒-? ท4นVฬฆฮNOฯ’™‚ะhMีฌาษณำำำณิเ}wชบ฿ฆz•ˆˆ8วไlศลTหขาy๑ƒื็฿ใ”ซฯNฎ9+ึ‰ˆTฉœK'ฯฮ’™‚ะผ9;นšO%ฯ’้RฝํmฤZ!]|S…์i๑โTณฺ๊JงษTถ$v/‡nฏkัM~ โ๚%<ฮๆ๖z]†xซง๕AD๐๑ฬ}ชฤX\^ฏวส๗ฑํW้ฮ)๋๑๕แ๚%<†3yM–š๊ๅAD๐ั[`ธีm•ˆˆˆ3˜xFn4ญ_mW:ฎาSึ๗ม๊ไ๚%ไร-fไธ~ :…:…็/ภเก้ M) ไššฺ•ฒะะDA[ฐร-fxŒ>๎๗ปญ,๑ถ‰ึDมวิลZ&ข/ผ๛๐๗1ฐ฿xQตe๊ี_+˜sท- aอใัoใฑฐฑDd๖.พy๗ํg๑แuฃ‡ŒEญฌu้ฌฃ5 k ,พz๗แร—ณใฆ‹rท๕บเi<–7™ ิจK*g2จQ— AD๐ฑ[nทLม—ธ ๛ฉšf๖ฮฟ˜ฌnญ&.^l๐-ฝžฒจ†๒แงƒโvอ‡)ธผ์ศmd๋Œ-ดดdMญnW|<ใ6„เ[๏๙—œF,ฯ“,ท}ฤP๚ฉ‡ŒEอ67ืNล1ž…๗~ac7รO-/Pl5.ฺ๋:บz”S.x,TYบxัาlhคjDD๊ๅgญวเีฬ๏\P็S^๊N๙`-๊ื<w๐ชฮ#]๙ฮฟโ;›ูc๋Wgะ-~ฟ แw,ฝว๏่มŠw\y์˜ร^ษ|šQ-.NO:LT•ˆˆu†B–Qส:omS:ฤŽ9์•์๗šLD•๘ฦฟˆˆLค1 C CDฤ=3 “jb3^กขรยxUฌึ…ญIง่ถ^ื้ข{ซ9@?Yง๘๐aษวYCŸ{ vพ ๛UIwสkQฟๆ๙ปƒ๚๋v๘ู๊ฏฏ๘ฮfvCz\ะ=๚’—๕P=๙~-๊ฑžjๆ•ืม๓Uพ:5Q:ฒ™l ใ,“ำใBคrฏwร ผ}9็ต0DR>Yq.พ™6ฆ๓๒ไา3_ใxkค’‡6=ฤ2๕๒ร‡๗๏฿พYž๗Zฃ|ฅ)ณfซ‰e-SSnา๋:…๓0D”zนTR$ˆH/>๗์|A๗ซ’๎”ึข~อ๓w๕ืํ๐ีณ__๑อ์ผ‡๔ธ {๔%/๋กz๒Zิc=๛ีฬ;+ฏ็ฦk‡5๕bk๐ฮดำผLvกs ฑปถ๙}๕€ ={๑–ถ2R`#ฯZ|s๓Sฤฮvฉ1่JvGฏ‡TO6V“ 1œล;ป๕—NJค•N๓หoCš˜?ˆจ]ฏ๋๎x87†[ฦภห7ถ“Oฅ๋SฐŽู7sส๎ทcA3^iKโ‡ž/tœ}ฺ-hDdš๚ใต)๑)VbL๎™…ŸNœ;ย!''ew็๒3 w๗Cp๙O๋Y›Žฃ๋.แq0bLู็ฯg]> ย์k•บ_๑ง์)ฏบซถึ\๓pƒ,ห,ฯ]vฯ}XษโrMม—ญฌฌผ‹8X๏ณ•ื!ห@ซ9ฺd๙fZ i๑žูEใhsฟb Œ๏ญล›ฟ‹i3ƒกฃCLsK“ถหI4j฿^ื \ฟC„39อB—ปpึlo•’๎U){สซ๎ชํƒuฟ>‡*”…ˆ?h/งjšู๋wห•tƒช๑ี๑ึ฿qกิสy5โ ุสi‘ Œ›หgU’ีฃอขขhd!FำTUSooยŽsฏื™ห2g๓[…\ตMq^ื ไ0Dj'๋<%ญห๛k‰๕žฆซ๘S๖”WถถOoอรM๕ิม‘9::d$YนUwี๖A7YC๒๐ฤฉb.ถ™‹ต๙k3ต๙ฉ๛yš<ำฟv๏ƒug๘j'ะy๐ฮ1๑rลDขะธว<๕7รk๓์~ Šนุw•ฌ‰้o้‹๗ธ–๎ณ>;vญ‡hตฬม๗LGฅn๏uwย0Dxซว๋uY๎{นวโOgsทึุ\uWmx|tป๗ํม๋;ฮƒ?0—ื๋ฑ๒๗›งพk๓ฌืา}ึ็pร๓—`ˆ0œัศkฒิผ฿แ‹?AWkL}zซฝๅ†[บ๛๖เ๕@็มk8ƒ‰gไFCั๎1ฯ6›แy๖}uฅวตtฏ๕90x4ŒMiH=์A{,XcOoีกทภ#ฆฝ๏^๛k็มk”ๆe๔>๓ิ๗cžƒีใZบื๚jธ~ :…:…v,Nนป{ฮSft‡ขัเKF๗T๋ภํp<"ฌีํ๗š้ำbฏ๛{"x๛ธ฿฿ฌ%’Šmข๕กขบNO k™˜‰†<6##‹ฅไแaJPh,๒n9ภ_>ฺWษn}Ž•[หวม2๕๊Uุœ๙tP$ณwqiฺม6rฑญฃ’|wูแtฝEํบ k ฬฯO9Mš˜?‹ๅ%"^ืไ๐ˆ(นƒต25๋ƒฎวศจ'ทืrิPHMmฏๅฉ1j๗๐Œ>“.b.lฏoื4ณwลยde5Q%"1ฑพv*บvŠม7ไG—ฬž€%ฟ๕Uพ๕นŽK9Xž'Yญ#(7ZDDบ†qM…น์ฦื ?ตผเท็ใB๛^ื)œซ€GDS$Q”dผŽซSชาl4šชFฺๅxP์˜ร^ษ$…ฆชสตtบศ;ฆAื้qbก%wœบ8ภค‘ฦ0 1 c๔Dž/MฺGkXS‹ฺแ ผ*V๋ŠRซIƒจฝ็ž.k่WSอรฯ›•ภฏBอรฯ›้‘=0’x สWฏ7(~)ฉ*‘‘ศ2๕๒รคฆ)ฒXNลาีั:0>|,“ำใB[ลฐุ๚]ส'+‹‹oฺ๛Bต๓nฃ๋บ€เ้2yย!ทœ=:+ใ๚%€Qล\l3ปำj™ƒ๏™๛ฯำไ™nmฺug8์VZ๘o ๊๏C8วdฤห‰Bฃ๓โwฬณ7อิๆง›ML๏|K฿^๊มึgo-๊ข่๕บ.Œึƒn Ÿ8›๋uYF่ฌ=tเjำๆญžซmท๕1—ื๋ฑ๒]ยาƒญฯQม˜อๆซ_VVV>~8ภฺภCb8ฃ‘ืdฉ‰ำๆ†[W›ถzmญม6๛ฮ`โนัPดฮ‹แ~้มึ็0ะํŸ?qภำฅ) iHe@ุดฏmใฟ7จOi^น๓โCธ_zฐ๕9*?ลยแ.}6‘่pสมึณsฃาขวWOxธ:…:…๋—†ตLฬDC›‘‘ลR๒๐0%(Dฌy|f6CDฤ๒ศŠ พ™ ืhd\Sa.๛๋ืฒ}ฺo'ข6ฝฎ #ทฆ vฬaฏd’BSUๅZ:]ไS+˜MืdUmVโฺฮŽ์๑๑ก`ฐZ•|V”Uต)d ‡รFi รร1FOไ๙าค}ด†ลฌ3ฒไŽS๕ƒœWลj]Qj5ษ`0ต้u@> 0 ๔nฏ๋๒€Qล\l3๛5๘็`็Lž้[ฮีแฐ[ษ••เ“/WL$ ซ)ฏOpG๑{Qซ้ฝด๎Ÿ41ฝ๓MOฟ>๏ก™ฺิY๐:^ืนัzะ-ณนฝ^—…!๊i}x๐ฦโ๒z=V๚”wV~ฐฐ–†ฮ?<*โูึjF“eR“[ซYญu;๖`ƒ?ศนฝี#7ฎOygๅkkiธ!xT4ฅ!ต.†น๚0่เ5J๓2ช้MpW๑ฤZjศ€’๗๘’ษ^๔ƒmƒ๓`๐โg›อ&D๔๏๏๕_ี๚ู๛าu๕ุฬAฎ~ถ[บ๎š๏หาาใš•าฃ๎!ย*เ่๒่ฎ_ึ21 ylFFKษรร” ƒ/฿ฮุฏM“฿ธWX ึ<>3ทY,ลRUี์]\švฐ\l๋จ4R7/_g™z๕*lฮํ|:(E-๘ห—•+ูญฯฑ2ฑึภ”ำค‰๙ใฝX^"าํu,๙ภ ˜ssa{}ปฆ™ฝ๓/&+ซ‰Zf็kโyžœ3บจึ[ษQg๒ฯอs฿ถ๋Œ-ดดฯmW<K~๋ซ|๋s—rฑ5ฆถฯZ7Bk7O2p[ฏ๋๒ธฟnG*]๎ื™‡n—ฏ%๖E_–—5้!`ฐKื5„U‚ŽจBYˆ๘ƒ๖rชฆ™ฝ~ท\I_ใŒcvƒ์ๆฉ8 OญœW#พ€ญœนฑภธน|V%Y=ฺ,*ŠFb4MU5๕–๑๖ะฉฦW?ฦ[ ฺ’ŸŠฤŽsฏื™ห2g๓[…\ปฮsKฏ๋ ๒€AฉงŽฬั๙ื!#ษโ๙้ฉp๑ฦnณŠตฺhrR๚เศ2ป๘&ฬk’ๅd"RZo<จา๕gฯ฿๙šนX|ดWถZ89rEg_ฝ7ฐJC(ฤ2m“‚ถฝฎCศFsฑอ\์—ธVุt฿wฦ™<ำ!ทœ=:ซ;รaท’=:++๚ม8วdฤห‰Bฃ๓โ์‘*ๆb฿uV2ibz็[บ_๋๓แ›ูLm~บlJ-s๐=ำQฉvฝฎCฃ๕ [ธgs{ฝ. Cผีำ๚ะ.๘cqyฝ+฿U๑ ึif็pเQฯถV3š,“šZอjญ‡uƒ?ศนฝี#7บ*`มมz"อ์๒€GESR๋b˜ซm‚ื(อหh็ล,8XOค™Ctึ๑qๅ๕๏zฝ?{^ะศfM/ยีฯuL,งฅt๙_ืแw4Sท๒CX%€ฮแ่๒่ฎ_CเลŸ๖ิง๛>ซ๕G๔L}c#)ถฐๅwำาฮ็ขJDœw้ฝท๔u3ี$""K่ี ร๑—รsฦไžžžฐ›ฅV:‰ล25ต็ส้ใกนจ฿aิ๊ฅณX,Ums€1๘๒ํŒZ ฟ๛qOะ ๖พ;ฌE-xํโ•Jv๋sฌLฤฺsณS. ฏ5kฅร-m IDATณรXบฺ‡Uื[•8{p~vาafUIศฦโล๎^ง_ฃgรsน๘ชhtQ๑œˆ”RQˆบœl*ง‘ม้4Ÿ•‰ŒนYkig}งFึเโ๓จฏ๔=ี‡1็ฏXOdม-๎m์WYW๔๙ยTๅ[\ษอฬฮืลN9gt9Pญต >X•ˆˆฤฤ๚ฺฉx=b๐อฬ ฿W“"c ..Gผ…๏้ๆ`ซdDCL๚๏/™:gŸ~พ.>(๕ž<ไร…1y"s3ใv^“*้รƒ“r“ˆ ฎ้…ˆฯn$ฉ’>ฺOœทฆ&OdvzbฬH Iๅิไmse].s)~bŽบ์t.QณTง&Wาˆs:mๅ|Y#ึแ2[BS#า‰ร]พš€๗ฬ1๋Vา{‰r?^ี์๐xj้/ๅ†B”?ห…=ึธ~ )อฦลAwk(h/%๖๊Dค|จ*้3๘๓lถ*ซDีBY๒›อDฝๆ=V‰ฤRข’UิJIะยfQฯู ๒€กยMDๆlๅญตํ๋ŒผX•ฟ–ษšuV๖ึถk์๘์หู`q5.qศฌ]ุถ]ีฬล?n}ดใpูหน’YštYH‰H*•š‹N•ฦแtฅ…ศศ4Yนศไr๊ไj‹ฤศnfฉ๗WB๑ฺุิขฏ‘8n4Œv#ัํ#cึ 0้อขzg๐!ชd™z๙aRำY,'b้ชJBb}็rVV‹Qฎ๖š<๔^ฅz!‘"""†ท;lŠํฝJศ`Hฟ ซCmD{ศOี๏๏AีไสV ~aฑฺลธะT‰Š๙s6d5RนQ>ZdE%*Uฤจx9eณdHฌีoA]cย๙ก&ืฯี—้D”ˆจZ*ฑQง™ƒำ)–Nd"ขหk‚ผฯEฤ0าู฿k‰*‰้†U)๚๓บ–e5McŒ6‡ƒใดบสฒw=ึ‡s๛ฦู๋ตฺม฿_ฅ๊ษฦj’!"†ณxgฃา฿I‰ˆX“cย็w[›้t๏งD๚P%โ|Kf]j-{ฐ}X้ว™#ไ0,0Žbน^็!I†ฐJ๐ †aดห`5Mc†ˆ8{`>๊ณฒชJผ‰ฮ๒6—ห์๑ฝว1 Sv๑ษดLDBฉdœt งZฺky}uํฮง,9"oฃW kลl_ฦ้DDคช*ร0J~๗sžˆ๗3ชzGC‡)ใามจ’*7ค‹๗ณHฉ|5hตIœ3๒rม%eS้ฝxฉฺ์วm็ฝV‰ˆHษlฬ0ผล;ป8O›ป๙žOA €!‚ั nไzศU…‡'๙ย*ม/4M#ๆโ4ภe†`๔ฮ”ฤทoEE3^y๑เ!ฎOy ุ!+รeฯผ{H3๐ฒิQ)›วc/ถ๋e๑บอ\ฑ @ำด*Š<\?K`Žฬํ๕=N"Nป™็1ิย๑B!„ะ]"‡งๆ‡ป?[ฉห^*$wฌฑษg# \|ซB!sEŸฟ wูฤฦŽgzvVVณ…tฦ5๙๐y •g*พQฝ$(‡ำาํOศ†rุบoq•ชีvฬ&V๋Gq…Vย=1ฎุ>~โถร7‰•/zฮขor)นeŽEžฬฑ*_อฤ๗G6วKŒไONี!ฌsปี:={G3๐6ฒค”๗’ŽH๔ษK†”Eฎœุฮ‹,คgf๓S์ƒ๘$ล๕ฒฅ๔ฎsb๊y€&”Nปถฟ} ;ฤผ? „B™ฮมฺยมู@•/&V‹‰SaRuw๕๎ั_๕ฅ๎ฦฺ๛ฃW$ฝี˜"6พ/|ณฝฟ๎DVO็@สป๋ๅ]8K*m/–zmหฅuj้ฅ๔๙„ส‰็บjy๋๛o%Kj+ฟฝš?Iฬ~\่๙ฯจญ\|97เ]๔ ;B!„Bม๑B!„Bจ_8~@!„B๕ Ÿ@AV๊๗mปrญทพฏNงnเแ_t:{ํ„4๕ฟ™]ว๗OึJHY๊฿ฯ ๐ร๐๗~๏๗บี‹ฉY>5]v3ฯdf !„๚‡๗B!„Bย๑B!„Bจ_ท<i(โ‘ŸV?Œพ6Q -พX4่0ัjงUอ์$rอำ๏ถE^Ž๓++YฝO“ำถัXฤgcUพšI$šฒ^Bš4S'๎๑hศme ฉ]อ$ถšzี1B!„B_ฐก^^ฺ?๕้ ฦ;>ฮ–Wณmย˜z๖”Wsฝลฯ#]แIg;พฒี$‘“มฦ‡TS;!Mšฉ|ฑqถธ๑aƒ',ฃ33!wqฃ0เฏ "„B!๔ๅน์๘a(""ฎ.gx8q[`("าูส˜ฦรNถSŒ.๕ilCื …ฆค4หuมg4t ฎptlxˆQP(Ek6—ซ•{We€Rฆšr™Sอ–nlฺ}uสน๘Jบฎ๊ฅ.ูฌยjK€Fjๅอeถ!„Bกฏื ๎?˜<bs๕mยš}tทซบ7g_จช,ตู๋d"ืT€K/oeวlbฅf(O8jๅ6>l4Uฃo๊ฑGou@XEu(8ๅำปขศZY€–fBŒษj ฐIจห ™:M3*i™ ์ฌฺ.งท…๖ภพŒŽBกo˜$IƒA๔ฆe#tg Cงs๑, Aฺ…ฝB[hี8uฬศˆšัš{+‹Yสไ‰NE|ีYHƒmุ๋qปๆNn+ว€ษl้TRœคด[|‡H’TU•`-6EฉผB’d„ ฺอrฝ,ŸXลูิYH›U][]ฆ†Fงงรž๊zSช๚ส๐‡?ผโ’๚__-‰/ธD๗ะีKศอ๋•ทพห็ลซิz๎(K่F …p8ผฟฟ๏ฯE๗ŠษdŠลbลb๑ย˜{Aƒ ฝXŠ$ ‡ฯฅfภl({xvา!r๑Tตู้Ž‚Pี~ฎ๙+ŠB„\๚๔ถ@๛EQ๕ฉU)œœค™บ j-ะ”Tjฅ๖Sซ๒ีwB_ฟซu่บ๏—ูŸ\?v‰พD๗sศื;W—ฯ>Wx5I–ะMKงำกPhzzša˜ปฮ BŸI’T,www/Œy๙๑ƒ GรอaAŠnฟ฿0‹ฐ™ๆัšHgภ'ฆmไO= ฌ^”ะIe)X–EA'ก.สไtZไFน.(บฉKg>•ิ฿HกoฬUบ๕—ฟ€ก/ื}๘]œŸK^์๏wตืY๖ึณ„nข(ปปป๔าบŸ.;~ม่tZ๒’jฝ฿ˆ2šY’๏P—Mnด'/tTสๆ๑ุ‹ํบDYผn3Wlะ4ญŠโูท 't^ฝR‰Fl•L“ฒ†‰๒งฉ•˜“ำ!3To6๒2่คฎ4jอฐืoฉ็ฺิ฿mฌgšgSEมๅ;๗—ฝ€ /๕““+\์๏ๅW[๊–ณ„Bธ์๘Aฬง2ฮษ‡ฯํ\"[๖Žฏว>6๛b‚R๘Z6žh่-ญ”๗’ŽH๔ษK†”Eฎœุฮ‹‡ <3๓ŸŸ.}Zˆ—;…tฦ5๙๐y •g*พQ,ษฅไ–9y2วช|5฿o๊%พ)Hฌ๙‘ อิ…vาzขU+l%Š๘๒V„B!„ฎ0In์ญฝ฿;ใm้(Xศmt_ฺ๊›ฺสoฏๆO‡‰ู og=PฅืZ;ต๔ฦR๚ย„@*m/–Nญ“บา.&V‹‰^ฉ"„B!๔อ!๏:!„Bก/ฦ@ฟิHพ[ฤzB!„B๗@!„B๕k`฿@}น2}|lฒ๋๏Xญ๚งณV๋แฏะฏ้Aฉ๛qฅA}bฉอผ‰ิvฅ?๘ม๔Oด๛_8Ÿง]s'kบๆžฟ]wk4Qทฐ™๗0K!„๗B!„Bย๑B!„Bจ_8~@!„B๕ ว!„Bก~แ๘!„B!ิฏSใI’ ร]e!„B!tฏ †ฮ้ท๐zkกP‡ร๛๛๛๘๊7„ะ-๛ม~pืYธU‡๛๖ํ็ใ๓ป‡{ๆf !๔u3™LฑXฌX,ž <5~HงำกPhzzša˜อB่N}xื9ธ๐๖_ใ-ฤทฎ๏ู๓ป‡๛ไ YšŸŸฟŒ „พ!’$‹ล“งฦŠข์๎๎ž‰๚๊เ~๔bแธผzj๏ม‡ฎoaฯ๗๏๎ซeiaaaะA!4B่žน‡ื}่ฬึ“๛]_๗ž๏฿=๗0Kกoพ !„B!ิ/? „B!„๚…ใ„B!„Pฟp€B!„๊ŽB!„Bย๗/!„เื8^พ|๙๖ํ๎o?ฯV่ว+/ป™๗0K7กŸอผ‡ป!„ะ]ม๛!„Bก~แ๘!„B!ิฏHหศฬใว=ž๒™ˆมฌกมณE^>Ž2๚ฝz99|ม,>6๐่uฬyำ9C่3~๑dฤจ๑ฆเ“น๐ะญ็็ ]/ใ้7็่Gฟ๓ปŸct#ร/๚ฏ“฿๙?๚“?฿ู+๗ฅืy#;นฟJUฯภณค[{Ÿองu๙w฿}๗ำ  zย๕๖า97–Otณt+ภž%ไt7ๆ*lc3๓uV?X\nq๏ใฺ๊F‘๑XณN„nšPN%™štื๙@! วฺฏรฟ๑ค๖gŸI)ณํ๓๏yub๚~๎๏๚฿+๑ปไnา๑ฃฟ๛ื_่4็ฏsพ”J๕l>นล๘วk“‘4o"๕kบฑ|ขปrณ็m4ฎ฿๛ะ๐ท‘^แ(ƒี9์0ษœ เŒฝ๖๐Iลd๒๓ุ่Pmk%อฉ`p…ฃcรVFjูDถ!้ฦDhPบฅnˆQP(% 0~๑ศฯ@+๕ก<ชv)k`":b7’Rป–฿Ke*ผrb5”#๚4J$–ถซ๒1B}"XWt*:ฬv*ฉO๑|ฬฃOŸŒšอ๛ •๚ฐœแ0ธยฑqท•V…Fng{ฏ ฟˆtถ2ฆ๑ฐ“ํTw7ใŽ7ฆฦŸ๙‡+ฏ฿๑ง๎Ÿ(ฬ_๘•๛`๑Wพ๔ ฟ๘P๓ฟ+๛ำ$R“?๛๋ึใG๐ๅ5wลŸzf€wโ๏ำู06พ๛ล—๓ม ตฮว$žkฌ๓GฌๆNึh ร็–โ–๊‹ธRegcซ(hทฺVญJ๕ไ1’j้O๑\K`c“aฏ•ก‘Knฅkะ;๎šYบ‚ตทvๅดš ํิi๛่dุkfhš”‘hํ๘T0๗ป๋.‘:บwŽ+ภj:ฯตTขีุูq5บภธ'žออF&.ฯถญ!ฑ[ตŒˆฝํธ&สŽYนญล7o?๎)‰ U7&BƒByยQ+ท๕แอ›ลอ\๛pdฺHพ[XXX=}มฦเ ีƒต๗๏>lค๋ฌJGา6ฑWท“U๙ข˜ก~=~c้ำ๒าV2tญฝฅ……ฅtK๓๑SA€~w%RG๗ั0Uโหหu๓แ!ึ,!š˜W5˜๛”cุ^‹/&ชงFทjM‘rซVํศร2ม&ณEฌฆ8@.k#8ํ˜ Šษl้TRœคด[\!šehเ[ีƒD๕ิ?XG#๖jbฅ&_๓k๐๒ๅหปฮยmธ‡›yณคip๙ ้Lเหuํ^ฐษl+)ฎฃTJ5rิฬB]€vaฏะ–Z5Nำ_ฺ฿๛`|๔ำ?aฎ๑\ blค?ฉ’1ฑฬบ=”J%ํฅ3วฟ{๘7~๛๗๎๛’ xp yํ‘๋{š t@ฉ m€ซ7ช{ี๑ญv;Ÿฮ5%ฉฦ)v ิ“Kk„,+ีF;be๕—ีอาeœซฝoMฟอ„ฤ ๒แuS‚ถZMเzป๎+oคพB!ต_iดหu5d`อhš˜หžคydrค“ุ* &๋งฦ$IŽ ำ๔ลใŠ………ใ฿IRŽฑ‡ณฃ TSk{u…‚0๘fžบ )™็.)ฬฯฯ_˜„ฮ;Q> ‚Pีพ&ฤ นDส8™1(|ฝœู-Ž๓ษแ‰‡D+ฝx่ฦ„/ณะž<๏ไท๏nๆ=ฬ’ฆ+ไ๓ไIqฒฐŸ›ชช„n‹p๒,VU•<Žy|ฉpj๑{~.,,ค๗8x๐ปโง S๎wด(ำํฆ TุWฟ๚3  ฺ;\€ฒ ณ|E่nฐฒ๕๋?๘ฃ1Uใอ_ฑl6ซณื:ฯบฐึ?\๒ูอ“วจ›Eซ"โ5“Šดj=ํ•%ฝC|บ€ฏฝฃิ{5g–5๚๔๙˜, ๕ไฮ็=r]๗ต5R_ Bš˜ห๕จ รำ!ฑzv„ัOa$ฉ\.'“IE๙| ๖ิ8! ฦ••Aะ้ฅ'ๅึฟฯ]˜PU•?X_?9I๕ขวญฯิ่›5??฿ga8]>UPแจcก฿?น™Kฌๅmฒb“Qo}5'(ลญตNh*ไสo•ๅž1ปพB๛ฅ\พฆ{ธ™๗0Kšฎ–ฯใ3Bฟญ"B9n UPOฯQี“gฑvSชœ ผ็งแ>€๚~๚;6/~ดข@w$ห2€๑cคoน @=[ฟ๕ฟR˜ษฮ๙ฦข0๔่ฏตฟ<+ฝ๙?~sGz1(ฎฏ5c๊ฎS{'Ÿk o๋๗ห้*ฒส๘>?1๋โฒY:ˆฯฐ๓ต๗ \˜z๏fโ3ึถWVn^œ=]wืฺH}ัฎ:rำ์ฦ\ๆ„ฅ†ร1ซสSฯ=)็3'๑ยย`0&&&Bกะ๎๎๎qเฉ๑ƒํ^__ฟp๐p |ปลบฦ์f$Dๆโ<)บaฯ]NK^R†# ฺบ1MจO)ๆ*MQE N\•K”ŸL†ตํช3ๆ์Kน}M๗p3๏a–4@>)ƒ‘!x‰qธํJซpิฟ้ํr ฑmขTž๏จ|ปe๐ธญนL‹ดนljซx“2šY’๏P—Mnพ˜ษKูฝด?๙ร?Dว๓ถJซk9๘…ฟ๒หiํระ~๑ท๐?๎6„พ๛‰ฐ\.GwYั๛๊~/ษคV˜๘หล%'~๋ืตc๊ฎS{'Ÿk oโ‘[‚ (Š"T’๒ฺ i0Rค +๊Me้Lํ}k๚n&H‚`X–$x๕ฤ๕hM๚ป๎๊ฉฃ/€f7ๆ2g‡\Nง๋VwใำFฆฅจสฅฮAถถถ?~ฌ;~`Yถึ๏\ €TH&ญฑs!š…jfป…ฏ@7ฎSHg\“ŸZูxฆโ€๏_x6?อล•ฌะแšฤ่๘ฬ˜‰!:ญ๒nขp๒FŸาH'*Obใ๖ๅDM๎!ิ—vqฏ66๘ๅฅ๐๕ƒ๘vใ่ไาฎkb๚™Ÿ๋ป7๒‚TH๎Xc“ฯFน๘ึัYฺ>6๛b‚R๘Z6žh่$s?ษ้ฝ,ฐ!“ฒฃ?่ฮ(Rื๙฿๛วม๚็~๎o>ฌnฟ๑_ฦ๏>ฉPููศถGฬ{๒Goปmฆ๐g๔๙‘๏—๒g~๙—j้ล๓๘—ตc๊ฎS{'_งึฌTต" …tฮ}*id;žู้XYอ ƒฯา‘Sตทf>ญแนY๗i‚ง๓กรท?i๖Ÿชf3ก•:_ุo?~๚บ6ฉฒPฯฤ?ํk^[ีu€F>ฑ‘๚BiwNดบ1—:;”Vf3ฮ>qlๆฏRA8๓ha4~vลฅๆ‡ฮอฏ[K๗ฐ|ริบฯzv …_DฤUํ.ž†_=อC|ท“ซฅNบ&_zk๏6๒2i}๔€NพOเpฯŽปrื{ž เ์ ฎ+๗ฌ๕๙C„B!t9 W*ŽŒ?{1ฺํูฉ—ูnuฆะWฉฟWษ๔ว!„พDไปๅปฮBื&–หw „.g@฿C!„B}ฎ๘Bทห'๚:ํผm๔5มbƒบgjผ€B!„๊ŽB!„Bบ๓ำ”wๆeฤOZชช 6&t?กn >yภ์\๔2๋๘๓G~‚O/-ํ฿่๗'พqด54๓0ะŽฟ]€รื ำGฯให…๕ท‰บ๖’วยเ‹Ž [ „ช๎%๙ฃWŠ;โE l‘—}”ช‚* \1ต,฿‡ /กฟB๛ล0ธ#!ท…%UYhไ’[{5I'hh,โณฑ*_อ$Mภy>.gxา:6;eุ_‰—๎ใ[ฤI‹/ :LดฺiU3;‰\Sั 4บวฃ!ท•%คv5“ุ>h๊ฝ2๛ŽKฒฦแะคun=S3c6R,&ึ“Ui™A฿ฺŒ…v#%๑ตโ~jฏิ๎–๙kลปซ?OรCฅ๘ทสwาปฐE^Ž๓+:฿พธก_<๐าวณVzi%รืuŒ*4๒ษDบv๚๓ŠŒ๏ัห๛DMผ๋TEโ๋;[๛ฮž†kmD^›Kkนฃฆส|2Eฤ—๗nซwybสB#ŸJUoฎีผรหๅฦr~ใวy่ึํหใvผ Cแัฌi1zcั€lrgชดvzนฯZตฯ˜ฌ/5W7—7[`L=ˆxซซs\(งขR?ู›iฅ––3<ม8ยณ#ๅ๒Ž˜๕ค๊ฤDU‘$Y5{Cn!ฝด^๊€10๓4่:จๅ%อ@าžtถใ+[Mาy0l|Hxƒ ํŒL:k[๏ๅเ€๑Žณๅีลl›0ฆ…=ๅี\G3ะเ‹ณล\฿ธา—ฆ๎J๗4<๒๔.๊;๏~ผsถcf๐ล"ฦ๒๚‡ žดgฆฦ›‹๑๒‰Qaุc(ฅj‡ใญฃ]Gผ#๒๒_สฝึa€ฃฒห2Œุผห“‡๛“dแGม๊ไืุนฬ๛[ ƒ+w[iUhไvถ๗๊0>}2jx4๏8๚p#ใ› {ญ,\r+]๋Y7ัฎ่ใจSฮลWาu๒๚๕tš•ยnฆrฬธฬ7™iณq๙uฎฃpนtš 8๑=ลV๊Cนy๖ ซjญI{Yเฺ=ฦ๐นฅธฅ๚"nฃTููุ* šๅ๓2…๖ ม๘ฆŸY‰รฟไrง’,K…‘edY‘;’š6—ซ•{We€Rฆšr™Sอึแส ‰ˆ1ทพVฟใkRบ ]+š’ะ,ืŸัะั ”‡lึFaต%@#ต๒F•w\’{Ž ฉ @ฐฎ๑ษ%ฝ–ชใ๕BŒ _ฎ Š| พ’.ั”kว<ู|ažฒ&ข#v#)ตk๙ฝTฆยw ็ํ4๚Zก๐‹Hg+c;ูNuw3^เt๒ip…ฃcรVFjูDถ!มqเ ข PJ๖(ญ;๋ฦCถกF~ญ)ฉ๕\Q˜ตY นk๖0ล๓ำกฦ๑cF }—™ืิ๗‰‚ศฺX LSฏ#ทIšก|›์˜าฉV8าoขก.i๖~5{,Z์d๙”j้O๑\Kี๏ฑฮfd@ ‡c–๚๚กๅฎ‘ IDATาF‹ด‡NŽึ฿ํิ[{K {็nฌุFฃ๖F|iฃEบฃณั@e1ฅ๙‰๖CŒษj ฐIธท—/…,€uœ 7g_จช,ตู๋dw‚‡Žbา4ฃJ๒a•๊{ะHพ[HยP๘EDk‚ฑMํfฯOฏ_iณSk๏RŽฉgมacqŸื*Ÿ—(ด_ !—)L wOi>ท_’@ศ~ฺ›š{5„ฬฅึใeE'6ฐ Š๊Ppส+ฆwE‘ตฒ-าœ ชฉีL๛๎=\zy๓๐'m6ฑRณฃHำŒJšGฆB;ซถห้ํDAgณ๎ถ$๋-gฯMก”mLM=s นด423=TYฯp8x@P๊ๅZ$๔ B๎kmฉ;จฆ๕งมชซ๏K;ไ๖;ฌิั๘แzพy์ูX๗g{oiIoพŠ^?ฤไ๑›ซo†ะ์ฃ ฃธ]U5๓Iyย1+ทพธค\ฑู‰`cq—สŽZนMี่›z์9N์ฮบ14อ(Ÿk0Yb˜“=ณวC?๏‘๛Qเ็ฏ>X฿[ค‚ยฒคู`ต•„รwทEบฝ฿๓=ญ&ฏ—๚ด๖.a}tๆใe3๎v6s ใ“ู"VR\Gจ”jไจ™…บจณž\Z#dYจ6ฺ+{ฝํึฆh–๋ๅป/ธ_งๆสb–‚2yขS_๕ฃฮ”อc^ฆ<ำ/"v !๓q)ญ7๓ยz๚zRmg77๚พบzฅ^,ดeฎT(tสg…๖‹!—3น๖pะ ิ2ู๎>g†#asๅำว-0๛ฃฑ ท’โTญ@’$UU%X‹อFQ*ฏไแ\(๓่”นฝท\ผ๏;‡4ุ†ฝทi๎ไถrผN Kiณชkซ‹ิะ่๔tุS]ื™กqง%Y๗pœงyn–ถWJคษ›Š้อ๊}?x่~๓›หข?ฯŽ‘ญโ๎nŽำi|/ื”k šehเ[ีƒD๕s๐๕>๏๋eพ]ุ+ดe€VSวŒ €จ™O“ู"VSœ —‹ต‰ \วdถt*)NRฺ-ฤ`๎บ1Dณ+…“5ีq &ตjูแศ๋ž๕ม๚"Qฦdฑt ฦb1Œุ<ฌoy‹Hฦแด*ํผิใ”ั์ฑœ+`ะฮงsM @ชqŠภ่Oษบอศ๘ ๕่ฉ%UUIB๗(SVDฤk&h่>w}DjU ƒ๊Uข๓I'q ฅfภlึ+‘ว<~Œs๓๛ุยs‘^ŸKoฅปsYW๔ัƒเฦลฯWฬฯฯ๗๘ืำ๏Aึ?€N๙์ทะ๖N๑XXXhe3•@ฬ)๖ >1ๅvถ๓๑z[ฒฅเ-ลqZME!B.}z[ }„ขอ‹Moัˆฟธvภซp/wศยย{xvา!r๑Tตู้ถ”V  j-ะ”Tjฅ๖Sซข3[ด๐>ูqต’zzฝฝค่จZ็&apŽOŽานtz4 ;Ÿา5|]Dช™D5ณktŽฤb3ใย๛DU๓ฦี%›๒ณ„\"eฬŽพ^ฮ์๎nFฃฏ›y๕๓‚ ๔๒I„ม7๓ิญIษ1๕n#ฒ‡L:5%้t'ZUU-"‡ฏS’{๏ฅ‹ว`๚‡ฃŸs“vEงผํตคไฌล—ธภœฯฑW+฿ h่~ PU๙Jzฟ์šhจŠp™ฆlL่vฦWHnๆkนA›์ุdิ[_อuOฏ[h๔/๎‡กt[ญ|ชชสฌ/๏Ÿบักjnๆ-m‘&I’H๊จฃ)Z๊ี}„ใ ห็ฎช๕ฬ~๋้จoฟ–=ฺถ{ี๋‹TQPญNฟ฿ๆ rะm์”>ืŸทณE‡W”>ปD๏Wณ€้ว>ฦม-mๆ@พภท[‡J“$๋pูิึq;zศ1ฤ2ฌษศAPEจ$3ไตฦ`คศร(“rzbโad˜D.ัY•ฒyq๑Bศo'yฯไ˜žž‰4Mซข(๕จ4jM›ืoกIา`๗ป๕ฦ=-ษบ‡ฃŸsSช&ื63œ ชช(ชrแๅ*„ภเŸy<แณi’คL๎aปิhV‹7ๅ็๊OAŒvง…aฬรcA็a b๒Gร^›‰!Uฉ{Ž moฃัือ6่EŒV;ญjj''่สฅไ–9y2วช|5฿?ฏ๎”๖'ฑH}eซ|_่H้™™ฬb้ำBœำ , นํค):๕,DซWุJuw[’uG็ฆ๖ส—s๔ƒN1‘ย›่B>™1Œ‡Žiตำ,๏o๎=__Sž4bŠ๙Tฦ9๙๐นฟKdห่pMbt|fฬฤVy7Q8ชTฎื่Ÿx~๚๐|ท†5zš™็h๛ุ์‹ Jแkูxขก›OฉLZcๆB4! ีฬvK€N!qM>|heใ™Šo๔8OทาฑE^>๔u{sฯๆว7S8ุ5FงŸัชะ(l%็ย“ฃYุัฎฦีฦ~ู๋จoฟšๅo+๓šฎนEAPDฉ)Hอฆzโ๖ํm‘ฮ)ฃ• อฆKณวr;›Iฦใ?ๆ็็๏ใไ„ห'๚Zh–d,่ ฐุ ศ`ฟjuQรำฯ]ล๗ŸJ_อeูฏo‹๎ญ3ตอ@ๆ/!„Bก๛Œv{†ช…สWิี๚ถ่‹1˜๏ว!„B}™ษwหw‡[ ๅื฿ๆ๏:๕๕mั๏? „B!„๚…ใ„บUšึq;Bก/ŽB!„Bย๑B!„Bจ_—}~ฺy>v฿qv๒๗ุ"/ว๙•๎ำั3ธ#!ท…%UYhไ’[{5ฝ฿ำC#ัฐ฿nขdกQHnงkGฏUฆญก™‡v๛ํJ„ƒs,:6l5rซบ—Hไ^^l๔?z<*๎|ˆพr฿y๙ะGฉOผSษ๒๕‹‚-๒โ—‚ @UUhฅ—V2<F๗x4ไถ2ชะศ'้šFฯิฬ˜‹‰๕d๕ย๏‚!„ะW…ถcaฟHI|ญธŸฺ+ตฐŽ?ไg ๘๔าา~{p‰ญomE|6Vๅซ™Dโ )๋๖ฝ8i๑ลขA‡‰V;ญjf'‘k๖zฯฯ™&’ ฬฮŸะp้ำBผ|‰ าNz[คๅD_ŽดŽอN๖WโฏฑPซm >y27{๕%ฎu4o}‹n}|ฟ0พ้a๖†Bziฝิc`ๆiะuPหkืไCฃ“5ฝถXณr2์ZŽ—eฃ7 ุษ&wแฉล๚bQsusyณๆภิƒˆทบzะุœPN%Dฅ~2ีVji9รŒ#<;1R.๏ิตืูฟ๚ฮป๏œ=ำ พXฤX^ฐม“ึเฬิxs1r๙Mฅ๕๗\`ฮุ๋ญU i$ _‡๚ Nz;;฿V%ึ๊ …ว‡๋๙ทป๘ใ] ฟˆ85สเHWxาูŽฏl5IGไมdฐ๑!ีิ์qฦ;>ฮ–Wณmย˜z๖”Wsฺ^ำj";๙อ๗ฅร/S๖ศ#ณฅนฌอิฏนEฝัฮศคณถ๕๑๘Sฮ7าj3๑%๊~ƒV?๓๗v‹พQƒ?PึภDtฤn$ฅv-ฟ—สTx ฎptlุส(B-ป“ศ6$8bAJษ็ร}uสน๘JบŽ฿IฝฒิQYV@–นฃUfฬfถqPhKภสbภfrฝำฌv3ๅ–cฦe๎™iณq๙uฎฃpนtš 8๑ีV๊CนyถU;ีZ“๖ฒ$ภMtเษ!P#ฟึ”T€zฎ(ฬฺ,ะ•  ‚uOŽ(้ตTกฏi02|น&( ๐๕ƒ๘Jzดป=š๒SCแ‘ฮVฦ4vฒ๊๎fผภ๋T'cJต๔งxฎฅะ๖ัษฐืฬะ4) "ัฺ๐ฉ q,›หีสฝซ‹2@)S MนฬฉfK3@ฃหกำภะตBก))อr]๐อลตšHU๎ˆ‡๙7ฌีtr5SืขvHฯ๔ผcn}ญ.\ซMฺGGMลไyขW_โrG๓nท่(๏ฬซจใ่/ฅฐ๑vUฏG @ฐฎ่Tt˜ํTำ๑๎)sท๒ƒมชk๏฿}ุHืYป• <แ˜•Z|๓๖ใž˜ZฃVn๋ร›7‹›น๖‰ญgLVอ˜ญF| ใfูORp๎ีห—ฏg]ี๕DY๏ ‘Qฑ84‡ฤ04ศอrกฺ๎ฃ*งiF•ไร#+ี๖*4’๏VดฏŒnj7{ค๊hšQ>gI–†ก”mุงžฑน’423ํwืq๐€๚F(๕rอz๑;L4 ๖่Š่5ๅ็ภไ๑๛ซo฿ญ•Mแ ƒส฿ไ๕Rูตw๏ึKฦ๑ “ƒoฬ฿I/ฝ{๛fyฟอg>^f๐@XEu(8๓˜DQdYV'ฮw9ดcr้ๅอ|๗B9m6ฑ’ิัYผwI:~"—น์7ฮดRื฿ขพvˆ>าœ ชฉxๆจcvCญถidฬอฅ๖ฝ;ฟ—<šwบEื!็7~*ŠBฑิะ้Q€ั0Uโหหu๓แ)sว4‰ h–กoUีnษlซ)Nหลฺฤˆ…ฎc2[:•'ฉํโ8ตs[›ขYฎ—/Sa 1ร‘ฐน๒้ใ–@˜ัX[Iqš'ฐZiLOพxญJbฃP€าŠฅ๏่nญg๚Eฤ!d>.ฅ๕๎1šCO_Aชํ์ๆฦๅnํ^>Kงฅํ•i๒ฦ&‚bzsฃฺ๛^*BH„B—]$šN฿๙โš ๖๘งAeฉGฬคŽ."ๆ7—E0ž#[ลงำ๘๊5ๅ็ ]ุ+ดe€VSวŒ €nอฺฮงsM @ชqŠภ/ศฆ๎?ดีj‚efข“$ฉช*มZl6ŠRy…$Iภn๒gบบ1Iƒmุ๋qปๆNn+ว๋,ๅ๔บ๙ยาUZธsฉณบ[ิืัe2ท๗–‹ท„ืjตฯธ__)Iเ๏๏’G๓ทh W$2TZฎ'5…ิ~ฅ ะ.ืีธ๋'5ฮŽๆ็็{ฤ^XX;ะํ นDส8™1(|ฝœู-ถU ยเ›y๊V€คdž#€ U๛J‡ิช>ธู@—ต๐f{ุูฮว๋m@ศ–‚O<ถWำŽฬถ– ŠTe…๒=ฑ้ฌS๓-ผOvศ…อ๏ ` ฯEz]ูjฅ—–3<ฌ+๚่Apc)๔๔&Žปfƒs|r”ฮฅ๓ถะฃนฐPุ๙”ึ}คก‹]ชzพ|'‹๗^๊†ฒิgฬkฆŽ. ีLขšู5:Gbฑ™qแ}ขชy้Uฏ)?pขถU z^"=ณ๛ChดฌังฯวdYจ'wtฺ'อQ‚ ไางท%ฺG(Šชุuบหก“ฒ‡g'Bแ OU›๛็ฬโฝ6งฝ]I]พณง•z-:ฃ˜ญ๔fม๘‹k|๏[g[ํKก}ั๚์ล๖฿ฑพๆโัtบwgไ@BsPqY๊s€ฉฃข;kIๆ+้ฒ?hขA๛6ฌvSฎxz๕„าฺ๋ัyฌ7lฏฌผผโIe)X–EA'ฐ๋t—C;&้ ๘ฤิป wœYผ‹&ื.อิ{mั้ฆผGL-j;ป•ถฯNŽ6Vำ=_2u่ธี†v฿3~L;k0ฬ~86o[Zฺk๗™๙{ธEภ GรๆR|ซนเk๕จo1G}ป์%žใจะฐ-ๆ(—&r LจO)ๆ*MQE บ5พbc๖€ณ?"s๑ ง~ฉูฃพ.;~P*ฉm๛D๔ูKFๅู๋ํl  ร5‰ั๑™1CtZๅDกR!™ดฦฬ…hBช™ํ–B:ใš|๘<ะสฦ3฿่๑z;|SX๙ิ3h€๛๙ุ๘ฃ1Zํดชฉัภฝำๆx‰‘›วw๘„ƒค%:๑ฬO)B#ฟ•่N๐tD_อxป7žฆ็= ็7œ˜—w‚Jขฑว#ขร…œx๏ภณ๙1h๎.vฟ๛a{6?ช,ถ…ํฦ๕7ำy๙ะG'ิJ}Xฮ๐ยม๖ฎ1:lŒV…Fแp‹ไnmย—s๔ƒN1‘บฏ')B ”Of ใแ‡cFZํ4ห๛›{Xรsณ๎3ฉO็C‡๕งfSฎด}l๖ลฅ๐ตl<ัะฏฯแ ๛ํวO_w{ช,ิ3๑O๛zehKษ-s,๒dŽU๙j&พ฿ิ ะ่rhฦ$€๔ฬฬ{Žำ8€ร๙‹^IX-ๆv๋J๏สัL]‹ฮ6ๅบ1๕uJ‰m๛“XคพฒU6Vซๆฟค-๊ๅp;i#"ŒFใ๑๓๓๓8q[wU> ฎฑQงTHfx{(ไ” ษL]ฦ@ ‰Pจ;จŸ๋ๅ็cฤโ7xทY๊?๕oว}jตฏ๕‰+า5๙า[{wx9Ÿ4>z@'฿'oต7‡๊แLmƒฏKE่”ล้๑8LะfW๗bเษ@„ะ5)\ฉHŸฝ˜›››››{6ใ2…+L๚A4Bhgึ๓ช$’]_,จw` "„ษwหW_Z,'>–—„ะอย๑BPeQ่ฮย=x"!„๚ฆเ%„บฎw<฿+ฤผๆโฉgธfฬ›ุขkjา"„B7 ว!„Bก~แ๘!„B!ิฏ<0~๑ศO}๐E.ฌฟMิูภ์ธ๕Dคาง…xห353f#ลbb=Yลัภู"/รยว๎ Oพฺชฦ๙W•๋ ฌ‰่ˆอH*WHmง*"ะC#ัฐ฿nขdกQHnงk0โ‰puwd"ไถฐค* \rkฏ&้๖ฟธ&ยเ‹Ž [ „ช๎%๙ฃwŠ;โE$ฺฎฆลถข‚าจrjศศจf38(ด%เ e1`ณ@ณถธ}>ำฉ4:๘&ตวฒิQYV@–น#)zš๚ŽIฺ์C\~๋จ\.&(N|Lท•๚Pnืฯ‚"„B7jPใSp๖ีˆชสRปžM&rอฯ2้๘‰ZEJูฦิิ3—KK#3ำCต๕ ‡ƒtร พpP=X}_’ุ!ท฿aฅ*ผ”'ณr๋‹๋Mส›6w9 <แจ•๘ฐัTพฉวžใU0&ซfภj$กฎาNพœ>‚ถฺ,2W่€ *‡ƒ.W%ยเฐ›…ฦแ:„์งํฑฉนW@ศ\j=^V๔๛_\ M3ช$ฅ๚ม4’๏’0~๐f!„B_ŽŒš{+‹Yสไ‰NE|ีวณฦ)งือ–Z ”ถWJคษ›Š้อช8ˆิบAะ,C฿ช$ช “ู"VSœ —‹ต‰ \วdถt*)NRฺ-Dฯฒฺอrฝ|แ)๏ฬซจCiถ7v*T๗vำ“/^ซ’ุ(ิ O„๋`†#asๅำว-0๛ฃฑ ท’โTอภืŒy4๛า3"b‚2—า7A฿๑x.Ž๔-้‡|กpฃ9A!tl ใE…รนภยAฉ0›ว„อioWRGฃ ยเŸฅs้ผ-๔h.,v>ฅu_D่šบC!—Hว#ณ#…ฏ—3ปปลถ A|3O ”ฬsกชšฝIฉU)ด๚IRฮo,ไ ฺไ‰NMภฺงR๘ยึR!A‘ชฌPพ‡#6<ฎŽr ;๙xฝญูR๐‰ว–โ8ญภZ฿‹kฦ„ใ๗Al~_[x.ข]2 {ภg๔ฟCp…Bทiใรp,ยldบ—ๆิฃ๋v`ฑไฺมแphWtสYKJวมZ|‰ ฬ๙{ตโ7ห่[!IEQ฿EJ’ 7s‰ต\‚ M๖@l2๊ญฏๆDUU๙ƒ๕ๅSogRA=|*Žธ2“ำi‘ๅบ ?ฯˆ2ป]tฃPA•ฺ•z'โฐBฉยX‡dญP๏ร0RGยแ’๕จoฏ‚J’„N`evน-rฝT๋N๊๓ I’š"บใ’eกuใท‰ฐ|y@ก{kใ‡ŽJู<{ฑ]—(‹ืmๆŠว7๙ู!+รe”ชษตŠ,ซ`BUEU@ฏ๑F่*xŽฃBรถl›ฃ\n›ศe$0๙ฃ>ฅ˜ซ4EI%่๖๙v‹u;ŒูฬHˆฬล3œ"๐ผัๅดไ%eศ?โ เ๘b&ไtศ ีฤ›ผ&๓p$`nฏ๏qitฺอ<วi๓G‡อย๚^“ด†™Zช ’ฺ๗‰ ชŠขœฒศชชย7ZคVซtน ี’H˜‡ๆVฅญ&ฤTศ U๘~ฃ ่-ฎIiTนฐoฤฺศถTKภgซvnใv…ป๐ฮBgƒ?(ๅฝค#}๒’!e‘+'ถ๓Gื้ซลnตŽ;Šํ{๑ๅ?เ…ทSLค๐š+ฅ’ฺถODŸฝdTพžฮถ:\“Ÿ31DงUM: ’Ik์ม\ˆ&dกšูn)ะ)ค3ฎษ‡ฯญl6่EŒV;ญjj''่tฺ/1r“W{-ฎIศm% ัุใัแ ‰ํBNผ เู4w/๗…„B่+ะk`p:ฅB2รC!ง\Hft^=ฃถ๒ซyญ(o}_ึ o็6?ไz'„ุณิ้+ษตJ๒Tฤๅv6rg#ช|1ฑZLœ”{k๏๗x[๙ผŠา๖b้ยดีV.พ|.!ฅ™‹ฏœ ํ.p๚D@่ิ๖6–๗๚ ฉœ๘P๎+ๆyชP]/๏ž ๋พ !„๚ฆ‘=ฒ8=‡‰ฺ์๊ธ!š a hฉC!„BWะ๋C;ณพ˜W% ”์๚bA•nl๖ฏfBˆ7Z๊B!„ะ๔?จฒ(tงŽธš a hฉC!„BWะkBก~ผkท{…˜/~ณิโซ๕๘ฟWH!„ะย๑B!„Bจ_ฝฦฌs4 ‘ภ:ƒˆwˆB!„๎‰^ฝ3ฺ๊๖๙œfhหp๗bเ๖อž›Ÿ๎ณI๗ญพฟ‰4บ#Ÿฝ|๚ีใIฟๅsikh๖๕๋˜๓๐Oฃgู๊‹—sรŽA|€uูษ”50ไลซืฏ^<}0ๆdุภ์)“.๕็๘ƒง/^ฝ~97;แ=QGฏ^NใฑC฿๋๘ซ˜ƒ Sฏ็g†ปฮ“ฺ6:๔ลซnํK].&ึษ_:S๐ษw๓'๋๓4hƒ;๒ู่หืฏ_ฟz๑tfิฎ{๘{œg[[ไeท๒๚ๅณ‡aื}=_ฎญืฉยg7–Š ส l,•@”1๏&๐2ฺ{+K{ญห.5_lœ-n|ุเ ห่ฬLศ](HFo,ฐ“M๎๓gฦŒ.ฟฉดž ฬyปีข $Mƒ$i}›ŽuŽฬษฑบW฿ทธ_้@Ÿ4v2€ั%r฿ๅyส:๖`&Tป]ํไ7฿—ว””=๒ศ฿ิ-*ฌ/5W7—7[`L=ˆxซซ/c ๅTBT๊๘j0๔ l+T„อn#ฟ๋่ ]แIg;พฒี$‘“มฦ‡Tณ๏˜ru2บ๏x€ลžq4hณ7ไาK๋ฅ3OƒฎƒZ^ทjื94Z„Vji9รŒ#<;1R.๏ิฏฝ…๗Pฏ๑ƒ"wDิฃˆwxMŒแsKqK๕EFฉฒณฑUภเ Gว†ญŒ"ิฒ;‰lCฝ@ฺ}uสน๘Jบฎ›#rศfmV[4R+oบกfฅฐ›)ท3.๓aDT‚ € ึ5>9ขคืRuฦŠถธ}>ำษv็ ฿Dเ%ฦ;ฺีtฃุVTPUN Q๎ Iอฃk5ื๋ ‘6๛—_็:*—Kง Š€฿Ÿnฅ>”›}็ก/วu์4h๛ฯ=ง~พชtฦ^{๘คโ 2๙ํ‚yltจถต’ๆTยเ วฦVZนํฝz4๋dส3๓า[]์Žาอกง3Tโ}ฒะg๕ 6—ซ•{We€Rฆšr™S:W4bๆ๛ฏ“ัCฺGGMลไyย#’f-K…‘edY‘;ฝฦŒ'B๏AํTkMฺห’_cI๊5;ฤ<๚๘ีซ/ ๆเแ ฤภ; ผ>าfงฒk๏mวศฐ(O8fๅถ฿ผธง&‚Vะ `LVอ˜ญฦžhF%อ#SO_ผz57๓tฟ}'7ห…j๛ิmก”mุงžฑน’423ํwืฑกบ ภ—ำuฺjณศฉสtD.Sัํ4อจ’|ุ[‘๊{บ฿Ÿ^XX=ภ‘๚vHีชbwฐ&ปฏvเuชJซAH์V-cboป.‡ €ว,๕๘าwSขgrิvดึณuฒ\ฉิญ;`ฐ้jนqณฟ๊ืภ‚(ชCมฉ˜ว$Š"หฒ—ˆ‰u๒—ฬ42ๆๆR{Wตh!๛i[ ฮฝz๙๒๕ฌซบž(๗8๊'B๏`์vSปู๚JKRฏ™ฎWซฒ ‚ฬภ@ ผ“ภห0ฟQิRอvฅชิ‹…ถ ภี› E€ษlซ)Nหลฺฤˆ…ฎฃะฮmmŠfน^๎9ŠาfUืVทฉกั้้ฐงบžืฌV„า๖J‰4ycA1ฝนQํ}ื]ๅyu(ญย๖ฦฮษึ…rz|aฉื<ทฃYNž้;„๙ธ”ึ™qB?ฏํฟ๛็ฏqฅVrๅu๖๓š[tๅ8WKกVฅ‚7%WำŠฯ ]@ฃZSd‡ชU;๒ฐL0D7f%ลu€JฉFŽšYจ‹uฒTฉpc;Q(Sv‡ฑš=>๔W’$ฉช*มZl6ŠRy…$๕Fš1ฑNb1žqฟบฟR’ภ฿;ขfอ Gยๆสง[a๖GcAn%ล้๖:ฮŸzฬกงฏG ีvvsใnๆS฿ผ^ใกธณQ€ใˆwxํ^ฯ?๋€ ƒoๆฉ[’’yŽะ ฉU)\X จ ึ๒MIฉvPj?ตZ _ีŒIœใ“ฃt.ท…อ……ยฮงt ็ำžœ฿Xศดษš€ตOฅรแasฺ•”ะkัร6D.l~_[x.ข^<–ฝBฟไ"ื6\aฦผๆ]-ยuRG7กYญ™f•้€^UๅYAจGงŽชช$q6ๆq bฅย:† ส8,ีย‰ฉJTฟŠข!—>ฝ-ะ>Bั๛ช๋ไ/i …L…O›sATญบแvถ๓๑z[ฒฅเ-ลีtWq๎DะำJ/-gx YW๔ัƒเฦาื๘}š^ใฃ'–>ํถ\ั่ฐ|๐iท"c Aเ PU•?X_็/ สไtZไFน.่฿‰”คำญชืแค]ั)o{g-)๙k๑%.0็s์ีŠƒxึกฬn(ิEPฅvฅ‰8ฌP:ผeฑไฺAฯA%I"hŠ่Ž#H–e„ึ—$ฏvฅ\sฉม่ฑฮ1ธE}๋ีbขFW.6  ๎nˆVUiั\VUU83œKh*•ฮŒรjcฌ๕๒ึ‰šถฏ๊We)X–ลให”ูๅถศ๕RW๔b^ชNพ‡Mไ7จมไฐณร์wรฟm๓ึฝฅฅฝถฦqืj  ’๕่b‘ *I๖zeใ๙แŠXญตง\ฺ_แฆ^ใาhต;eรP๗bเพbc๖€ณ?"s๑ งh˜“ำ!3To6๒บรฅQk†ฝ~K=ืฆ†nc=ฃ3Eช&ื*?{๗ตะถฒ6 ๘5๗ม€ - Y้๋หมพ–}฿%ืฑฏe๐e…ะมlpมMถeKฒสB‘) $™็$ฮ0jฃWฃตั4 @๋:ึaุfbฌ๋๚•ŠGรร‘d๕ว#Vq๗XP)ณวe•„‹ถ็ฐณBi๔ณHz‡bก {งิรถHศูฎfG]Œผw‹G\b” ?b‹ศ‡_nvฺp‘ฃชาxJI์™>{ฅุฃœ^'๎ีFuรลf'ขaฆ[ห]ชฦช~กl&"ฮfฑKป"~ิุ๏]L>;?eพคช๚œช4vิgร?9ั@7ฟบœdร/฿ูJ_ฮZพพ฿ OะjฏงLz}&พGVฟวฺkŽพQp@ Q&หชศ#๚ฝฟ2d6›/๓๙๓็ๅๅๅหE่ฌvƒ$’ฤ'I4Œฯ›์ฑ๗I5u๙ฅkีส2๛ใษ)ฏ•Ašฬำ้rW’Œ/๙:๎ัN๗7๓#>”ลKLym –…j>“oสเN|Z ~นvš๚'s๖Tฒ„ๆขZฉgvณใmˆธมจ[ึะ์์คฬ ][ๅlฆ$ ศ;๛)*mn>S “w:1ๅท›"T๓้|Cฦ฿ฟถ1ะ=Z,| Š ~จ1jล‡ฑฯผŠkฉำAMhพIhฉญ’lPUz’๛›_ไ™w1ykปแ๕’อญๅปg9m,ศJ๎ฐะบ๘า๕:ภ1๓Uธ—YI]๚ˆๆ˜ี/ฐฎฉd,่เฐฤ3™r๗ฌฏมxK Vู฿*œฟ5$'Œ['?รSไ’8สต บน฿ Oะฌ+šœ :ฬ Vz|1›ฉt๛ฦgtFpฦ?พ 1€ตพุฉๆำ๗8ป_ซmF๕L้จGญๆŠ’kjสฃUsลถFIโ$ฦ'Aฤ๎7ชB@™ผ๑y_s{ฟC[}ฯ๐๙‡$O๋Zm3๊{hดอธ-ซw๐ƒ$’ฤ'I$‚ ~gดoำง๗/ยJ!๗œ;๐ิgร?9‘xVF@4ว1X•‡FIโS$ฦ'AฤŽิŠ?฿3ำืฃรGซwŽุ‡ฤ}ๆ๖ะษฆPr†ซฅึRฒEง|ตTีx8]รœใOฮ…’ +ฟทฑืkdE<ศo—Ž^฿๏ะหฏo%ฤบcKณFvXKŽ ฎbƒ3บ?j$[Gt.‚ ;ซuYรss1๏ฦACฑฐ1ฮ…ษฤ๏มJฦฬิFช‡อู—sีย่มื ‚ nsๅv›๙ฑ9๎ถCKฺฟ๐!ิZœ\ญำoัแท#X๗๔\,h็.:y1zk/ฟึ่Ž‘ฯhrฤy๓ ?ง4๓๛งร[&o,1ํทณบ*e3ฅฮูษž๑&^'/hZฃึšฐฑ (bๅpฏoีฺ?จ๓€€rฺ๑ฮ๖jšvDb~๗ิ๘Qฮ;Mt`แCษลญ๕ก7หญSoŽขฐXฺK๕a3b8–ฉว—3<ˆขdโ8 kg-œm›8ฑ#ˆCLฌWE  ื๐๔๐#ž ˜ ใ“อบ แ‘๙0œํ,ฬ}๘ซNต- ะ=\-!@ด%˜‡๘ญ’๑ฅุงŽd‚xWF๎ลค๓@ฤcธa๒ๅๅe›m๖?„Pอ”**€าlŠQ—xฮekีZ€ถ‡gใA+ฅ๋ภ˜เฮ/J ›Ÿฟ๙ˆ1Fh่ๆ!Sh๑OŠึ$แ"งฺkVฟŸ฿ฑ/หn–ป*ตUฎ‹o์68ๅ ๓bƒœ=ƒฤฤขAั-ห ~hีฝ/Upฦว๑ˆ ๘ฝย๚FQŠ๓&^ฝ˜LญOฝ1š็ฅ๑JnฯJ&ož‰/M˜tฉ(ีDEฦmต˜๚๕:mต™X]๑ˆ๘ฤ฿ „”๙U,ู™šฒT๗๗d๖ถฬR๕pฝšก)ฌ้t่ๅ„@W๛๒ูณŒrนXญ๐๙OŠdC๏o&๋_บkNรฟ3z*รฅvฟฅ?น…Jฤใปธm$K“ญๅืพep%?„tฅฆ๔อK—ฝษ9:อดภfยZamญฉa6๒Ž๋u๛ไ!}๘ c,•w7Nn>พN[<›ึiดen฿฿ๅฟ๚ถ3^tดี๋ณiํzKาTี งQขqัQ~14œณ(Žcๅํ๐๕>฿็ฝ6๊ึqkญ[ษ์T2ˆฑธ"ษนDฐฝ]้‹ขrY้^ฝลEvJค;ุŸ!ฟ ด‹3™–'r๖็g๛๑๚๚ฑ7"Xป฿MตชmX–UภไOฦนrช8ธ€มฐ ๚‘‘|นSzน)?บa}kฮ1ๅ—๚ใ/V๗X:๑3จชJ]D2x’Ÿ&บ๋็Ÿ ‚ธง;Žภบlงsvป_่tn็เยพl๊๎ษณืไ!„hšF˜bA—IgMfšzทเฆก“ำ&3‹qnŸK๏u‡ึ’ุใœn3@Yรษ… ๛๙†Zยs ณณ/ใ~๚n[‹ำ;ญฎ3ถ1er…}ๆv็A Kxv>‘|๓Q#rŸๆ‚xมšฐsล:"!gปั4Nำ%ˆ2y\VE–~cNฤ‚N Kaต฿Wapส”E‰sปด^ทฤž>*ภฬVŽฤบฝNญ;<ภˆ'าอฏ.ŸYษต๕๊๒ ๓p3’r†ฑˆ“ฅh“'โg[ํ.€‚ig เโ(Dฑ๖ ฯ*ฯ4’ โ‘่B[p„"v–ขk(ไQ;ฉื‚xจปฝ@ป=6กv~ยี:yสํ|ลตืl2ั‰~.{l@ตP๑&}Š)R&• ,,-ยๆถ9๛z ภฯำะ=Z,ษ๖ุ๛ฅ๐เ๙๓7Ÿง —_(J†“Wkวญ้™ื็i]j—ารษีj.gOพx?ล Mๆ‹้‹7ฉ+ซœึ“ฐ3ผ\I็,‰๙ทS –…๊aฆvRDARYญ+แQ9‡Nnฐ รŒ)‘|=aBŠPอคซWพปuyฟ€u๚ํ็iภZ_์TำG‡oฆ"tQtfqฺย"ฅื8สT/ฝˆ`ฑ‹]MV$ฺฤ‰ Oฦ5ฝ๔a–ึฅV้ ๓kD,7#นœอูณoรด.wN3 ว9w<๑ืG–า๚B#“>ฺ”zฺH&ˆว"•ำ9s|๖M”UlœOฝFA๚ูlพ๘ฯ็ฯŸษำฤณ๕ใใำp€B‚xd†‘<D†9ฺไใฯ๓9‰qณ6A?วตฺๆŽฯ/AA๑ปฯ๘ำ๑›๊ไV6žz‚ ‚ ž5r ‚ ‚ ˆq‘Aฤำหd2ษi˜๘Ÿ็fขแ๋ใ/}Uz`N‚ โู"‚ ‚ ‚ ฦE๚AAAŒ๋Q฿ŸถL๕ื”นถ๗%ฺ™ML8อ”. ี|:฿์ƒ90ฟ8ํค๚ตฬnŽฟu0&‚ธ+gcL|€๕๒๏๛อjFฺ|Žฎ&_|vสgใ(ฌษJ๎๐ธฅ’แ([(™˜t[ฌ๔๘b6S้หล  `‰Xุeก5นSอฅ -eุ‚ษ3˜๖MH๋๑ว™ฬ้๙(2ๆ๐ซืั~vํเlgให1`Mj๙tฎq !ˆร>๓~)ุJ}M๓(฿ว9ฎฐบuŸz๘ฐกWูŽฟeZx๘็ศฏื`0Oหไ_/ุ์ท๛ๆ๒ˆ68ก๛ฃ1™ร๑(ชlญœJด}๚ลโT๛kZ๒†-๕oBไ}ะ}ฤื0P ช๚‡ไFๆฎึเ”O.ฌ๏ึ0G฿Lzหญ๖๘็‰Nบูห)}ธ ก?!๑คiิดgƒ33\c{ต$"KdU,ะุฎw ช ;ขs\ุYญหศž›‹y7šแไ\(™ฐ๒{{=ฐFๆ_ฤƒvyฐWๅF>ำื—Oฝฝ๚FQBฌ;ถ4;ัhd†ณ$ˆงA;vเ;ศ้rR@†ท๙™S=฿ย#3ิ`ž'๑็yดๅŠF-ต\ู:k=K๙Bง&๊๔/เ)3 "`„ €8๏ฬ„^ุษทI‚๘กืก]fJ[งว๙bSาภไ%ฆvV—[ฅlฆิQแ"ัมA_ึiฝt>ฦ›x๐h•ƒอB{t-zใ@ะTEg5MMำ5Eี 06_(dนœ"*ๅ&‰ฦหดชีฎชtm9d6 น…pณ lตrrUT@จ6๚ง †}ส้rงป‚‚„Jก€h—ฦŸ๎ๅื๋หล ฿๊2AŽ •๑|‚โr[ รธ’ >๕ฺ?Žู`k™๏5โผ‰๙„ŸSš๙ƒSqH ๆˆ}ˆ+‡EหLฬรฉญยAฅ‡วŸง5๚ๆฏจเี็๐`ฮE ษKฮ๘์ –;•l๚ธญ\]ยํTIg๖๖X๏?X&ฆ}Bธ๓=่คFกึ1vงMบ ศ๕Rว5všซิี‰ล…`h—tˆฮŠMโ๒ฮท•ตTกอน์4ˆ%ํยแ๊?_ทŽ๕ศ์ค,1aื๙guฏ"^ชAY‹ฤฐVป๙ถๆๆ —๖ำ๊ไ๛O?ฝไๅw3 !6๖N๗ซ…SีกฯTA ส}ๆv3€Ln—…e‡]Baซฺู~Tๅใฆ ส๒๒๒vูxกˆuน,bทG๖%๑ฌจ<ฏปœลๅ”Zท\!~eึ@€ชี„‹›as}cฐm›™t#^ƒY‚Aบดณฒฒ[7ฯLzะ]ๆู;^_^^/๔๚ๅํๅๅๅๅๅมำMด?–ดตึฟฎlๅ๛นจ๓|A:ูบฒำฐฤซDช็˜ ใ“อบ แ+้tp๑Sยญ๗ช้TถƒไzzณNY‚ษูษ~a/ล๗‡ฬ B ว2 ๕๘r†$Yฌถ>Ÿ4ญQkอNุX‹ีฆ4๓‚Šฤžtฉ(V๗๚Vญ=ไQ—sF๋วฌอญCYร‰ไคฐ™ศ๐ ”ษ้|>UฉVF^ภบ^œํ,ฬ}๘ซNต-=tาณ3X๘wBrqkฝะ’ู:๕ๆ๏( ‹ฅฝT๏žE?ˆโ้ษ€ึ๘‚r=๕ฺ?ˆ๏ืซ—๋นZ(ถ$ฉั†)3 0๔T#ž*]@m บหฤœฟ s฿yZฌถ~3/(:@ณขขVฺ}ซวUQ่ต<=r•ˆ็๎1๚”sjสR฿“ุซัNSหงˆฑ๓ณฐณ_Wษ33e*…S็ิซ๗1นš/ดศ๛ฃฤ2ธา&W2y๓L|iยคKํF๑่จ&b@™B‹o|:Pด& B^žS{อ๊mอBรv๛=โ้A[ฤrฉ>๙Wภ™Zไ@ธ7ฺ[šsหีrๅ ฯw•[.๕฿จ‚@ชฎW34…5ฝœp๔,ด๊—*8c๏ใฦ‘1ะ+ฌo% 8oโี‹ษิ๚ษฝ1ฎแงM@Oปtbด.฿ฒ,F”“M… =๕บ?ˆร๏Wซ—ซž‹ำฦก‘๛๑๗—๓{ž—Oฆc๊"็ๅ^%โ™{ŒƒลํโLฆฅ‰œ฿๙ู~ผพีฐz™NตฌŠอถwก…๓A1ป“Sรฏ'[๋Bไ}ศ}ช‘๛ฉฤ#QU•ฆฯ.)ำ4ฅช*€ึญdv*ฤX\‘ไ\"ุฎ๔1ฦRywใไสีk ฮkดซ5m๑xlZงั–‡7X „m…|^ebภ…€๑’แพ(O$ิฯฏคNo๖ถhซืgำฺ๕ึเฮm๕จ‚๊Mึ๎wSญj[–eUeXฏMUUฤะhpบฃ8Ž•{ท_(ำ๛|Kœ๗ฺ(๏๓ ำฟ๏qฒ kฉ฿œgถ้ว\yโ) ตฎIiJเ{๊u!๎Z]ศ๐ษี ใk!„๔Q@†ž0\้x`|๙djpa๎žซD<ั่ๆW—๓ƒŸl๘ๅ;[้Kบ ด:ฑŠปว‚J™=.ซ$H สนฆฆaฐยXืฑค๗I<&I่)ฟณ$ ดื็์ E,แDHฏUšพฺ๏ซ0hJb๓นอฅฒึp|Šช]–$ณืc;UuGxยMรลUKxnaส |ๆŸิ้ะG˜ p๔”Iฏฯฤื๛ศ๊๗X{MTe์c]ืฏ4E5Œ1‰`„a<ุ‹ืYยณ๓SVเแKชชX7ช สN๘ญ๒๎q—rEl+?์‰$ฝร ฑะ„ฝS๊a[$ไlWณท B”ษใฒ*๒ˆNq๗9D IDAT&A< .์ดภrkNโูปQืๅxzียี๗h“™E’สบ}.ฝWฝ๓“Bw˜ง"หŒืํเD™ฆฑ$)X{ฆ€ฯ^)๖(งื‰{ตณœดูสQ’BปฝNญ{๗U"ž‘Gแ2ญ^8๒ฬฮฟ‹0HWฤึIบ,€6h{IŠด๐โCPฉe๒คI<ฝ™Oปfo?ฒXj—าฅ€"tQtfqฺย"ฅื8สTPซนœ=๙โƒ4™/ฆ{:(ีBั;๗๒]คW:(6Cั‹๙*RWV9ํส;c๊œคO“3ฏ>$ฌ๔๘|ถ"ร๑d๓หษอไ?$ั*ฐ๘9p๑๚๒A@Ieตฎtเ‘a$—ณ9[b๖m˜ึๅฮ้af๘-rๅ0cJ$_O˜"T3้ช—พ^๐๖๓4tV#„Xง฿~žฌ๕ลN5}DพNHw†ื`Fฦ'€V?>๒ฮ.ผ #ญ}ด•:•ีj.kOฮฝ`A๎Tฯฟ฿ฤธฆ—>ฬาบิ*dHM๙K{ไƒR๙r๖๗*ใlXฌ์ญ ๙Aำื—'๋ๅื7Šbฑฅู‰F#6œ%A<^~}ฃุgํฤยโดผžปหE‚ ฃ๚บฆ๔1่๐๙’HŸ$๑ุ๐หwถฺ!ล}fต™Mึd0yc‰iฟีๅV)›)uT–ภxฏญrฐYh฿qL,ำชVปชะmดๅู <`„ €8๏ฬ„^ุษท ฮ้Œอ Y.งˆJน Dขqม IโรQN]ฺYYอˆ๎ ฟ่@,iW๙บuฌGf'ํ0,€ตุM kต›o{ร2น๔้ำว๏฿พš ู(กฐฑw:ธnอX-œช* ืKืiฎRW'‚ฃ]รฮaภ <‡ปฑ;†ล”ubอ‡OŸ/%4lR†aฑชuีv๙ธ)ร`๔ึๅๅํฒ๑B๋rYฤn์Kโ™’๛}Žใžz-‚๘๕jib›็5ƒ& ‰$๑I๏ย2๙๚๏ €๋ค›ƒTฝ]ซŠ€ะ๎๊4ซญฯ็ @kิZณ6ล0@ฌ๎๕ญZป1๒qช๎๑ๆj ข-ฤ|<ฤo•d LN0เ๓yฌJๅฐ"@=ฝYง,มไ์dฟฐ—โ๛wศ?อ๒4dด;0สiว;ซiฺ]Xˆ๘ำ!ม?t`แCษลญ๕BwศฒฌSoŽขฐXฺK=ูำsA๑S ณู|๑ŸฯŸ?///?แฺฤcฤง=๖>ฉฆฎฟภ†_พณ•พœ๗%ภ๛๐ยงหชอH'›ป•พaโV–ผzg-~I7iWliฮ-Wหงต:฿U—ฆ‘ษ33e*…–s*๊ขๅjvฟะ2z ฿}๓W๔๊ƒ=ว๋0'$ฎ_ysแŒay๊|wtรK๏œล/๛ ฆษืoL…/h .ผ๔ึv%=๘ฃ3๖>=ฐฑ๑๖F๑ฌ๋โŒŒษ[E (ฮ›x5%ฆฎฝtqๅH6Nแฟw3qtNรฟsฟฉฦœpๅ‰dŒZ๑{|ะกŸœ•ๅƒฦฯY;‚ ~ืj›Q๗ฬdฏ–๗zDยฏ•๗šI$‰O๘`Œฅ๒๎ฦ‰tk"ะวฆumyxƒีไOฦนrช8ธFฐ)O$ิฯฏคN/๕ob>(fwrj๘๕d๋`]ˆผน[ตŸ๖กจ_˜Qyžกญ^ŸMkื[’0dwจ๊ี้0V่ชช"†F(Žcๅํ]Iฝฯทฤyฏ‚ฑ?q3~k{tฮ๛ตฺุึ']…ป2~hตv+Žใ๚}rฟ“ ˆ๕87eถป\6mr ~D’๘$‰?€$๖8งLPึpraยN Kฐ„็fg_ฦ๔ˆY*˜v.ŽBk๚ฌ‚ะ`๗๛Wญ*Ÿู+  @๋:ึaุfbฌ_ฃa‡$ˆQyž๏ฃู๙D๒EฬGุzงีuร6†ขLฎฐฯ๎ {"I๏๐‚#4a็(ŠuDBฮvฃy๋—ve๒ธฌŠ<ข“Iู~pต6ลฺCำชั ุ๑`ฃŸ_B .ะ] ‰$๑I ใ๓ฆ๑Ÿ_d๖ว“S^+ƒ4™/ฆใ&ใKพŽ{ดำอˆ๏/!k0Ÿ๔ุXJ๋ B&W—0Yz?cฟ”ฉพแd อ/DดRฯ์f ฟ6D\3ผ<ob)แั*๛[…0”ลKLym –…j>“oซ™ผำ‰)ฟ„กšO็2ฅ๎ั๊fIvฦ?พ 1€ตพุฉๆำ~๔พ$OŠมฎWk4๓K/C €ฎHBใ${T%ใ?qwืj›Q“w:๊Qซนขไšš๒hี\ฑญ‘D’๘‰†๑Iฟ(ษžam๓ซ$X"โ็ธVŒz~‰ถyทc๕~D’๘$‰A–žam๓ซ$A<กQ๗อq VeE?ก‘D’๘‰†๑Iฟ(ษžam๓ซ$X"โ็ธร๓K๑ฌ๘$~$’‰วBb‰ ˆŸใฯ/AAA\F๚AAAŒ‹๔‚ ‚ ‚ืจ๑ง QL<๊ตqH๙R6[๎2Œฆ#๖!฿(฿wgใŒดนY๚กvbl–ษฟš2ื๖ฎ †pใŒ&ใ!'‡%พ˜ษ”ปะ๖ศlbยiฆtYจๆำ๙ๆะ!L‘ษ3˜๖MH๋๑ว™ฬi๏์cใๆ๐ซืั~vํ 6‡ห๘2Dc X“…Z>kGaM๎Tr‡ว-รL?ฦ]p้sZ5๕5ำ๘)‘งฐฯผ{ๆ!ฉฐพ~"~ƒe๒ฏl๖[ฎ๓t๋FฤO๒ง๏C+ภ_ย]๛ฆP2fnค6R=lฬพœ›่ฌ† เJ<;lp&B๗‡6€๒ฦๆ<โมๆa—rว_ฬMvึ๒]0‡ใQTูZ9•h๛๔‹ลฉ๖ื4o<J&ฌฦ^ฌ‘๙๑ ฟ],Pnไ3}ฝ}นตึหฏo%ฤบcKณFถH;vเ;ศ้rRpทŽ* [ฯ›ุเฬ ืุ^-‰ศ™ 4ถ+dทŸaPฑฐqญRถง|ra}ทฎ€9ฒ๘fา[nํjํ4๕ง`|ษใ'E๒Ÿ@8Zฟ#pฤ>$žzM‚๘รัถ`€m–o๓1ด ะโ‹Xบ•†๔จ—9๏ุ N{็t[P0@ฏRiNO8Mะ•Y๗๔\,h็@๎Tr‡…–€ฬพXbสg็@้6 ้lM:^˜๓&ๆ~Nแ •“7–˜๖Y]n•ฒ™RG…‹D}Yง๕าล{ฏญrฐY10a€rEฃ–ZฎlตŽศๅ๔z{••v_จkS๓^kพ‘/tjขŽA๏๐ž2ณ†ส้rงป‚‚„Jก€h๐}ิ^~ญัฝ~pb…ou™ G<<ธAqน-ะa\I8o9Ž`ฦ๋i&–iUซ]U่6ฺrศl ‡ŸbP4ฆฉŠฮjššฆkŠzท๛‰‘วฒF฿ตผ๚€^~mฃ(ลl๘ๅ;[ํ‡โ>ณฺฬฆkไึqG์C\9,ZfbNแ๖ชภCฬฐมƒLXrฦggฐฉdำวme่< ORcwžดแCจต6ธจg~ปˆฟ wุ๖มํ_—™Rลึ้qพุ”๔ฎใฅ๔ฐข ฬhbฺฃ–jC๓ํbรXบ|ี้>ฯ59่เโง„๛<‡^M}I๓t`๑c_=›So้ฬฐ[8ŠBว_๛OณนRปX-็;พภ0ฌฎj็ ็ณ+;%ภMธ:้๕ฏ+›E5˜ˆุYฑ„Mศl|บvภ[โ3>z0‘9ฑ466าm๋ฬคˆ%ํยแ๊?_ทŽ๕ศ์ค‰ ปpธ๖ฯ?ซ{๑าๆฒป‰aญv3yuใŽ,ำ>!;Œ‰ƒ~;&็“Kฟ฿็8คFกึ1vงMnดœ.&gX|!jป|” “[Y^^.O…X—ห"v{าไRy^wน9‹ห)ตฮ:˜ใ˜แz†ทPุุ;4[ซ…SUาy๘IฦEหไางO?พ๛j6dฃไา~Z|้ใวฟ—ผnฆqทจ๛‰‘ว๊ฏ//ฏz๒๖๒๒๒๒๒เ4lxPN]ฺYYอˆ๎ ฟyฤ| โ‚%@'_Wv–ุค{h;`3l๐ะXาึ>Xบฒ•๏ๆขฮก๓บ๔๑5Oญูl.ภไvัอฆpงm7…b“ธผ๓me-Uhs.; ^yใใ}Rzpั!ึ91z1„Kฉอส๐ฺ{X›๖f,=a“C;M-/////ฏ๕ๅZฝƒฝi?฿›.ร7†>ฅถw7šฆ้WK‰ ~๘J๙ฅ+eƒ๕AIทs๋;Hำtพ#ฦํ˜ญึ~๓จื„r๖ะy>ฉ\อŸ4EฑัฦS&@ถXm}>/hZฃึšฐฑ (ซMiๆˆฝห๗\ฤสแ^฿ชตwy๏‚60ฦ'›uย#๓Q…1Fœอ้คi,้uQ๔๕^5ส๏„œํf:ฐ๐!๎„ไโึ๚ะGฌSoŽขฐXฺK๕๎ฑUไOO|ดฦ๔ เnvƒaxer๚ƒŸฯcU*‡•๛<)Eำxกุ=\-!@ด%˜‡๘ญ’ฬ๚ใ1ks๋PFึp"9)lๆ…Gธ๓#"™ธฬ๐(ะตชจํฎN“ซJฤXฤ๊qUิz-O›Y€ุfki๒r?ข[MšŒ<ซญ฿ฬ Šะฌทจจ•ƒv฿hžรร{|ใอSk6…— Uดeโหตtƒƒ !†cz|9ร–+€-zเาอกล้ไ`๓ดwK›rX›๖f,{‹†59Xo<๎เ7x @m6…iท UดหmๆKฃ_ัzี์6๏ วf_; [‡๛งนโzแ๓็ฯ#r/ห%ำ๖๐lฤต#ะูaผC•ฝ๚ๅ?๊Š `6j๐\>ห`Œ)44hG-}ุRG2Oฅูฃ.๐œหึชต๐mKฟ:Oน’ษ›gโK&]j7ŠGG5?ๆสฝE\:ฦ# ุ57 kำŒฅ2lr๋‹วํ๕ƒึyWง฿lJQทxึmใซใ<าEจ—sปนธeงR~•bhtV`žไง‰๎๚vร;ึ kkM ณแ—๏ฮ๎aŒแผ(อ2 *š๑ฦaŒฅ๒๎ฦษ•+ธ.M~eะวฆumYฟ}…‰ด‹3™–'r๖็g๛๑๚๚ฑดี๋ณiํzkp^ํ๗ใh 8Ž๋๗eฺ๊๓2jปX›m%๎ถ)yสฏข‹ก8Ž•{ทwฦ๕>฿็ฝ6๊ึฝyK๛ กQ๋š”ฆพA๊์.`”'๊็WR—_ฝ%ก๘3…bฝy๖ง+‘l๒'ใ\9Uยƒ‹EˆขŸื๗0EกวqcF๒ฐ๚zฬ†๕ญ๕หอ๚ั๓|ฤœ7 sŽูำภ€ฏ๎6<ŠoAIb`x !คc w0ฌสาอ+ท† ž+‰#ฏXฒ๔›‘=p้๒ijซŽ%—ญBฆP‡?‹pk›๖"–`ึ…!ร&๋Oฤฌ๕ƒร๖ฅ%rณฉ,บํNึn๒เ,c อ$&,ใอชx๕fห˜Uๅตwวฝบะกˆฅ(ฦ yิŽะ„MำSฌ#่2้ฌษLS$ฑg๒๘,…hKp๎อผ่ฃR’ุใœn3@Yรษ… ;ฒ$™]หZผS๎KOkYยs ณณ/ใGz‚๋ฯะอฏ.ŸYษต๕๊๒ ๓` ฯฮ'’/bพ๓Ph7›ึเ„“ฅiณ7โGFฌ๘Lศฮ ฺ์qY%iXEฃwxมšฐsล:"!gปัผ๕&ขL—U‘ๅGzlท ;{ๅ๏_น[€X;ฃ๐f๗๛พGะPผษ ฆ€‹ฃลฺƒ>ซ tิ^Oqx}& m๕{ฌฝc~2๏ฑ#๙ฆศ2ใp;8–ณ˜YCŽb‚ธฺlๅ(@ฌ๋ิบ><8ภ <’ุ3น}v†ข8ทื‰{ร/ฆˆ๐6Oนูิ“!gฏษkw]บ%œˆ–ย๊เˆgๅo๏ใoัร—ฎ ๅรอ=ฐ๐z!b:๙ฐ6ํอX’eyะบฐ๚ง'=wmชทจ $b–Z:฿พzv›M์Š†Fkิi‡qMฝ|t๖r[[น๋‡{ป๋๛R93วg฿D9Pลึษม‰ีBล›x๗)ฆtJ™T6ฐฐด›ฅj.cK$฿|ไ*๒ว™๊ะ'าิj.gOพx?ล Mๆ‹้žJตP๔ฮฝ|้•ŠอP๔"ท"ue•ำF?ฒNŒMIeตฎt๑˜R=whMฦzฯa‰/œt@ซŽ<ณ๓๏" าฑu’.muษ•รŒ)‘|=aBŠPอคซ \๚j ภฯำะ=Z|Žภ:๖๓4`ญ/vช้ฃว๔3:ปž1~€ฎงQxPลฯ‹eี๗—ผ„แกx=’๕ฦqฮO๕‘ฅดพะศคO๛ะ9IŸ&g^}H2X้๑๙lๅn฿๋yšH}ูc๏—ยƒ็{฿|žบ๘ิ€V?>๒ฮ.ผ #ญ}ด•:• b‚ธฦ5ฝ๔a–ึฅV้ ำršŸjิเQซนฌ=9๗v‚นS98Y็C็ูk6™่D?—Uoหyƒ"tQtfqฺย"ฅื8บุฬ‡ฎใ}-zœขร2_Hmึ~Ž๖๕<ร] Fฑิ?อ=s/฿…ลJฆิN _ฌahุข>u๙<Œ^8t›Mv"หŽ์0ดRฺูj>๎ฅ-d6่๓็ฯไ†/๑l‘๘$~†‘|๋Dฯ9็R]ฎรฦฑ}2†‘ซ„๗ำฎ_๚ำฦB(“7>๏kn๏ื๏{Waน–๓ฮใOAA๑dh฿‡„S้žๆ๎yxา ‚ โัษญl<๕:ฟ‡'%ญถ๗e๘pw?y ‚ ‚ ˆq‘Aฤำหd2ฟnNรWฦฯ๙#O‡?ว/ †+ซlัำฎ/]t?อฝ „๔‚ ‚ ‚้?AA1ฎวyšฒ…’‰Iท…มJ/f3•ฎ@™}3‰)ŸCชศ3้rW7ๆงTฟ–ูอ๑d๐-โั9ใ^@ฦz…๕อขtŠ,–;งนLกีŠAส(‹&๕ฺ8คŠ|)›- O๑ pฦ?ฮH›ƒP~Utp๑cpq๎ญš๚šั๐ื9ซ่œ๑1ykฐž—์3๏—‚ญิื4๒อœใ ซ[w(Pgให1`Mj๙tฎ๑Lใ๘Aว๛<ฌg2 UŠํ‘yฅภgfธฦ๖jID–ศซX ฑ]QLกไ WKญฅ$d‹..N๙jฉŽ7lฉ๏~"๏ƒ๎#พ†bPU2๑Xฺู•ห^$ณ)”Œ›ปk)‰ฒO.ฮฯtWz$ ‚๘…™Bษ˜น‘ฺH๕ฐ90๛rnขณZ่>๕Jฒดำิยฯ๙;žtฅˆ1ัNท๘rบœฝ฿ิหฏo%ฤบcKณFv๘0O่Aวป๙n ฺ1ต87iรnดฝ{2b<พG้?˜XฆUญvU hห!ณ@s8ํ๊vO€N~๓`„ €8๏ฬ„^ุน>7A<*สแttNwบ*hWj๒’ำ]Š๑ “7–œ๑ู,w*ู๔q[ฦ‹ญ,รPชGฝ“ตชฦ†_พณีq(๎3ซอl๊ฐ&ฐ๎้นXะฮฉไ -ภ“; ๅt๏${šฎZงฃŽึแfAภภxฏญrฐYhใง๐‡ขN{็t[P0@ฏRiNO8Mะ• สำฐ@ุ„a)”'8bโสaั2๓pjซฐP้a0yc‰iฟƒƒพฌำz้|ฝ~ซBฤy๓ ?ง๐…ƒมถ†โYุY]n•ฒ™RGร๘ใขฃํ‘ูฤ„หLฉb๋๔8_lJƒ“ัCสำxž†๋iธEฟสลๅถ@‡q9$A_สำpž†๋iธE\๚Oค๒ผ๎rs—Sjus†lๆš๋rYฤ๎ˆหํOษ๘xK €Nถฟฎ์4,ฑI72žz็Mพˆน.n,ฐžฤ‹ธ{ุ}†ว?Ž29ม€ฯ็ฑ*•รŠภ! œvผณฝšฆั……X€฿=•๋้อ:e &g'๛…ฝ฿คฅฤF‡ E‚xzซญ฿ฬ Šะฌทจจ•ƒv_•dํ์ฤŽปงgO$๋ํZUิ„vWง)h็ึwฆ้|GŒนณนv๘–ฎนต^‹W4ฟ†ุณ@ฌ๎๕ญZป๑D๏ <ฎ+ีึฃ๒„!b8คOร๕4ข{/ t๙–e1ขœl*T†์Žaz…๕ข็Mผz1™Z?Gd~*Cป|l?วm๐`]ำ4ŒฑฎkฺศŽใc๔(O$ิฯฏคN/ฏŒช^]5Œ10ฤ|Pฬ๎ไิ๐๋ษึมบyrทjฯ๗น:โ7 ช*Eำhpœ14ฃ** EโY๘ฯs3รญ]Žg c ็็ผ๓vŒนš›_๗nฟไษfยZamญฉa6๒ถดลใฑiF[~žฯ(…ชชs^ญ'๙iขปพ]6*ฯ๑ก<1\^ะๅฟN…|cฉผปqr๙ํ]ใ๒4.:ญ[ษ์T2ˆฑธ"ษนDฐฝ]\#ซทณW4@€0ึuฌ>ZBI๏ดg de(Šs†|ฆv›„"A< ’ุ3น}v†ข8ทื‰{ฝ>…หqB#ฎฆ „hšF˜bA—IgMfš1‰%<ท0;๛2๎ง‡็๙e่B[p„"v–ขk(ไQ;B฿ธ<วw‡๒”%ษ์๒ุXึโšp_*ะ฿ช๏@{œำmฆ(k8น0aง†•งaัYย‰Xะia)ฌS็-ป๑สSฺใw2e๒๛œ}AP‡อำh=‡๛e๖&nv๖ส฿๏m3Q&หชศฯณงd|ผmถr ึํujndY˜ี?=้กเG5xๅ๙%T`๑sเโ๕ๅƒ†\I็,‰๙ทS –…๊aฆฆภูอฉQ‘^|*ตLž\๑%3๑ehิo?OC/ฟถQ”ไr๚ศœXx;อ`นS=ฬ44 กHฯ€Zอeํษนท,ศสมaค๊‰๘๚อ฿Qภš.์Ÿ~๋\ฎ*ฤปO1ฅSสคฒ…ฅEุ,]˜"ue•ำฎ<ฎ๋’ส้œ9>๛&ส*ถNN0.ฯ๑–็ถ`”UฉŠน—๏"ฝาAฑŠ~รoUศใSซนœ=๙โƒ4™/ฆ{๚ฐ๒,"tQtfqฺย"ฅื8สT•ณ๙ŽWžz3Ÿvอ&~dฑิ.ฅKฝก๓4Zฯแ~นฝ‰ฮฺลwฺL๋๔ฯำ€ตพุฉฆ:?gM๏ส๐xฦ5ฝ๔a–ึฅV้ ำ่Ÿๆ‹žน—๏ยb%Sj'๔;7x0พ๎%2›อ๙๙๓๒๒๒}7 ~ฌงŠO“w:๊Qซนขไšš๒hี\ฑญ‘D’xKโ†‘l๘T’กaฯ/™8<Zฮห(๏ว`k%uชP–่ซL๎[๎™žี ‚ žˆใoxต3ืณ*A<ดอธ-ซw๐ƒ$’ฤ[‰๛ั…z™|๛แ๛๗๏฿ฟป่•‹U2.Aฤ๓B๎?ฟŒงŠODsƒUYัฯh$‘$–8น@AZฎนk‚๘maญ/ฺƒ?H"Iผ-‘ ‚ ~Wค@๑๔vvv’sฤฑ๔ๆ$‚ ž็ฯŸo&{๎ƒผ@AAฤธH ‚ ‚ ˆq‘็—ˆ฿‰31&o >gv๙๗f5#mn–ไ;LCูBษฤคย`ฅวณ™JWG์รซ0s%eญบ๛5ำ6ๆงTฟ–ูอ๑cศwล8&ฑฐหBkrงšKZ ะ๖ศlbยiฆtYจๆำ๙f€qF“๑“ร_ฬdสก๏+ “g:1ํท›ึใ3™ำ๓oˆ›รฏ^G๛ูตƒฺ`฿9ใ_†hŒkฒPหงsป A#Y&zมf๙พŒ}j๑eD<๘’n^_ุ_Sๆฺ 2๛fS>;‡T‘/fาๅฎn\ฯˆU2:w<ส‚~+#K้๒ไ"K๏g.ช^฿_>่ฯผ_ ถR_ำ<ส7qŽ+ฌn้ฌณGุง3€แ1_ค@… ฮฬpํี’ˆ,‘๙Wฑ@cปข€XุX?๙>4&˜ฝaK}๗›yt๑5 ร€ชƒ8Otาอ^N้๓วU ‰'MฦไˆฮEpagต.#kxn.ๆ8hhๆp<Š*[+งmŸ~ฑ8ีšๆ1ๅอyฤƒอร.ๅŽฟ˜›์ฌๅ‡|” %V~ocฏึศ‹x฿.F”๙L_o_๎๘๕๒๋E ฑ๎ุา์Dฃ‘%งy‚xฎฬมd"โขบยอf"œ‰ะ‹QปMกไ WKญฅ$d‹..N๙jฉช:ฌžซtAVJW๗ฆrบ๗ญ~๖mmฺ๎๖M`ฺ้ถ฿AN—“‚Ÿ5”ย]F๘งณ1ค@ืก]fJ[งว๙bSาภไ%ฆvV—[ฅlฆิQแ"ัมA_ึiฝt>ฦ›x๐h•ƒอB{๘˜Œ&–iUซ]U่6ฺrศl0:ฏ`ภ!@q™น ฝฐ“ot ›/ฒ\N•rˆฤ๑๛ฌีสuสUQกฺ่Gœ6hดAไ šจcะ;ผ€งฬ,@฿้๕๖*+ํพP/ึฆๆฝึ|ทg4Oส้rงป‚‚„Jก€hgืบX่ๅื๋๋‡พีe‚๐ซŒื๚ดhย‡Pkmะ1ณNฟ]D‡฿Ž ว;&ฎ๑$H9;ษžฆซึ้จฃuธY์ฑqๅฐh™‰y8…?ฺ;จJ?จWt.ดฒ Cฉr๕Nึ๖ซšaฅŠLXrฦggฐฉdำวmeศสcƒษญั7E-ฏ>‡ —_(Jภ†_พณีq(๎3ซอl๊ฐ&ำลA~๕l3ง,า™aw,”nณzTl๔‹^๋•?PฎhิRห•ญณƒtสแดwช=:๙อนฦญ็๏b่*ษhwX/ƒฺ*์TzxXษŽฎ๏Mฌ)ณห๓ึhฤฮ$;€ (.ท:Œห! ฯถฏfucŸฮ`†H๘ํ™BฑI\VW9‡/์ถำMI:Kฺ…ี.ํM.อNvV ฑ„]Hญฅบุšธ˜kฑ›์f FŒ,,6๖ฮ~2V งžท/-“KŸ&0ึTฑ]สe*]น^๊ฬฯฟ๕ส•‚:ฑธเhew‹ipŸ*๗u›อ4x™. ซ3 5 e@Œiำ„ชภ˜8่๗ฑcr>ุ/๕๛œ0ฌp†ลชvvbUๅc่ไV–sเˆ}ˆMƒX—ห"v{d_ŽIk6 ฏ‹.W50น]t“t๎ภn’ืŽ๘๗ ‘ฺZบ๚bm)` ะ๖ืŒij้ีคป–ๆH!›Bำaฅฐบาะ-“‹3JfฟชมJีKฺฺป๋ฉๅŠฝœ‹ถWฒmใ•— &๏ฏ/>ฟD9]tjg%๏ž;้7ืNคfณ๐œmฆหล๐๙€u๒ฏฅI๓ฅฉฺนีิฉาmT€s_(หฤดOศฏuุ๙ณ†a1e˜ŸŠธ8,6 ้LUฤC๋๙‡ะ†ญาตsวชลpw€%ค๗wV2ฆ่าซIฯ้A Kธษ๙๋0,ฅ{๓ๅŽ„QeงyV˜*ฯ#ท›ซัNฉี2น~๎ชอ(๊ฦ? ฐ!โ€รฑ H=พœแIซญฯ็ @kิZณ6ลbต)อผ bฑ']ชชลสแ^฿ชตท}Ÿ29ม€ฯ็ฑ*•รŠใอีD[‰๙xˆ฿*ษ๕๔fฒ“ณ“ย^Š๏฿2Wb4ฬg; sฦjฟSmห@Ÿ….~Jธ๕^5สv0EQcฤูœNšฦ’NQC?!q~ฃ;ฐ๐!๎„ไโึzaุ@ศึฉ7GQX,ํฅ~๕ณ๑Oค5›ยŒห…ช ฺํ2๑ๅG}ยwืแ[บๆึz-^ัb+Vซขะk xฺฬ๔ว.dรึถ4j‚ซ’ฌ0DŒnSyxฅฺoๆEhึ[TิสAxๅ 'บ๕zปV5กีi ิfS˜vปPตAปfพิฑฒทQฟ<ผฎ }฿Œ ฬ„๑ษf]…๐Eสiว;ซiฺ]Xˆ๘SŒ๊๙ม๐a˜ำpw€xZจtUต%่ฎฯy6คัtฬ6ช๔ช ล“˜˜ไบh๐|4๏๛Š1j์ŠŠภาY`๛>/ฐ; DŒ%๓{<™rๆฬ™ฒณ3&z™อหฏ%\mžCป^‘_ปrำRฝFO๘ฝดVห๊ม็:Œีqƒwg™?^1ีcฉส˜c‰๗ใ&]lTrววฅŽ!SpnมซEkข€!dุwนjปส฿;,ค๑๗3.‰ฯ๖3ต–า่ช,wYRพ [ญ2นc3ฆ-:ข๓‹q‰?ฺหึษ‡ิฟศฌ๑)š24พw\ศตโฮr1rvถ๖สบฎ#„ด๒๗2Dบ๓ีๅ๗xปใม_Lเ-ฃK;ปถžโ<ษ๙ท;ฟนe๙๏~็ฑ;ฟ๗F'6lBฟ”jตqŽAsฺ๊ฅ๚๋H๑g1ฎ~ ๎ษA•Œmุ๋!8%5๖ไย็IM“้ฃ:ภNี0 ๕ฏbฟ)ฟซ๛KฎVลˆk jฌหVใช$ๆW)G4jแ๗v%€kb`ิ‹๙–j€Zฯ—; vkX?`๛|P\ut p๙ใฅฯzำ’‚ญอ.ศแvvช™๋Šlี๊–นฐrบกPม?”๋กมYูฃะo`๖O%|j~๏ธํI&}Z~๏ธช!>p`TUฅ้๓ลgšฆTUะZ…ิV!…‹3<5“ 46 ฒab~{๔ฦา‘\to7ป9ฺโvดfฅ!๕๎-(w8(gVvŠื;,“o*มๅwrญ๓0žไl sด•VC&๊๛kBx1่:ฉ—ศเ้waํ>U็ ฐ,ซ**m๕z˜&฿มP;ี†’pูก\•eเ8@Žใdนื็dชช"†F˜โ8Vj฿šH—k๕ฮฌวFAg่QEฏ๖C`œฟีp‰ส•ชฮiฏrcอ๊!ู๘5BB๚๙ภ}@%ใG8!ˆ;ซ฿wo๚fผS5ฎ;ี^ 4=่๚ๅA†ฟRตชฬน์ึจ่ึศย๛qำต อใีm์วฮ—“3™'|ทcษ~ฒถqซไ†a๔๐๓ฎ๏ภƒฏŽฟฌ–ฐตนvาฐ9Z=ศ•RหคTE๐ัผึ๊ิm๕xmZฃ\ัฉ๖›?PfปำฉTHฆฑ๎"$ย'Œ(tิ็8๋ดว๋…œ –P2จ— ี–ฌสฒ กุis^—๙,/‚5”ˆR…œ Kขh๖ธmEU ปhธ\Dถ„fDญPKปS์้ฃ†1บ \C1h‡฿๏,u*m xญBฉชšชjš@†ก๋†ณk0 ]ืo8อ0 ๘+„08”#”๔Yฅํ“ๅ ๛ุzฆV_"lํlŸ*ev;ญข @ฃZM†วี\‹v†}จฒื๋ญ’ฌ ๑เธฝyึ6lแ ฃม;^@”ษํด*RŸI&แ6RตชOM™v๕๘oŒฺlๅ(Qก]‡ึโฯ็ผฃV2…หq๓A5๔pชbงm๒{ํ…\›rxFป$ุฐ‘bP$‰๑ธฦธŽDำ†(*ฝ_ TซF2bZฅtท v๒;๋ฅ๖/ต2ซห™๎O6๔๎ณํ์‡USฝ„lB‡ yอ\ซ‡Ÿ p}|u`ต$ckธ1;+œาคัศn5ภฯผี๕์ฮ,กู้จj๐ฟ๑z#d6_ํl\ZZบyO5Bจk—?ˆŸDˆตOœ;>๓ูYClœๆš*cF#—ย"ฅ]9M:2๛SQ•AšTหv๖ฆว"ofยvิ>ฯ1ณ‘ห๛๏ิ‡„[+๎mdzŸฟ„=^บ‚ฌdbยmc)M*ูTบ,^ฦ€,มู7‘1Z)งถ?ญ”p‡‹ณฑi]jSูš €ฌม้้ —™Aบาฉ็Rg‚ฌ3:Œ rƒg2๕ูMH๘ฬaฆ"W็/uiฏnœIŽฤืwA M๎4๙ฬaถึฟ.ฒไฟไ็ใr๚วล๙ธ„pOใซo_Š}ŽKฟ6+พ๙wl๚g†Š™skรับX?;Jๅš#Ž+™๕L˜๕u7ิšิศํ๏ ึฉž m,HอB๚ [Wzdพ…}Yƒ3ำQ—iใ_;E้ฮ ๐’ฑุโ|จบ็ํ€+๙m.p๙‘hล/>Œƒ›#Nสโ‹'ฃcHŸIeชR?e๖สRฝO฿qluXใ_๒ๆๅmH1qcใฬŠืCs”๔๋aแฮyฆฟEฤ๕“๓ลA{l1า๙นS์Zš5ฒิvžใฝฌฎGwฦx’๏“nญฐ๗+์jฃฟอ_ฒดดtWxู[๊น๚อLžษˆ[ๅำ9ับ5>khDH„O ฤฺ'๐B!–Lxฦฎ ส3๓5P_9KY"๓o™๔ˆ๏w„P&Obึ[+M๏ฒžeuผB๐€็Ijะ๏kmฺๆ๖๛]ŒีำA„D๘$B@ <tก\b&>}Y\\\\\4็‘rSฏaำูo฿฿†”l๚ฏš<ภ๓ฌŽื๐ข฿๛Dscจ’ข_ะˆŸBˆตOแ…B,™@ ^xภ๓$ ๕ก฿๗ำ†&Kข\ B"| !@ ยSA<ท ๗?ยำC^Jแ ช๚ณที@ „— ™?@ „Av’=พ๘>ฤ^ษ_9๘฿~๙๏บฎไรุฃs๏ย}ฬฑูWŒลฟฬ‡˜‹*ึ๘ํ๏ฉฦๅZ&>~ŒšKป}b@&๗drาg7!ญ];IฅŠํ๓3ผอก๙๙่็~ฉ{2ท#๑๕]6 04I(eำ•‡บค๖‰?กงOณvnาAษฅิvบ๖."zU\\๕ภJป–;JZฝ๎วกฬX2๊ตsHํิrฉร|K๘์v:0๗5แ„kทhฮ๗TเฯX๒0cใษxศiก5ฉษงณue(กษ›˜ŽzmehRณ>8ฉซด=<w˜)]๘ฬaฆzํา€œภoqqD๓;{นร็?ฺN~ค๊ฦ#Ÿ฿z•ะ๓Žsž“ี้ ๗u3xgล8"S‰ ใฦล_g-พิwพึ  ผณ_gธ์๊sผกห มzo,˜๐แู‘ฮษฦฺIฏK[ ฯs`*vR-a†ัษฎฏv๎สู@,Lหฏโ‚SIkmw}ท ึ๐์D vqa‘Tษคdฝqผ™ต๕œˆXW๔xฅrิภว9OgŸJq๗G๙๘5ฺ™˜ตฮณq[ŸfOศR!„ฎใZษŠa@Uqอ™sG&\์u‰\;แ!๘7Oฑ7๊ฑXŒซlฎžu%<;๗W6 ๘ฺLมฉWฺ๙น#"[dn.๊-ํ๐=๋่6Zq็ฟEภจ‡,y@ฦ"3a#ปตZ–543๗ฌ๏Wดม…ึ@ิ+eืถห ˜รs ž|ฝจšC‰*Z)Šด}๒ํ\ด๑ฐv>ผฤ (&Ÿ฿Tฮ๑๗c$๔ว2ผมvะƒ๛บฟฌณข<๑wgใ Eนog&š?3-ภ๙:ฺแฒCญ‰N|uสoƒตฌ๗ฦ>Ž๋ ผt9š๏งูะปฯถาLxอj๕h็ $€ษON๚์ฌ.ีฯŽRg‹0ฑBฦ“tk…l๏๛} ฟาช๒วนJ5็ฑf”3ฑ”าy๋tŸ(‡sL(n Š ฒYD#€ซ[{™Ÿ•ึmh(ตz‹ pภใฌฎ!๛44E>?@ม kูฎศ! ฮ›ืณ[™ฆ๔Œอ ZฎK:Jพ …?0ฑL็[ชะช4ค ู €ํSฉ1‡ฝษoถUhf6ํJญฃ<ฑ%c`ญVฎ™็;*|E;lP้ ,lhชขณšฆ€ฆ้šาฦvjูfฉฃ 7k‚5ณ2ภ€Nฦโ_สAฮ‹ป9ตž/ด d๒ฤงb^;cHอยัแICธhqcศ’N๋gz4Cณฯฯ–ฎฝ$Fœ'9›๔qJ-ป฿S๓๎ฉbZ๗LฐลC:ซldฃฏๆo$ฤ8#3๑€•eJ•dิ>นว[1๕+ก™ฟ ํ{๓%Xู]„ฒN~šC?Ž…๓%gง™R;๕โI&Wud๖ฦ“QฏฅUษ•ฤGฒ:l๊A์๋FV/œณrx<ํยJCึสนRtึcอดฺx_‚ 8]h2ฮ1Qภฌ›>ฐาฃDwม๗†ed฿?P'}ถตฒš๊ธฦ}f ๑)ปpฐ๚๏๗_'zxzยฝ„ฌลnbXซL>ศxดV…ฏu<ฬ2๑ทฏ_?อOm5bŸ๔ ™“fWร0ฌกj็aิFค*@3ฝฒผผผ™ว๛>ฤ:–Nซ˜Cฎ?jŸ”+B…\๕ข@ท๕)•ฯšฮูO“\กฌŽฯฝ ศวุษƒ]฿-v—ฟซ…Sี^ r ร”u|vแหทo‹๏ง7oๆน]G๒๔–|U’u›หล2นœ–e†‚tถwจN,~๛๚๕Ÿ๗žฺvชข€Xษๆ ฦ๎ฐiยลLi0'` ่ณญ••ํฒ96แF@๛โSถฦฺ๗•_ู?qะxา.๗฿ีB็<ฺžอ€ม๊๗Sฅ’p๙ทูถT๗ืืึ~šฐ›คิqอ6F'‡(S–ภิ๔„œฉ‘ CA™พ€฿๋u[•ยAก็ ”รnlmฎาc‘7oโฺv๑ขพYG็1,y0ŒฺษQ๓อฬ— Un๒ ่ก„ภ๚qku๏ื„ฌกไิ„ฐ‘้.GานoI—ๆwŽบ†tŠูBKP๋‚๎4q’ลj“ซAัชๅ:ฑrะ-V›Rอชะi_ฌโ๖l†„ปุ}>ฟnrŸ9ญv:•†ํฉyhึ๊บๆาฺ๕šข๙4ฤขšฟ™*Jฺ๙ภ1vปŠmw๊ŸPฏฬ฿EซV…˜ำ‰๘ ํršj๙ๆyขˆแXฤv-ŸชuEfซUฎ7d@ศ8AทDฟou์ฤว๗ๆkนiคWwŠุิ‰}hชใๅrYQeโlMขNQเ}€Tฏั~/ญีฒzะ๙ฤEŠž๛zร฿ๆ๖{๙%หหฟ:ง๖—K๙ํ_์"d ฮ-xu hMP/!จํ*il†e˜3}uU–ฮ_J๙r+lต(Žhิย๏ํJ—›ิ๑๗Hwh๎xpฤFŸ };ปถžโ<ษ๙ท;kั…‡ื๛Ÿฐฯพ ‡ูฉf.v)โ๔)!“;6a ูข#:ฟ—๘ฃฝlฯŸืก๑๗3.‰ฯ๖3ต–าgฉ฿ฃ^ฬทTิzพYฐ xู฿ชฃ‡s’qŸ="ฐฦงhสะt:๘n1”v๙โ~ฃcHgๅ‰~GFจhลๅ"b,ไ์4lํ•5Œ่ƒq๕ฃŠBฦ…30 ƒB่–๐’อp›1ŸOๅ7ฏ[u%๗ั<–>šฟิl“ Ÿ'5Mjค๊Wษ_ธทฺ๎fƒRญv"ฮ1จqN[ฝิPB*ค2ๆXโธI•๑qฉc(ฆึฎV{—}`ซ๋vืหื‹ก+*€K1ืค:^0ท•ฎ๋!ญผ๗ฝ ภ‘ฎ=|ะชี-saๅtCก‚O]”a่ํฝ๏ะง7}nฯ๎h&ู0 1ฟฝ~*+ฺโvดfฅ!้dƒ0:hซวkำๅzwฦไ›Jp๙\๗•มนำฑธœœษ๔?แ๓gK๖“ตๅeŒใง|*bhิ๕[วฑR๛ลu]ฎี;ณีฟG:ซ|}๖ลๆth๕E8}2žไl ฟIš IDATsด•VC&๊๛kBx1่:ฉ—žํซำgๅๅฬสๆ+ฑ[–ฌช7ƒ\1ฌฃัqiษะ๙s@ุ}.ชฮ7`YVUิa„ˆขภธe`P ญ^ำไ2jงฺP.;”eœX;xขd\Œ\/p\^…์ั 7ANฟWโื๏™c5฿+$^๓ทโqguใ๛๎C๖ เ3ซ€\ฉส๏œ๖*7ึฌž ตV!ตUH!ฦโ Oอ$อ‚|ฃ˜4ห€ชhฦญN•Dฬฒ.๕(ข}|-FQ/ฌณชส2p  วqฒ,๕๐u„JฉeRช"xŸฌฟCฯ ี>๗นุis—™ ฌกฉ7ใvช—ภšy3=.แลVBยXBำณษฉทq๏yU(ํ๐๛…(ึ๐Zกะสฌ.Ÿณ’n่๎rฏqƒฌ cมq;GQ์X8่hTช๗:?D™Nซ"?4!fŸ˜Z—;ถp๚Tk้ญœ dบn่=ื† Cฟ…f‰ซ†a YฦูิmKึ›๕–#ฒ1er†ผๆF๓ฒRnีัศxKฆกd<์`)ฺไ๛ุzฃ5ŒPmท•1ืDขญ>ทต๎€ี—ˆํ  อnงUลaœฑำ6นผv†ข8—วaด2Hขhvบm,k๑Dว]๔eH|3$„r๙mพ|฿6ฌๆ{…ฤjNBB,วQก/3~+๓ท[1€Tญ๊ฎ‰ ฃ]ญiก’๑€รยR†ฺuฦy1พ1–Bด%0ณ0๋cz•V‡M่ํ๋n3‚๊xนเœ4ชUk`มาดู๖กJฅหื€ัศnํๆŸํทำฝ่]ข!zร0š๓—pจ|:mŸzปe&ีr‡mฝ—@[’สiํ‡Ÿc@ภใJ~› t=ๅ›%?hลS5P:‚จฒZK<๗zๅ$ํJ$?~e)M*ฉรโp++Rแ eJN}7!EเS‡ผืNญ๘ด4 ญใี๎yึษOK“`hrงษ7GWฺ๛y,๛Dv›ตำn_๖(x}j~Pฌฤ7oฟ”R*ƒ๏ƒ:ง;ฝ+K„8Pน%ๅ฿—8ถd ‡iKr๖S”1$?H•.zโu4ฯะ’ฅQฺ–œขuฉY}dŸš๙4ฮ‚ิ,์4>›๓ฬผ๛nŸํ็ชมศEH|3$€r๙]-่]ฬXอ๗ ‰ำ„Dด๓aแŸn}šิศํ๏๖๙ zเฬ฿iลํj•‰Œห้ฃ‹ฌ-‰อMZXคด+ว)^้f>eKN-|ๅฺฉ\ Gnuุิ ฆƒ>้้๋n๓๐๊xนhXgฅ•ำึฉฤวEฮkนำื‹‰ž๑./์็ฝ†้ 2›ฏพZZZ"‡ฯbŸ„ืึ’‰y†‚๖ฝ๙์)ุ+?๖๔๊nB”gๆk พฒSิ(Kd-“‘bว27๐๐๊ ‚ษ3qซ|:':ฃQทฦงs ํJุภ๎ฃใq?]อf+26$6ฮgหญN๊๑?@x ฏฌ–฿๑7&!](—ฦcŸพDบป UศตโeฏเมีAฺๆ๖๛แ8งZ=kBk=dq๙ฌt–ญศุุ8_ d@ ยหB-n/>UBr%๕ ป“ๆq~›‡Va :นํีขกช Ÿmฏ๒F๗“ไK!ตดฟZCช+$6ฮ—™?@ =14Y๊n.บq]ˆGS.็KlA @ …ฬ@ ย ๙@ @”ั}ภุฃs๏ยV/$ŽศT"่เ ฑ–Kฅ๒- ฬูนI%—Rฺ้‹๚N„๐"ฐว฿๊;฿kPูฏ3\v๕ืู=ทณ8_cโฦฦy@shCD>๚น?’’ ฃ… ฟ_Œูฏ zž‰@ู‚Sษ —…1”v-w”*ดฮฯ{น๋ฌ๎@ๆพ&œ€๊^ึฉ๑;฿Su€ปโH|}ค  MJ™รtๅ^“{w2?\1o ๛่s๐„pX&>พeFxˆ$ždอ๕ฉฒวfไ%YœlpฃํไGช>ย‹ฬฎโดว>ฯ‡8@Hฬฎญ^ฟ ไvC‹Iศ›๋น?yq๘อฒฟlซปโฬX2๊ตsHํิrฉร|ฟGภ`™๘๘1j.ํ^—T๒oŽž w‡ู9xโภ˜J†TKธฎtสŸqw๖7Z”+๑vfข๙3ฃyB–๒๖!ผpืJP ชJZa„ะ—jMไp:(๘ŽLชdRฒ “‡g‰RQ>ฟใ‡v&ๆCญvฏ l ใ*›ซgd ฯฮว•อ‚‚uVดโฮ‹€a,คY[ฯ‰ˆuล฿OW*Gs6๓ƒ'ฤ๋s๐„ฅœ„ก0๙ฆrf”“‡q วซ=†ฑ๘—ไํ@ฯภU>FูŸl‹3งb\i็็Žˆl‘นนจทดร“~iุ@,Lห—7เ๖r3<˜avƒ{9#™?(ญ*œซด]s๋ฅะแ๑ด + Y(็JัY5S!ึ็‰อŒู๋ญLƒL #CงหMฦ9& ke&O<9้ณณบT?;J5ี+แฒคำ๚ภต…™Ÿ•ึลุˆuMฮฤvคf!}ญ“1ำbhŠ|พpb„ํต์~Oob™:ฯทT UiHAณ@ม:ซมม[ศeๆ”Zฝล8 เQœ6๓ƒ'ฤ๋s๐„pูดF>F,๓K!hg~ฎ็D`C๏>JF0แ5ซีฃƒ’ิฃq!ณ7žŒzํ(ญJ๖๐จtใ6bฺ•\HขิฺaMร7mlBx0ณน…`ssใดƒlัoL™ตƒช้JิCKรc๖๙ูRช;cฝ>ฝzญJรำษqง™R;๕โI&W๕{ดt=N,=โ<ษูคSช™ฝbg%๗จอพฦp-ŸOmuืโจ1‡ฝษoถUhf6ํ๗<ใŒฬฤV–a(U’Q๛๔็oI(9K,๎ๆิzvoฟะ6S๘ลด๎™`‹‡ผu22V?ุศ /~๚……rF"–R:o>Wi็3ผ 0ร์ jƒ‡‚‘| ต*|ญs๓mcโ@–ฑ‰ู)ฟE–eŽใ@*Ÿ5ณŸ&นBYŸ{ทษไ0ZิZMwบ8‹ำ!ึ]ทH๛ใSvแ`๕฿๏ฟN๔๐๔„\˜ด ?wuทะ9๗Ÿอ๔ส๒๒๒fฦจศI:›‡k฿W6rj ถแ9@นย!TศU{;!ปพ[์ฎ=1V งช เี`-ไฤ:–NซXN ›๙ม‹ูท์7๔9xB8ฺ'kหหkูถœ฿\^^^^พS'}ถตฒš๊ธฦ}f่ัธ_พŸธ>BnคWwŠ&ใb>] พy;g('›ฅ{6>ธDล๎๓้}&‡รฑ ˆํZ>U๋“๙aโฤ#๑ู\]+ ˆšYนGa”Œ ูOuๆ๓YจA@9์ฦึๆ๊!=y๓&๎ฏm๑ ฉขคฯcท[ ุ}™ิ)f -@ญ บำิ-hณVื5—ึฎือง!vtถ๘œ`ฑqบQV!toุปc†v˜ภร๐h๓]ืBZy๏{€ "]7™ฑ™Sศั๙ลธฤํe๋dCaP–––๚๏๒ฏ3hี๊–นฐrบกPA@™‚s ^(Zิฦ@k ด=4X)]ฦ๕๛ณAx<–——9ฮN5ำ๗#ฺ?ใ’๘|a?Sk)=็ˆฺุผHh@ฺูต๕œ็IฮฟุY‹.1 ด˜}ฅ>@สo๊ฦyทql›Zปz๕้*ๅ›~‡ฺูี๚ล"ถiใB…๕๒๕ิภใqC(ค๑จ˜ๅŽ๒7K๔`ฦ|>•฿์ฟ้B*ค2ๆXโธI•๑qฉsำ๓]f~๐8{qYLร0:๗ด*๙^G}Kuรๆ๓Yจ0ภจ๓-ีตž/w์6(ึ๐Aฅfž\๘<ฉiR#}Tฟลๅื9OภC9ขQ ฟท+ฐฟ3fx!เ‡ู 9 6Pe8Žะ€ใ8Y–€๑$gฃญด๚0Q฿_ย‹AืIฝ๔ขž’{Fu๖กRj™”ชฎิ0 1ฟฝ~zcนิใKธ ็…ด์ฯŸUอ`C๏>ศแัฑ9Z=sœถzผ6ญQฎw_'Q๎pPฮฌ์๏[ am๊rญ™๕ุจqŽr9p1๛‚ำ็ร2ภ€{‡,ธฦีƒ^ถMše@U4@/l)ัูจงxPัฮCmฺุจ’x7฿ฝงแ %t\ใ!sๅjWัc”h 8{ƒœ~ฏฤฏ_Ÿๅเšึ*คถ )ฤXœแฉ™d ฑY่๎็oe !0`%ใu/ีa๓๙ผฌ๎จ๊M“ํฝเลโฮ๊ฦ๗—v๑ฃaq99“้ย็;–์'kk'=ๆšwว /0๛œ[ฝaŸเ๑๎hTซึภธƒฅiณ'์C•JิZzk7'h€†ฎ๚_5%&!ŒFvk7ๅ*ฤN›sธฬe MฝทS ‰ขู้ถฑฌลwัฝcCั4 Š 8M:k2ำ1'†ณณB๋ๆ๙–ะ๔lr๊m{๎ิ†1d๙พD”ษํด*’๔ฟ๊I1q๚|`BŠ$1cฎ1Žๅ,ๆž[$๐K์ดMn฿K!ฺ˜Y˜๕]-sยIชbวฯ[,ถiqdHธ๋้ญŒวWห—Qขโ์ ๅ๒ป|๙ฺ–I’บnอ๊›œpŸป5K(8,,eจ ์ทbw7ฮก Mfโ\^งnษ0Œ’ฑ!{ฉŸฯ—`uฃ7๋-G dc(สไ yอfฏJ!ฤr…๊ป๖๗ะสฌ.Ÿณ’n่๎rฯษ3ผ0ร์.ท{ร!ยh?ธ’฿ๆฆ๕fษZq็฿Tญœ>ฐN%>.r†XหํŸถ@ืบ๓cฑR฿ผPJฉ y๙@x$ะ๙๔Tๅำi๛ิล(ƒ4ฉ–;l๋ ๐ูœgๆ็p๛l?W Fเฺก"Ÿ–&กuผบq&๑ู‚'๙๙[\ižฅvŽoฯมฦๆ : ๚‚์6kงพ้;”Ž ชฌึบ<5ๅŸ[๒_่l€uVงŒตฐN~ZšC“;M๐x”7“๙“!Šูซ์w๕9xBฝะส'วž้7ŸBHkฺ)bLฦลงSถไิยWฉฺIŠฟ>Hิ›ูT๕ใTฬนžชkุฆ=8ุวอกDP‡:…ิY%0ŠะB‘ุค…EJปr|SŸ๗วi/พuทฮ/,Eฯฯ5ย6„N้ค>๛๐u–ึลF~ฐ9œ’ฑ!Uผ๊0๙XŸOluxฐmณp˜ถ$g?EC๘ƒTฯ‰Dด๓aแŸn/fhR#ทฟwฺ๏๓๗ฟŒ’‹7 ถคญa†ู€้ {†|ศlพ๚จlii‰lฬ <[ˆ}^XK&ๆM ฺ๗ๆณง๔cฏ<ยท]็c๐R๒๙g <3_๕•ข@Y"๓o™๔h/:$€ษ3qซ|:':ฃQทฦงs ํQ„ฯ–[ิใํ_"๐0^X๏s~๑3‰๓1x)๙C่BนฤL|๚ฒธธธธธ๘iฮ#ๅ๘‘ฌ/n@~ฟห‚€ฑzบ?I๘Rxด๏ง @ < jq๛{๑`O็c๐R๒๙ง+ฉ_ฝทFD'ทฝZ4T๔ณํU่~ย—™?@ =14Y๊n.บ๑8ย—ูฟD @ …ฬ@ ย ๙@ @๒แ5แH|y`!†a@;ปถ‘2{cษจืฮRณ˜Ne๋2˜ณs“J.ฅถำต๕ษ€ล2๑๑cิ\ฺ฿aธ๐๛ล˜ฺธซแzHฺžNŽ;ฬ”. |ๆ0S•€OฦCN ญIM>}˜ญ+๘„F”๑ท์ัตใ&วโ_๒ๆz๎w๏๗ล–่/็Y(™ ฮดHี‡ฆ>pB็#gฤ’cฮฝ w๖/=ีลH€Cjง–Kๆ[บ=ถ๘>P฿๙~X3€๒ฮ~แฒซฟ^ะ๕NŒ#2•:8CฌๅRฉ|ซื'c๑/๓!ๆโs฿žj<<๑ว@ <G+=บ5š‚S se๛็ŽHู'ๆfcญีถ'd)oย‹ืqญdล0 ชไ<@ย … ฤยด|1ผPŠป?ส็'าฮฤ|จี๎ฬกD~ญEฺ>๙v.ฺ๘~X3ฦ"3a#ปตZ–543๗ฌ๏W4์ใฯl‰ž:Sฏ฿Qฒษ็7•3ฃำม„XๆฏA,๙ท1ฆ’a'ีฎฯLมฉWฺ๙น#"[dn.๊-ํ๐ดรe‡Z9œ V8B(O|ฦู฿8hQฎฤ™‰ๆฯL๏ƒ{;ู๕ตำ‘ฑMๆ„ื5ๆkทZชะ(”ค๗ดภ@Bˆ๓ฤfฦ๕์VฆA&„—ๅŒD,ฅt:mCSไ๓๑พ5ถืฒ๛bZถY๊่่อš`Dอ,€aตrอ<฿Q@เ+rุaƒJ8Žฑ๘—„rณฤโnNฉ๏๎๓"ะนฏฺ๊f^ktaŽNHk‘… ภRเncฤy’ณIงิฒ๛๛…ถ€Lž๘Tฬkg ฉY8:Y[^^หถๅๆ๒๒๒๒๒ๅ;Cณ?lฉ๎ฏฏ6ฌฑ 7ฺŸฒ5๖ืพฏสศ™ˆใ"ก@€>ZYู.›ฯCโJ๔:yQJถ๚Tฉ$\=p๊v“”:ฎู&ร่ไห@๛ใSvแ`๕฿๏ฟN๔๐๔„ฝgBฆเdHษฎญ|wด#ๆ~ํ๑Za๊๙นผทพvะฐล&\u็ืเJQ1_Zซยื:77๓0 kPึ๑ู…/฿พ-พŸ๒_ีฆึjบำลYœฑxQS)ฦฤ,cณS~‹,หว๕ m™xํืฏ‹Ÿๆงƒถ‘ ษ๐๊มywฉ|ธฑ๚sทdŸ`ฮvwrยK;y™@8‡๕วBฦ้q๓ํxEžo฿’ฬ--g1ษๅv2Mภจ5วfพ๓๕หBขH๗<ŽฃรŸ๐ ๔v]0,fิjUs9ใt™k•fฟว%>sZํศbตา0L&,V›\- ŠฎKีrฒZฯ{สN1[hฉ†ช z7$ฎDฏ“—คdปฯง๓ฅkkฃงฌีuMืฺ๕šข้ขP7dญ$h`ศ•Rตูุ^ ฉโๅก๚ˆฑ/วสธa๊๙lฎ.สRญาณ๙Z๊#g0%ฆ˜ฏ”รnœnฎX?lฺqyลI๕ํ๔{Zญฒ)Š2 q6‡รB†NQ=G๔ญ“ีต๕๕๕_;้†9–šF>ูฟDx๕`.2นc3ฆ-:ข๓‹q‰?ฺหึษ‡ิ„—ๅˆF-ฎpgƒngงš‘๎ ฉw–‹ˆฑ๘“ณำฐตWV@ไึ๘MšN฿;๎Iƒq๕u๗ สีชqAuูj|…>ใโC?ร0บใ„ะu!….†=ื๊SขWษหQ๒˜ฯง๒›ื7‡ ‘๚Bฆเ‚WŠึDแ*ไํ„คfž\๘<ฉiR#}TฟJWข฿ห|๏|Ž€•<Šbพz 0๊ล|K5@ญ็หป Š*@ซVทฬ…•ำ … >u&‡Aืu„V๛^`‚Hื{6x]•ฅ๓๑”/ทยV+ภƒฟ'๓ยkGUUŠฆQื•24ฃ**0žไl sด•VC&๊๛kBx1่:ฉ—^ํJ%แตbq99“้ย็;–์'kk'›ำกี๓bฟฟ*Vำไ2jงฺP.;”ซฌ็ข๊|C–eUEํŸPB๚๙`KชV•9—มฺ•ƒซ…> Kย†ต๋อ;ะV/ฆD๗Eฒy๎JFNฟWโื๏ฏ œ:†!ๆทืO๏|๋z;!.wV7พ๏>ไ๕r฿ฬ_ำศ\ษฃ(ๆ๋GUo.^กRj™”ช'ศื๏ฃส2p  วqฒ|iฅดีใตir]ิLพฉ—฿ษuฟฎีd’ฬฏฝูโ ต^){ะkjœถ@5า[UM3ภศ0tะษ๊ แEาสฌ.gบ?ูะปฯถณซcUน1;+œต๚†ค}“‰ฐตณ}"จ”ูํดŠ‚”#”๔Yฅํ“ๅ ๛ุzฆ ๕Nmถr”จะ.Ck๑็}vชU# 1ญR๚ฺ>E’kŒ๋H4mˆข‚‰ถษ๏ตrmสแqํRฯฏuญ>L‰^%/Eษ”ห๏n๓ู๛^แRท๕ ษy]ๆณผึP"J๖s‚ŽKˆBˆๅ8 ‰ฦตแโp`3O›ฬ,Uึๅu๊mฑพฮXษ#(ๆ_€ฌทโญQ่ะc!ฏน‘k˜ภhdท๐าพiTซษ๐ธฃškัฮฐU๖.๖ุYBำณQ+ิเ;ผŠA;~gฉำPi[ภkJฝฯi2 ผ&‰ฏ๏‚]ฃด4y~าˆ”?<6'฿|šd ฉษค*hฅฑR฿ผPJฉ qป„ืฒฌvปฟYkๅ์ฑ{z๖s˜AบาฉŸๆ; ๅาถไ๔งญKอโy“ ฦ9๙ห4ญ‹๕ณิๅ.VตสŽ‡ฺฉƒ๋๑iๅ“cฯ๔›O!ค5Žํ๑ ฝ*Ÿ>ฒOอ|gAj๖z^Ž/ัซไ…(™r๙]-่=dง*ŸNง.FคIตa[๏‘ศŸv>,C“นฝSๅ™๏”N๊“ฑ_gi]lไ๗๛~d๒W๒ร‹๙๊p%ฟอhxณไญธ๓oชV8L[’ณŸขŒ! Aชtgร2za๋ˆZ9}`J|\ไ ฑ–?ฝœ(ATYญ%žปฝr’v%’ฟฒ”& •ิaq“^d6›/XZZZ^^พำไ™ŒธU>ัจ[ใำน†F„D๘Bฌ}1žกB^Š๐ ฺ1๗ำีlถ"?ร|>nู๏€ตไง2๏G{มB(“'1๋ญn๎•ษN‹‡๒b”L๛|๖”~์•๛ิป Qž™ฏ๚สNQ ,‘๙ทL๚ฺ%zฟ็3ไแล$ B็็?^฿๑ด๊ค๚ฟD~ฟห‚€ฑzบ?ˆŸD๘ดฤBbvmํ๔๚ทk{คl๏|>[ ๙๙ฐม2ŽศT"่เ ฑ–Kฅ๒ญ็mํม…฿/ฦ์ืๅฝๅ พ/ฦธ5{l๑} พ๓ฐfๅ:รeW ำ๋?-”-8•œpYCiืrGฉBซ็Ya`Kd@ ŒNvf ๆP"‚ ฟVŠ"mŸ|;m|?=!Ky๛‡^ ธŽk%(†Uล5|ฮ™pฑื%rํ„‡เ฿ <ญโnœย่ณ†6YQฏ”].+`ฯ-Lx๒๕ข:่ใZq็ฟEภ‰คJ&%๋๋ใ†vfm='"ึ?=^ฉ๕พ๚๊!`3oL%รNช%ํ๓ุ@,Lหr_!VKxี๕Nๅžˆฒฅ๕•ผบ4mŒ๊†็_ษ็7•3ฃœ<ˆS8^๏1Œลฟ$oฒ6oๅ๓ูZศ#็s๐Kyโ3๎ฮฦA‹r%ฮL4fศฑฌทQŠป?ส็งžาฮฤ|จu>iผใํpูกึDงƒ‚u[=ˆลธสๆ๊YYยณ๓qeณ€ฟง๑Ql‰ฬฏŸ๎ชญำLฉz๑$“ซŠ:˜<๑ไคฯฮ๊R์(uึTแR8ฦ,้ด~vใI~HบตยFถ1l7ฉe›ฅŽn€ฌ FิฬB „ €8Olf\ฯne˜ŽฑyƒAห่”| !~€ั'เ_!hชขณšฆ€ฆ้šา  8–ฑ๘—๙ ํฬฯJ๋v ฅVo1Žxœั-.๓Jซส็*mืœวz#0ๅŒD,ฅt:mํ#ฤj +์™ะmฎV ฿&Zวซg^ul่g[้ภ&ผfตzดsP’ื6๑q2yโS1ฏ1คfแ่๐คกฐน…`ssใดƒlัoL™ตƒ๊k^ท5๛l)ีฑ^Ÿ๎^ฝAล:@ผๆ1qbู้็Iฮ&}œRอ์ํoผญธŠ๓Y[ศoๆs`oฐง]Xiศ@9WŠฮzฌ™V7*Œ32XY†กTIFํำŸ{ผ5%กไ,ฑธ›Sู๋ฝBpOใำบg‚-๒ึษศX`#+Œt๊๙‡14E>ฏkฮฮ~๒H…ฌ:>๗fฌ~ดศr๊``๔ู้l๏prv๑4 Mศl๏W๔กวาLฏ,งa,%๛_ฤ:–NซXu‰อผึช๐ภนnถŒOz…ฬฯ&;WˆีVุ+ก;ศgฟ–ฯ˜เ/Žย๗+าžชฃNzgk%ใš4แ3—NE\ฤวI๛โSถฦ๖ฺN›rฦ฿อD+G PŠ้ำภ๛ธŸO1๑@'ณช'VฟŸ*ํ }B` F๓ƒวูซ6อ๙hoิ<๑vfยล\ฝป็sถไs0nฐŒ‰Y6ฦ&fr๖X–9;€๓™‚“!%ปบRั-s1%ตวw‹d ่ฝญ•”)๒~~ย]ฏ€$<ฎ-พ —~๒og]–ฌ๐*6Rฎpถ./๛ปc€Zซ!—‹+ัฑ^79Ÿฎร#dืwฯ2V ง๖œอaKC@ๆ„ฟ„Že@lื๒ฉZWdฑฺไZFะดJฉ>=ncAP,V›Rอชะi‹ืFยมฎlี•พC‘ึษฦ๊D[ษูDฐvพ‘’ฬ}Kบ๔6ธsิ4ค๒แF™ฒฆฆ'ไ์๎Nmˆpี'ึ—ˆ[ซ{ฟ$d %ง&„Lwกmฐว‡ย]๘'ˆ2:gป;ฺ˜yึ งeB…X-๕Tc 7J|G-ฆ Gฤ>jฑฺไjFPt€jนNEฌ4d1Ÿ.฿ผ3”“อาะ๋ร/ ปฯง๓๗™ฦ`4?Lœx$>›ซ‹bฅ7^๎= ฮ?j!ษ็CภดMŠข ร@œอแ iCิ)ช็y7ช(i็๏ocท[ ุ}™ิ)f -@ญ บำฤ@ณVื5—ึฎือง!๖Exฺ๐Šฺyอa๛bœ[๊5zย๏ฅตZVพจ๙P&‡/เ๗zVฅpP่๕๎e[‚๓‡ฅฅฅฤJ < บCฉส˜c‰๗ใ&]lTrววฅŽ!SpnมซEkข€!dุq’ฺฎ๒๗๖)บ*K็๛aฅ|นถZ$ญธณ\DŒลŸœ†ญฝฒ‚L๎ุL„)d‹Ž่b\โ๖ฒu๒!๕ ั'.ํ๒น;ลFวฮสŽŒP๘๑แhgืึs"Pœ'9vb็ึพQ2Pๆ)G4jแ๗v%ถฟซ%กง๊)ฟ ฿6ฑ\oฐ†aP่<ค! าxTฬ๒/ๆCศ฿dฬ็S๙อึ†u€7\h~๐8{qฝ:บชธ‡ฤyษฐ‘ไsxฐmSืu„V๛^`‚Hื{ฯแฅfž\๘<ฉiR#}tีVซฏdžะไp;;ีฬEmโ๚b็ึ4€Vญn™ +ง |ขด3~ฦ%๑๙ย~ฆึRzฟ๘ฦ–็๖\€Jxถ 0นUU•ฆ้๎ošฆTUะZ…ิV!…‹3<5“ 46 ฒab~{๔ฦ|.:tราทฆ5+ ฉw5๙ฆ\~'ื: ะVฏ‡i๒  ตSm( —๊(9่mฅีะ‡‰๚š^ บN๊ฅ—ผ ๕Oำgนz_ฏMk”๋7Gˆขภธ่? 0( ๕}|่rญ™๕ุ(่<ยฆม3oq99“้ย็;–์'kFธฉ`ด„UŸ6{…ผึ`ฏFŠ”#ค„Žk er;ญŠิg’๙ ฮ|+ณบ|ฮJบก๓ปหk'ฌซ%ผุ๊ถู+คษๅต3ลน<ฃ–u"แฎงท๖s0๓ณฝ~๙P.ฟปอ_%IRืƒY}“๎so…u€ƒว9ดษฬ"@œห๋ิ-y$qๅ‘,dไ๙l„Fตj Œ;Xš6{ย>Tฉ๔zN!ฤr…Bฏ๛-COธ1;+ด.Oย๖ล}šัศnํๆ_ึทำภ0ŒัmาทนnKCฅ?‚8„็‚^อ:ง“Ÿพฒ†ุ8;์ีญ-‰อMZXคด+ว)^•OงํSoฃ าคZ๎ฐญ€ยgsž™wŸรํณ\5นŒW[’สi7พ‰ธ›xๅ$ํJ$?~e)M*ฉรข ๅ์ฑ{z๖s˜AบาฉŸๆ; uŠฤJA|๓๖K@)ฅ2๘>ฝsบ๑ฟำปโฟDˆAร๊@้ขสj-๑B“อำรโTlหc(ํZๆจ A๊œหฃW>-M^œ๑`ด4 †&wšแqsจ8ฆGู]ษos๎P๑อ’ดโฮฟื7น฿VKXแ๊ฅบป`fฏG๖ฉ™Oใ,HอยAภJล“ต†ฎ้b`vาU9ฌฝส…Yสๅwต๘ฃ๋ร]น˜ษนg}u ฉณJ`z8ภมใดว฿‡บ[็–ขะฮ\ฯ‰ฺุ์”N๊“ฑ_gi]lไ๗›=ใฤ๒ิ2๚|โธiๅ๔u*๑q‘3ฤZnด็›"ฺ๙ฐ๐Oทร24ฉ‘฿;ํ๗๙๛kูmึNป}ู‰โ๛bœ[ปนผ€^ุ./”n้๊ —๒r๗;;ฝแภถ4T๒fณ๙๒ฅฅ%ฒ‰๐l!๖Ix`-™˜7a(h฿›ฯžาฝ๒฿vฝ”8ƒ—’ฯปPž™ฏ๚สNQ ,‘๙ทL๚G๚‘–1^Lžษˆ[ๅำ9ับ5>khWย๋'3๖yฏ๐ูrซ“"๛—@xY0^XฏŽtฐ๛Rโ| ^J>1่BนฤL|๚ฒธธธธธ๘iฮ#ๅxrั่กmnฟ฿eAภX=ื…ƒ‡ผW๘R ๛—@xYจลํ๏ลฟ4ฮวเฅไ‡\IชŒ๐0:นํีขกช Ÿmฏ๒F๗t–Kแเ!๏พศ@ @่‰กษRwsัๅ๋ยมC'|)K@ aPศ@ @ ™?@ „A!฿?ย_cฮฝ w๖wx~s5e๖ฦ’QฏCjง–Kๆ[:mO'วfJ—>s˜ฉสภŒ'ใ!ง…ึค&Ÿ>ฬึ{œ”o™๘8?vถถร+€ฦb 3Lzํ•ม๐,`ƒ๓m'?R๕`ง=๖y>ฤBbvmํ๔๚})ๆะ‡ˆ|๔sฟิ๊s,%!oฎ๗ผ๑๛1๒ู?!๓ห6EสœJNธ,ŒกดkนฃTก๕xวCY&>พe^ษฉฏ\๘bฬ~Mะฝใม์ฑล๗๚ฮ๗รš”w๖๋ —]5ิuOสภ22b.neี๘ํ๏ฉฦƒS'๓@๘0ฆ’a'ีฎ๗ŽฆเTŒ+ํ‘-27๕–vxีJDPแืJQคํ“o็ข๏‡5c,26ฒ[ซe YC33qฯ๚~;๋œฅห้๎ญ\–pืษฌฟ˜Kฤไ๓›ส™ัสฏล)ฏ๗ฦโ_’ทI•LJึƒ๓๙ผ'ก—mŠl ใ*›ซgd ฯฮว•อย\ŽQŠป?ส็Gกาฮฤ|จีœ .;ิšศแtPะk๒๛,สB:ู๕›๓Cๆ๐7 ดชqฎาvอyฌ2jฬao๒›mš™ฯลZถY๊่่อš`Dอ,€aตrอ<฿Q@เ+rุaƒ ~ Kod3ยงุธญ#Eรฺ้ฏ’€Lž๘Tฬkg ฉY8:ฏ&k$lฏe๗E็มtAPœ. 4็˜(Œt|่ a!ม๏TU5™L.q@๘ห0™LŠ๒$ซˆZซยื:7G? ร”u|vแหทo‹๏ง๛‹ฤJ6฿ะ1v‡MZ €*ษบอๅb™\N ห๖Y}Rห™S5๔f>สŽ q)ํ‹Oู๛k฿W~edLฤq–r8้ณญ•ีTว5๎3€)8Rฒk+฿]?ํˆน_d๒ะซ฿O•JBŸฆ`|ยศoX๙น“mpN;}๑w4?xœอ๔ส๒๒๒fถ!›!syo}ํ a‹Mธฎ_†u#Nฅ˜>5ยq?g ลฬqUƒ‘Yศญฬฟ`Sฒ๋ปEซ…SีพnใNๆฑลฤ 'kหหkูถœ฿\^^^^~แ“‡๋PฎprUz{ฐฯy>คฑt lฅJฏ‚Jฑ%11อ๛๚๒น7^ฃฦ„XAXzพ๛~ภ‚2 ‹`,wŸt˜3็ฬู้;;#ี๋ŠำE[œฎั|ทcำdฌb‰ฌml|๚๙ใปล m*Ÿ>฿้†‰ลbํ๖ฐ–รภภภภเX,–d2Y.—Ÿฺ0ภv๕็มฮ 1]Y‰๙๋ฟJ"XHธ”.s’:mฉP??mญ,}๙K•„ำไš.W.wโXพฤ^๕ศซMจeขPซ4๐จ•†ฆ 4ห +ด›…ภ@โxูreiท[ ๔bถ#y์>Ÿยคบร#aIS$pz!]ฟ ๐8iขแ™\พมpี&ฬ™)A#Mฎ)Wฌชโ๙A๏ฅภ”Jศ ๑/น(โ&‡/เ๗zVฑx\:ฌ0™MอผฟJwภห1ปฝา jต`|ฃND^Bฎ็” ๓้ฌ}:KH็|็Œฐ๘ห๑`} _y™?ไrนนนน••Šข&Mุภเุ|j Ž$Iๅr๙์์์ฉ นAตQ*t$คFกยฎmPชศฅิV #-ฤ๒"<ฌˆภ1วปLšภUY!‚ogร’ลัYบี"ยณ3ฅLK ริ๋ฯ๗TUล1์ž_๘๕ใ๊ฏVืžX4/ห|3sฺ˜v–_3>Ÿฤ ฿tมำY๓B|mึคpอj์ฌฬ]eฝ๕ผ๎4ต่ฤX฿#LSm‹์—cฎ‡1S)!ƒŠ^nQ$œฑต%ฯŠGูzGิ๙ํ๔๑ศlŽฬ๛ksธl-{3Nึjม:๕†e5,^์‹x๐i,} ๚Kˆ" ี‡J|กา [ญำ?(Šrvv๖œ๚6ƒGC’๎~ชช*a๕zศำ@•ุZSŒป์PฉQvŸ o0ฝฝโ%‰ฺ฿อbถHส์žัห๋ กโŒ!%„ฐzผ6นYip €ษ—Œำ…Tพ๊”ดqƒมฅี่8!‰ใ&gศknถ:`๕ล‚v ฬnง•ใ8ภกD,์ pยไ๛จFณฃ•จ9๒็ูบ,–2—๘์‚Žํš\^;‰ใดหใPป]ญ!,ŽaMใ†ฝ๊ตั)€ป๎.S้๓ฬ๓ผู้ถQ”ี7q_ํฯฐ„ฑ€รBแช$ ใ=˜ๆX&3…FปผNฅ4ำฤฌ‘ธป‘๙y”‡ูoฟรไ%dPัK.Š$Iชฝ๖0ูิฬปศ๓ไŒk†ฆh‹™zžฑSํฮm3ฅ‚ฉอฯ฿…—๕ํ4 +!–ะโr"๙&ๆฝโ‹*แ๐๛4Žแ”=เตถšญ๗8๚ง†มณว•ุX ๔•+›~Kฉา๕โIฦ’X8Gช|›9N—%จไฮ‹หŸย$ฆˆlใโคภ_8อุ‹C„ยทJวi๔แญt 6‹]๔>๋๋ 9็ชฆ๋Lๆิž\๚8K฿*k๎ร1์๛๕ฟข ส|3txั6F €ปฎsฺ?,Jูผ{้ํง[L_Vณ ถ;XtauBabทz–f†LiฺcŸืB4ฌoฮ]ฮssภวอy่œํ์_๒l๙ผ1ฟ๐๋2กpอยัIK3Ms(ไฮw›Šุฮ”หฝVฅIKศ€ข^1ภซ››{—่้OM'ห•๓3ฯโสว&7ฯ~ค^ม7G˜feปู๒่ {ao`4Kˆศถ9‰’;U๎•๊yฦO|๘JแฒะฎฆOJำ๘่3›อฃc<&›››[[[Omลำƒ{–พฉ’ €[ข๏™WrญีT!|+Ÿ<ๅ+SผS์EคฉUB˜ข)%o๐ย0yๆฃn‰ษไ9็œ[f2๙ฆ(ฯ–{”๑มภภภภเน ด+ๅู…_ขฝูชิฮŸLใ]๛kƒ๔๚g๊…ฃฉ^H2าิ(!L‘มยๆ๖๛ล๖Y^ฒzz4'๐ฅ`ผ0000xzŒ๗ฯŒ iR•xQนC~œภg‹๑มภภภภภภภภภ@/ช,๐ฝัอ๘R0ฮ_20000000000ะ‹100000000000ะ‹100000000000ะห”พภlแ•„๋ไำี๑O–ตD>ผกN~2iŸ[}f>ฉ]ฬฬ&b!ง…๙“9ษ5Dภmมd"โฒชุญ็Oำลฮฐณาฤอ…ฤœืNc[ฯงO ภไ/ฮym4ฎส|ซ˜9>o ป๏e อ๑b๊7๘O2i=z^ฬฤพฤ…ƒฝ<7ล˜ค#šŒดสี๓้tก๓า๖œ๊kํา-าKใบฮ๙๐.ิ>IืฆzขA?OใdG๋ กชชฤทซ็งgev|ํๆะป๗Qแ๔๛Q๙แwคi›ทภํ๏_นฤ€ฐฯ&a——:็ฉƒหฎฤํ Ÿ…hภ0.ทป{1ฅKวPus&๖ๅ]ˆผพ!Zf~}Kฟ รyศfMsฐwฏฉด/|^ 4R฿N๊*เๅฏKtn็วฐr๓ฬะ฿&?Bว7ฅ๙รŒ?(ๅ๗RS๔Cาgชๆค๗อd"์ฤ;ํ~ฅ3ัฅฐš๛นSแ1khi)ๆู;ชสT`aฎ์\ฒ˜%ผ.ๆฏั7้ ำ4“ t9๕=ลaถ่๊๊œทœb$k`ฮห็vUD0‡Wื#žBCใถydš๚c๊70xัถ€Ÿช๊ฝw(ธ'ถไf๖;ธ+f)า๚ž็DF‹7l้ซำŒ‡๕ท ศvI †๔า๘ฎใส™tWj“‡วไษœอ๎๎ๅส๎Oฌฌฮ๓ป™ฑMเซูด 4ง>yะ๎ŽฬQๅฝํ86žๅํณมL์Kbzๆ ๋&ฐนฝฉMQ^)Hื!{Zƒ(ยแฒCฝ…9œ๔ฌA=๔ทษv|hฆ4hfพ๗ๆลชช(ฝู๒L์K\<ฮ[bnZjไŠ]LžXbgงพqyšพlI`ฎˆZm†ฎฎทิฏ[์ิ˜ณ|ต๋Z๕Xฏร(ซ•nV€6SยT›&Šl0LGR:ี&4›ะcTš๘Œรbบดฒ๛๔BeIT(YV@–Y”4["Tšcฤิ/n0e{x11๋4ใ(g๓5N!ซ_๕ƒ‚ึน๕U"oฆ….๓˜ูKฬyํ4ˆj๎ไดฬฉ#U๖Aนๆ—b; |ซ˜9๎ฝH๋_nฟ^i#ะ๕3ybษฏT๙V๑๔ไผฉ5*'ซ ื๕ “๚๛คจ @…~ฒ•ี`k–jงฉใ2๚ 7{ข‰yทtyTพ มhOb9แฃลZ๖๐จ4ฌ#Œ‰ฒำแ๑t‹MAจไหsหkถƒ^zD>MQ$bซ๏}ฅำฬeS๋9N-ช]ฃCzIฟ๋๚หR7๛ฝึ•%™๐ญ| 6พ_ีฃ๙ซุ๑ฟgmd™7ธว๓pฒ"ถ‹นRhีcอดฺˆฆ’ ฟ{Gํdฝ่˜giร[๙๛Hผพพบ›^ํ\ฉFทŸค3บ X)’ฤ%^ภบ฿ฅำ^c5Cƒภ+„rูุ฿‚ัแตฯ v๗๚ฦ<\]žญปฅ}Œ๑nญ{‘>+ูO๚[TปD๋nมH”—ฎป)KŽ๘ืุu ช$หตZ3แนชG.'Q;kkฤ4ธฯ๓q2/ดƒdS)tY"`ย”\ q'eอฑ,›ูสภL์KnRƒ5ฮœ‰นํชb‰ฌ.ˆiอษXยN}OuTsp๙ฝ:p .l]’ม7_ลU‡น๎]€%ฒถ1ซชฒฤ6/3ฺ;ฎตผ4เOฐ›๘๏g๕ฯ+แ๒๗ๆอฒห’kO<|BะฎC๖4QRฝŽน\t™pพจ˜o IDATp†ษ๙‡ํŸdC|˜๚cŽฅาทธ=Dๅ๐ @฿ฌGื#ถ”+v$ฉัVœ&€ทXmB=–ไjนฑ8kฃ kKjดตฒ๔ๅ/UZL“โฺR“ร๐{ฝnซX<.Ž๗ฆ aW์œ3ั••˜ฟซ$RพxฬZ;qฬcึP"i๏g_๔d†‘4Eืญา๕^Tซต็]NŒฉN—น~y=`,๓fซUจ5 ]8=v6–๎ff๗'&ห @ฝลฦํ๔˜ฆ[ฌ6ก–m‹ @ญาภฃVšC?Oข<๑๘Lxฏ._‹#+ฌา,3ฌ ะnvˆขป˜ƒซoลั~ฉ{gxภ3น|ƒเชM˜3SšiขcทวqUU1ฺๆp„ส)8>์‰มง w™ำƒบ#[|๏ศ8ฎ>อ‹แ ฺ%-าKในndI–kต๖‚ำ‰1Uยๅ4ี -อ˜zx'[#ึ"ทฬ63;ฉ’Fไมฆ’e9M[(;eกmTำDณญ!๎`“8^ถ\%Nฺํ(iญ[ฌ6ฑ–mK*ฝ^ะ?ไxฺR‡ฌ›๓K 0ยโO,วƒuญ๙Z^๐'ด๊ EvษF]”}2Fื!=?ฎƒq{|ฃND^Bฎ็”เKš?่o“'mฝั™?เ8>??๏๓๙Hr๔ผข:E% +Eม ฌœปิจท๔ส(†aฆเ๊บWœน๖จขปนน9R;Ž9eาฎส |;๋ œฑต%ฯŠGูzGwทฆ jฃT่H*HB…]ท ิr๙l้จษชe%๒ม๏ศถc&<1Z^2x0}Œ/ฆณๆ…๘ฺฌIแšีูY™U„Z‹บf NนluฆูWิoธ)๓๊อpฺ฿uoยZŒฌธขi‚ฑ‹VฟvUUqฌฏฦ๕kฟาHyใq{ๅhฏ!฿ˆฏฐ|แืฑidSUUร1์~๚iช?ๆตคข`&WฟUศ vฝR+ั?๎ฅˆa8 ๕K๋ฉ†’$UซีL&ฃ(นa@ตKฌ๎ฌƒ๒’2ž๋mB–dฑVcฃฮจำN[ฃPตc่เœฬ๏U๚Kฟ"jอ˜QMฅภฒคหj1 • aต™(…e‡•›มวทบ๖ฤ๚งyYๆ›™ำ!†๖7A:‡O[๊PuณฎHๅkพP้„ญึซ%ŒAดผค‚ฝฎoฐืฉ7,ซa๑b_ฤƒฦ่้ ฟMžด๕Fsgž077g6›๗๗๗y~ฤฟ๛=%ว`tจSU•+ฺป˜ ช ‚F๙œ*่่ง)ปฯ…7˜ฆEIข€ปรA!ปB|฿LX=^›ฌ4†|)IwๅTUภpผg๛U&p&zา7ฆ6#'T๚นWภไN1ณ˜ฦH‹3œ\JšE€ฏีฤU—Aู›ีใ!NUUธฮbE‚$ส}UwD๑ฆ !9๗{MVฉะO๖›Toำ์ฏ6๕่Ž๖ม๕ฎvส—ˆY+GวMนO]a‡gs”ขl_J่†bษ5_#—ฮUsม0L S i@šฆaฬค-ธ˜ตดฮ๗๖๎fŠ‘ีะd2-..ฮออญX?ศvI †๔า„ฎำ*ษBต&ผuฺk๔Lซvข ‹i0’วpฒ*๑๐Wl4M ‚€n*YV :ญDทา ฃ.;ฮตวzํObฮฺท฿ˆMK๗๛Mี*๊nมฦliง ฒnš|ษ8]Hๅ;ื†hŠ๑าซ้บ!ƒ=ดซๅŽIฌqเ}‹!m๒ฝฺ1Žo;๏0ผ^๏ูููศษรpl—vธฬ8n %Wfํื๚Ež'g\34E[ฬำxŸ†;B‰XุAแ„ษ๖Qf€$IUPๅษZ\N$฿ฤผร^้(ญFวูH79C^sณีบ]qฦใ5แ€VŸฺํฒใค9fLƒงภJฤ …ซRฏ๘\ ถุZMuFCŽNต1lวฑ]“7Cแa ,ญ/๛ฦฺ3ˆaA˜ŠS3งIกLfว€็yณำmฃ(ซo>โ&nฃิ#Žํš\^;‰ใดหใPป]ํ=Eด?ณ”OฒอพhVXd6u*า@jŽ๗](•๗+a•"ยdฆ0ภh—ืฉt;ราิณYซYณŠ ฬžฐซVวJ:็พO:บ™?2๗'zเy๘๘ุ๏๗-9ศviŒ ้ฅษ\‡.ษภืjŠ+ttkฝ=sฺ1 F๑็ŒS๖เผ๏dSษณํrสNง n7ฐฑVษp ฃhวฐwŠ&ฯqฝVัโ™›u]ตŠบ[ฐ1[ฺ)ƒฌ›ขJ8~'c8exญํถึ‰9ฺ^z ]ง=ุCฃ6s?^ึทำCฺไฺ1aว‡ๆฮX†ฆi–}TJL&cOพ๙ฉีจูP7}P$&sjO.}œฅ€oŽตฟi&\^7i†w…nฮ_าฌฐจl๊T4 •ฏ็R๛Ÿ&ถ|˜_xu™Pธfแ่D๛t1ๅJๆุšŒ๘Lซ\=t1ๆv$!^Qใ'ุ|ฤ๓ผž ขH๔ท จv‰ื‚!ฝ๔ืaุอห ’ฬtk52:+dNฏทjhฦ4@๑TNถฮœWDฎ]อฅฒ-ดšJ–‹ํศผศ&šๅ wณ7็ฏO@Bภ1์๛๕ฟข ส|3txั–ัoŠL.๏Yz๛)ฝ<สื‚=-ุ-ญ=๖y-ิ๛–`}sn์#ั๊QuณzžqลพRธ,ดซ้“’ึฒฺKš๔R@นŽF๖Mๅ/yฐถหKณMจv|h0ณ๙๖หจออM`๔วœคข?ฆฅ`8dบ่๐'†a€›<๑eoํเฐ๒ะืฦO[ผZ<]&l?_‘C0ฺbม$‰pฮญ$๐ณŽชฦ‘ำ็?แdณ๔5ะุN•d}๗†ฬผ–๛1ง†แฅ?ƒษ3uKL&ฯ9็ๆ2“ษ7ๅMYฏx๓%l>ปืIM๏Vƒ„w๙Kย!vJ™ฃO ^)ด'๖v+|›9>y•ใฺgภยษJปRž]๘๘%ฺ๛ขI•ฺ๙“ฉฌœพ* /›๏gyษ๊้ัุิ-o7ๆใ#—]อภเฟ_๘๕ญ๐ิFผvNช้ีััใ^๚#ฐ๙_;%U’@นตรจฝท‡๊‰๓MTYเ{ nจ_๒ภ๏ ฦkมภภภภเตqฏ“2Ž 50000000000ะหำอ๐™p<qำ@ปฃ๑xxๆฎ-ศ@คธ~EH&T4B|zŠฆfาkqศs๑งม‰a฿?เถ`2qYHU์ึ๓ง้bGฑ/|^ 4R฿N๊*เๅฏKtn็วรๆฦญ๎`‹5ด{ƒAฑ›ปl๕อŒ DŠ๋W„}BE#ฤงงhj&ฝ‡<NŠ#uื8| ์ Ÿ…hภ0.ทป{1ั=.ำ2ษ`ส๖๐bbึaฦพอdOฒ7%–ดฯญพ ณGŸิ๎X">ฬ™หฟ>ฉ]บO^฿อ-3ฟพฅ›่˜hEˆeค3๑5าูYผพ่ฤ๙ฐŒํฃŠไL์K\8ะu|>n๑-ฤฃIl๒๔ดะwฐ%๒แ u๚เs-'Dจเปถ๓ำ)žยt›ฆvรbฝ{Nฟ•{ŸŽzš๗์$์ณษDุeฦฅฮy๊เฒ‹LsLiŽหฐsDๅขรkŸ๚oฟนฑส tปD:ขษxะAซ\=ŸN:2เf๏Bbฮkง1‰ญ็ำ'…ฉŽiŸm2ฺ!2d@่๊มฮ%‹Yยห๏b๊A€pธ์Poaง‡‡฿š"—Ov› rภ]ฆvห อ2)ฎ_’ Ÿžขฉ™๔Z๒\๙\hŸํ๏ fb_Om‰ม#aลฃX๑วv‰#์๓oV็š฿N๊ช9L„xง=ุ็Q…0!๔ฯŠูrny/&RชG@]†ศ๓ฌ˜ฒปว5yR;'UนZฒxฝje†ํ๕‘v‘#ัฅXภJ‘$.๑ึฝ๘~ศX%ูหฯeO„*0ึ๙่Lใx?ื~ัท‡ %‡วำ-n7 ’/ฯ-{ฌู7ใฐท˜ƒฎญ์?ื LkL๛่m“P™x::dOw;ท๗๛๊พtาjก%ฉg–Tฏ+Nmq:ธFs‚bGV76Gฌ`พ฿ุX ห ‘โ๚!™Pั๑้)ššIฏล!ฯลŸ๐ว๖๖๑๗ู๙]dฏชแ‹%mอฃo?ฒ‚)๊บ,a2แMฎฟ‹ุ6ัkเ,q๙s{๛WลผqcšŠำpDฮึษ๎ทํผH„ํฺ&<+ธjฎะ”#ํ›๎ˆ wชL|;f™๗ถณ็ญ;าYุ๘๚๕๓วw‹AฎฉHฃG@แy…ฆqซี$ƒอfขhŠ็yยKฺว;|๛qฎ„#ื3ฬนrธท{ด-D\Z%™$)E’ฏ-ฌŸnผไ5Š7 jG๗|wkk7ื [[[[[ฝถ–I:ลŸVฟ/—Cb˜‚ฑˆZ๘๙๏๖๗TฎI;ํฤ๕ธรI\IณฎYŸนObtšญฬ๖ึึึAแ~ะ~ši —?ถถพ6ิสแึึึึVoซคVšƒvข:Md K™ 5๓ำฆP,ภfฯj๒t์œ€ก• w…CX1_ำ~กb ฮ‡ฤ๎๖ท๖.X.ใ้e ีMุM|๚ฌn›c็' x\–)fใ)@นŽ4ั ๊Ld9้ท‚@ำ4IR*n]^ฒฑ๑y-้ท\ฯiiŸฝm2ฺ!3|L„›พ€฿๋u[ลโq‘ฐ฿จฟ—๋9%่|ฐf•oื๋'€ฬ6๋u™ฟ๛เHqŠLจh„๘๔Mอคืโ็โฯ‡`ฑฺฤZถ-ฉl—Sn…Zถ-*ตJZihฒ,gขi eง,ดjšhถีซ‡l)W์HRฃญ8M4zƒ*Mก™ู‰ษฒPoฑq;ญm’มณƒฌn$\J—9Iถดห$ๅ_ฉ๛ B7a๓K 0ยโO,วƒ๕—<2ฆ–ข‰ภ๓eฑูD†กl6O ภfต ๕l[ซๅฦโฌ‚ถ<“ห78ฎฺ„‹dขw&ชา+ ศโ cี”I:ลŸvŸOaR#V1Œค)ธnฝฎ฿+อ2รสํfG!๚ึuฅ‰F๓iNๆ Znย2ฅเส›UUฝ\Gใธชชms8BๅวaW์œ3ั••˜ฟซ0ต1ํำ ฏMฦ‘™”!๓ย[[r๑Lกx”ญwฤEงฐฌ†ล‹}>\ณ\ฯฆฎZ2พ|šธฬˆืฏษ„ŠFˆOOัิLz-yฤq|~~็๓‘ไ่ื}'cฆช๗ชชโภณ,้ฒZLBฅBXm&Jaฏ_ Hซ0ค@ฅ „=ดXqEา!&]ฑนน92w๗$ฉZญf2E™ๆlL.ฅถJi๑'–แ็a9lยssๆ๐7@†*’ภ_ํโ •Nุj‘1‘Š4{„๛ผ@9\6ขSlะษ‡ |Uภ0ฬ\]๗*€2ืพ*ถๅร4ห2ฒh"‹๗ุฃjา$โฯŸOb†oบเ‹้ฌy!พ6kRธf5vVพ๗~‘/๚1fšZh=อIาผแฦNอ7€V Qล"?;วๅ˜ปsรฉุ๙†T.ฬแvฒต์๐9,฿ฺ๊๋Ÿๆe™ofN7แ/ง$?”๋Eม0Lฎ~ซALQTPAm” IฉQจฐ๋v”$€iiŸm2ฺ!“ข=่มแ N•๎ „AปZ๎˜ฤ 4๎…ๅQNง์Oฦ}Rแ๐ฮkDd R\ฟ"ไ๏*!>=ES3้ต8ไ9๘snnฮl6๏๏๏๓-w‡เ*จp“Žyิภซneฅ ำJt+ :๊ฒใ\{ผจ4iBHฮ}^“U*๔๖“}ˆIทW›‹ษdZ\\œ››;;;›NŠ„ี๋![LSUbkM1๎ฒCฅ†Šiq9i“iํยW;6ํ็ป)n6NR๙gsWใ dฬU๋ ข†V0€*๐ชmแ.ุถIŽxอb…UUนยฏฝ อŒa˜ข5ƒI’p’ภฎD๎ไฦlg๗ €ฌ2ฺvz๗=ฦH“†‹?=˜ำ๏ๅ™ฝถU‹ๅN1ณ˜ฦH‹3œ\JšEํC้i>ศดง9ฅ4oะเดJ๎๑6๋š ™ซท›ัฆmงn4‡[`s:ไFahV้@ฬY๖๛นŸ๑๑ ]' ะ4 Mำ‚ภHา]๏†)i>๖๛ำKา๊‹/ํ$@˜N+วi *:ูญ+ถ3M…๙ฝต{ฮŠ*แ๐๛4Žแ”=เตถ˜HECz„มฌ v;ึ้จRปMอXy^Žํา—ภญกไสฌช๓!Lf ŒvyJทฃ5ฎUฺอ๖L0lงpœดƒnฉี4ชŒ&"ฯ“3ฎšข-f b’N๑'w๙]ฆฯ๓ฝZl๕อGWตุJฤ …ซR๏›e ฆ9ศง9ašƒ่p่‚Y#qw#๓๓(ณ ›oSทS7C*=cงฺแgๅเFั4ŽaC^เฝVะฎkึjึภฌƒ"ณ'์รชี.€าjtฤq“3ไ57[7^ส˜๖ฯฃ]l,กลๅD๒Mฬ{]3P™\ฟ๖Oเีอฮฏrธu$‹1AY•ŠฟWU€nn๏็po้ˆืฏษ„ŠFˆOOัิLz-yคišeะ๊ˆL.๏Yz๛)ฝ<สื‚ัžLๆิž\๚8K฿*๗N?aYฐุูŽฬ‹aขYํe({์๓Zจทรu}s๎๊ˆTš<“+zŸ6bb๋2:๕ฏฌญยม%ส$ƒ‰เy^ฯฦ6ฝศ•™{q๙S˜ฤ‘m\œ๔:/ลNJปR&#ฟ|๙๓็ฯW=|ž1๎Vœ>7#า๊น พ"cŽ |)<๛ (‰I‚ ซAำค*๑bผ ˆืฏ๙๓„ŠF‰OMั๔Lz%y4? วx````๐ ธ (}C‚แรWdฬ‘ฯ–{ิ4๏ฤYไฏฅส?เ3d R\ฟ"$*%>5Eำ3้•8ไู๘ำภภภภภภเ5s;่Œพ"cŽ |)<%ƒ/zi๙Eo``````0]Œ๙ƒ^žn€ฯ„ใ๑ˆ›ฺวร3wmA"ล๕+B2กขโำS45“^‹Cž‹? tA˜LOธ[๒qม)eƒ OืฃใVw0H‰ล‹š@ฺฝม ุอ]ถ๚ฮ>@"ล๕+B>กขโำS45“^‹Cž‹?a/&ff\แL๖$ซm$n &—…Tลn=š.v”1ฤ๑ฏ1ว^žภํ๓kหฆ‹ฃHๆะป๗Qแ๔๛ัี!ุŽ๘ืทABUA•๙v9{’ฉ=าœ พ๛`;7xภฝ๗ด;ถwตŽwฯš*:G3ฑ/๏Bไ๕2๓๋[Z๋,“7พ8็ตัธ*๓ญbๆ๘ผกqง™ผฯฤพฤ…ƒฝxw{฿B8ๆืๆ‰โัQพ๘;XI๛๊0{๔๗ImH าKธูป˜๓ฺiLb๋๙๔Iกฃะแตฯ ๖พไ{'ˆk:ฉ}2,‘oจำพใ&'~บ+ื+a’บ9:Mํวqฟ=–ฯข„่qศ#a‰|๘0g.žbฅ{ๅh4kˆะพ๐y-ะH};ฉซ€{—ฟ.ัน_็๑็ ัd<่ UฎžOง ํHLส'Oโศๅ“&ˆp—ฉ2wณƒ DŠ๋W„dBE#ฤงงhj&ฝ‡<‚ัท ญ*’คqค“9bล%ŽฐฯฟYk~;ฉฃcR…บzฐsษb–๐๒ป˜ฟzP๕‹฿@บใK๎ฦ๑›หU๙j6-(อŽฟ›หsๅŠญ-ฮVซง#x“ฯoชd2@มฌัี„นxฐ[์eƒฬฐนฝ‹ัw๑Ys^>ท๛ซ"‚9ผบ๑ฅฃ=yŸฑrดวฯฝ]Y๖SๅGฌšษDุ‰wฺจ@ค—Lมไ]N}Oq˜-บบ:็-งฑ๔๛฿สี™„3.ิ้j‰#=CP;^6ฏ›ฆ9f=z ;ฤCJศำOย„๐ฺ็ภำฌก@ยแฒCฝ…9œุฌpเžุ’›=ฺ?๎เฎ๘›ฅH๋{Vใเ^1วเ้ๆช" (*(ฒ(จฝ?oA"ล๕+B2กขโำS45“^‹Cž‹?oก‚+็ํื8หีฃ+ณถžk•YEฅUoซsf @ใ๒:Šl0LGR:ี&4›DโืฉใๆโฏŸฝซin๎OํfฟW;๗ฏ[UลzฃChเ๖}‹ู็งสืฏzซwN3.ฑาy6_ใ†ผ˜มณ!้z๒ ™#ศ’จPฒฌ€,+ฒ(z)ค3๏ํI,'|ดXห•ุงxœท,ฤดX?๛}ฤpC๒.ทsif}1h+็๏ไuฑScฮ๒ีฎkีcˆ๒>ใฐท˜ƒฎญ์?ชW#ๅ IDATW1ล๋™ฑ5ถืsGœ†8Z”๋๊ื@}็  €un}•H›‘ฃ๋ข€w›!€ซป๚G=wtT์ช˜ษK.xํคสทŠง'็M๑ฎ"ฉ‘;์ลทvผp๚๋fาธ#u฿ฟไั…– ฝd+ซมธื,ีNSวe&บv ึ#๔ใะฒ๓E•M‡h$pg4j)g ึลก•ŽtF—b+E’ธฤ X๗โ๛!cEไหฯeO„*0ึ๙่Lใx?ื~๚)”QQอบhทEงห-า9รตGฏ`='Oทธd€Jพ<ท์ฑf; cŽมำmฺ%ซ๏#VฐF฿olฌ๎ฮeHqŠLจh„๘๔Mอคืโ็โฯ[๘bพrณว/ด&\5Whส€‘v‡Mn โoh็๖~—z}iตะ’$Ž%€[#ห5{”gฏบ‰Vf{kk๋ €–ย(งำยvบใrซ฿—หํ?ฆ`,ข~ป=•kาN;1L9ๆ๖y:ๅjŸ*dŽภYุ๘๚๕๓วw‹A›vรฤ_žH‘ฯ_ฟตๆฉJW‡ฮt็์™+‡{ปวMBฤu5ด๘ุลมทํŸUKฌ8,๏r๓๛์๐xศ*Sge(/‘$ฅโึูๅ๕/Ÿื’ปWแฎp+ๆ{๗g!ŒTคล€๋ไZญiw9 “ำIึซ-€๎๙๎ึึnฎ+ถถถถถn๖„˜aKํho๏คi]ˆธ1 |ฑคญyด๛m๛GV๐/EืŠโ๒็๖๖ฏŠ๙*ๆxตใลsงn"ั,ดธรI\IณฎYŸนOโ~šƒตCซ >ญ4_T tศ}ํ„evฮžทFŒ๐Mม๙˜๖ฯหๅ2ฝzŠzvŸ>ซๆรุ๙ —ๅ๑ฌz๚›5ญPชืง‹ถ8\ฃ๙ขฆRค‰APg"หIฟEšึ๚ŠSฬฑ๔O!‡ก๒ํzเdูfฝ.๓w2)ฎ_’ Ÿžขฉ™๔Z๒\ูณš/ฒพˆ@iไ/GฌCี„K้2'ฉำกnr๘~ฏืm‹วEn\qktูสž๏ุ้Wc[+ ฎฒ—ฟSkvŸOa๚B0Œค)ธnฝฎO“6›d–ฝื?ๆจsพฟs‰FX‰ๅxฐฎต•๒ลcึฺแcณ†ษH{?ซฝ|ฆ?๏<“ห78ฎฺ„›๕H–9gX hซ๓WC๒ฮฒ,ํ5c๐ –๓P^ p‡]yฐsBฬDWVb๚ฏา๕“!/ว์vตลวหิ ๋คZญ=๏rbL•pบฬ๕หึ0qžษ^ิXถฺT็L4oฑฺ„Zถ-*ตJZih ภ–rลŽ 5ฺŠำD๐cิŽฯบ‰Dฃะ*อ2รสํfG้฿y9&ฒv A?Tš/ฉ„ r_๛ˆๅ_ฉ๛ Bร#J/_อ0าnท@ฉgะ@ Uo(ฒK๎6๊ข์“1๊Ex<&w›5Tภ7๊Dฤ๏%ไzN :Ÿา1มq\UUŒถ9กr Žk'ฃ;ๆ8<แ๗๕l๊ช%ใหงฉ๒฿‘HqŠLจh„๘๔Mอคืโ็โฯ;t/๓ตpา-1ฬจ5-น”ฺ*aคลŸX^„Ÿ‡t|ย[[r๑Lกx”ญwDeLq่ๆ~3ฎD=ES3้ต8ไน๘๓j๛โืQqDๅด๚โ A;‰fทำสqื —%ดธœHพ‰yฏj&I’ช ’jŠkม—N2œiฉวธษํดŠ<฿๋ฟq—฿e๚—็,กD,เฐPธ*๕Lึ[ ว๒™>JปR&#ฟ|๙๓็ฯW=|žyผ[hปŒHซ็fH€ ผ5ฎCŠฟDž๎”‰ฤ$AUŒ iR•xฑฟั@"ล๕+B<กขQโQ๔ศ&ฝ<‡<†๘Tฝข5ใGงg,ะ๋๔‹7อrง+"สฯ๒ƒมkใf$ ๔ } ฦuH๑็2eสฝN๊้พYไฏ<ฆส?เnŽžย!!>5E‡0™žp ๅิภ)eƒ OืyใVw0H‰ล‹š@ฺฝม ุอ]ถ๚Ž9@"ล๕+B>กขโR4<&i๓ ื๘ธ9z ‡<†๘ิXwB๏ภBUUd&๕-˜N๊/ฺ[ŽปZวปgืwu“๖นีทa๖่๏“\1O^_ผ!3ฟพฅ›„=ผ˜˜u˜q…o3ู“ฌึ๓ต/|^ 4R฿N๊*เๅฏKtn็G๏Œzs่๛จp๚่๊๐1j€pฬฏอลฃฃ|๛qทฒjๆพ๋ฎฑD>|˜3—}Rำ๒'Rไ/ฮym4ฎส|ซ˜9>oHไฬl"rZ™o1™“\}(พ3๑5าูYผี๙ฐŒํ!ฏพร๓ธลทzl4&ฑ๕หำำยุพถD>ผกN|ฎๅ„โ|๗มvoบ1ล{‡oำด/|zขรธ๎๎ESทณ“ฐฯ&a——:็ฉƒห.2อ1Aฆ9.ภN„แจชM:ขษxะAซ\=ŸN:/vงc2Qซ8ค›x่-!ฺ$ส'Nแกศๅ“&ˆp—ฉ2w3Ž DŠ๋W„dBE#ฤคhxLถฺญ ำ๘ธ9z ‡<†๘ิ‚ัท ญ*’„<าI.ฅW‚ษ‡ญ/ฬ]M˜‹ปล7ๆ@2vโ๖ฝ†›อํฒ€9bล%ŽฐฯฟYk~;ฉk›‡ห๕ๆp:pธu3_อฆฅ9ต๛(ฤสั?๗veIุO•๑ˆ)dต\T`!L!‰ทๆผ|n๗WEsxu=โ)4JาLt)ฌๆ~๎TxฬZZŠy๖ŽชจJม๓?UพZL์_’pฤฟ.p๛๛—<บะRกทŸlๅc5๗šฅฺi๊ธฬฃำDขฟกาครkŸ์๎๕yธบพ&ฺฮม‡NูจRี๕`๋`‚ลlsVLูใš<ฉ‚ชฺง[n 2@%_ž[๖Xณ7*ค3บ X)’ฤ%^ภบ฿+ข$ป“๙นŒโ‰Pฅฦ:i๏็ฺ/ฎนรคญ"ข›x)ŒQBƒงดKV76Gฌ`พ฿ุX ห ‘โ๚!™Pั๑)ำก๑qs๔y ๑ฉ)บ…/ๆ+7๋Q\๑bฬ[_,ikํ~‘KQวUธล๏ว.พmฌZbื๕๔„ฒุM$eต›_เฦ{ฬํ๓tสีพžW๎T™:;่/Kdmcใ๋ืฯ฿-m8Wอš2`คa“ร๚oฉ^Wœ.ฺโtpซIV+ณฝตตuPธ/e๖‡ฬ•รฝใฆmแฦษƒž7cต๐๓฿ํ๏ฉ\“vฺ‰พ$:ๅ*ๆ๗ูวw‡nyืt์ผท=o ๚)ฮ_žH‘ฯ_ฟตๆฉJW‰›หEfr9-ฅQ#žWhทZM2ุl&Šฆxž ฑคฝ}ผ๓ฯท็Jx1rํ(ค็ IJน}›W?yษฉ2q๙s{๛Wลผqc๓ญญ\W(lmmmm๕FุZ&้X~ผ\n‰กYhq‡“ธนฝ“f]ณ>sŸฤ่4วชGi —?ถถพ6ิสแึึึึึ%?$อA;Q&ฒ„ˆฅฬ…Ž๙iS(`ณg5y:vNชj“&A‰,'AhZ๓=Sp>$ๆvทฟณwมr๙‡L/K%์&>}Vทอ‡ฑ๓<.หณ๑L*"บ‰ย%Pฤ๚ง‘ศƒP๙vฝNp2ศlณ^—๙ปˆืฏษ„ŠFˆ?Hั๐˜27Bใใๆ่)๒โSSิณš/ฒพˆ@iไ/ว]‡ถXmB-€ZฅGญ44`™s†•บถ:ณฮ Vน‰B๒ฬกอ&™eGvฟ๓K 0ยโO,วƒ๕ซฉD`u#แRบฬI๊ด5์น๐:๑{ นžS‚ฮaบx&—op\ต 7๏4Pžว0’ฆHเบ๕Bบ~7 –eiฏƒG]ฮำ™wสฟR/๖+„nย49(ํ‹วฌตรวyˆฦวอัS8ไ1ฤงฆ่.R๙ขก๘ƒชช ื[ทw†aสm aqปmrซฺไงt,ิŸC’$‚ิ\พพฦไKฦ้B*฿{sีVฏ‡l1MT‰ญ5ลธห•šVดซๅŽIฌqเีi]'สb๚g1‘g8น”4Š7ณŒ$=๓ข‡ข?๏—“6™ึ/|๕ฟcำ~พ›โf‰รqPฏ‡*จ8Že๗น๐ำaฤ Pxี๎ถpl$Gผfฑย€ชช\แื…ๆฮค็ฏ‘$ ' ์j@ไNnฬvv #ซฬ]ป@ฝ๛cคIรลŸฬ้๗๒ฬ^ปี๏๋ฐa…VOš2ญiN)อ๔?8ญ‚;ยAผอบfCๆ๊ํfดiฉtี i@šฆAห0:sึ๖ฟ~๏ข'fยV๑ิM<$ํBX=^›ฌ4z่!;ำ‰yบฝำms:gLเfปำiฃ๏ๆˆืฏษ„ŠFˆ?Hั๐˜„ifธฦวอัS8ไ1ฤงฆ่j๛โืQ๑!=วvM.ฏฤqฺๅqจ๎UO˜ญ4ๅ๒8ไN็บใท„–V฿ฦ}:r๘xž2[F.ช„ร๏wา8†S๖€ืฺnwภ๊‹/ํ$@˜N+ว Cจอฯ฿…ั๋‰„ษLa€ั.ฏS้v4=o %b‡…ยUI$ธป,n2›E1gsบ๓ษ๎l]ฑi*ฬ๏ญsํORท+ฮxผ&0ย๊s[ป]pวณwži,]?[ฅwTŠM3š7'๏s๕&jLŒ*ุ่ฝl? uถPM๖๗I‡9sฮœ้ปณ3กD,์ pยไ๛จzCqƒหr6ึnหBซEู–ๅ ืํะ—ภ™P๒ีŒํz๐AzRซัฒร6 วI&t องdะ๐,Kฺ]všข-f S1Iง๘ิม]~wง8๘ฐ•eYณำmฅ(ฦ7q_ท0ีJซๆP Ksฬ4ขฟเะ5c"qwไG๊fๆทฃ'nง~MปQญ2EfOุ‡U*J๏›q ฃhว0•x,ใ๕ŠŸ๔ฯ ลb -,%’ฏc๋–กฟ๓†้ฝ๒?)€,@'ท๛ฯ{t„ DŠ๋W„dLEโ#)Rู9็\Mใใๆhy ๑‰)zฯŽ๖J(ž’‹f(`›๙ิัอ้'คsn๕ำ!๕๊—ฉฬํแ๓|ฏอ ดุ้ฝธทRตR›wป‰b้๖™+ฑฑ่ฯw^}๑ƒX8๘7S9;qล๏ึ)\ไZ•Lบภ@9w๊^X๚&1‰๏ึฯำ:;}์๚‰หํู)พฬ]จา-ี็ๆ฿ฎ/Rฏq•J฿8๙ก็๙V‹ฮ/ฯY(Œ๏TN3ƒปิฬY>U๛่tLDtQฎCํว“D‹Ÿง ษ๙•OIRๆ;ต์qž๖๊๘ฤšX๘"$ถY8ส(yรณฌฤ m@hทๅ๋‡bB๑ไฤ–|ฝ6Kb"[ปHw$P๒CzW้s|แ}”ก[?Oท@นษ(๙๏์ิณ๐๊Cง฿ ,า$โชสžๅwต‹วƒำ]ฎฝp/พ๙๊ๆ3—•ภ จWZiฺbkซกึ๙๗_fฏฯžฆ!าD‚LSม!kˆ9๖ฮv฿:)–ๆ\•tM| ;uƒnฺb๙ไˆIฦ฿ญัrฏv‘:Wœ๒๕Š็ท๏?G@ูฦE๊๐{ข็ฤ˜ฝโ]ฐg๖‚Q ลยw[=7'*tc‚™อฟ]๘๒ๅหๆๆๆRีแ˜‰๙‰j.WแLžนจ[(ž\4$d R\ฟ"ไ๏c*าI‘บCzฮูYทจข๑qs4 ‡<†๘D=~“๙C๏ˆภฑ๗Iโx/]{ผํ>c2ค็Mืซฺ๗หป๑‘5D „๏ีGO้ฟร๒Ÿ ผ”4ƒ—b็Cpฯโz พ}PpKtๅ5y๒/:|แ ็`cFŒezคฆธษโ๒๛= „ีํ๗ป,w~ศ@คธ~EHฦTค!>’"u‡ŒG]ใใๆhy ๑‰)2ฉ‘=8'boWfl€_)W์›`7sx๙‡-๓ ž/คืoฏซ์พ”4ƒ—b'ฉU.‘‘Ÿึึึึึึ>,{ุ‹ขqัไAฮมฦ หณaz๏€ L$&pœ(cM“ฒภ๒ƒ‹1d R\ฟ"ไฯc*าE‘บC$-œฃ)8ไ1ฤ'ขศxf<8mท@Sqฯ๛‹7ฬbปร#๊๑มภภภเ93p3–ฉqošโZGไูk๏ษ"ว>˜š!‘โ๚!S‘–๘(Š4ขฅ๑‘s4‡<†๘ไŒŠฤ5ˆวdRฏ๕BOา50000ะr6fเ๚g,ฯ…xwญม”0ึz™ฺ๚vGโ๑ฐ๏ฝ{ ")ฎ_‘B„ฑฉ‹ฆH!ำอัT๒โ“Rd```````๐W1ต๏Hซ/ไ;นหฆคอ{๛๗๏จ@คธ~E่ใ)RM‘บCฤฉๆh*y ๑I)"ฐผw†a ห2€X<ุสิ•โ["๏^SวZ็๑ูๆ?ฎ„hภฐ^ng็ๅ]…3&o|aึm[ IDATkฅqYd›๙“ฃณบ@ฺgฑำBˆlณx’ฮีyฅ˜H0“{.1็ณ™0ฑS;หd 7งฬ›C+oฃ๑ทTฉ/๊ˆฏฟ ฒ ฒศถJู๔Ie๊W  รซk๓ถ€๒แfช„-ผ˜q˜q‰mณ้l•SŠฉ฿uล}ฯ<†“Ÿ–ศปwณๆาฏฅ‘๗*ถูๅ7แn๊Ž‹pืŸถ๙ตี@`+]“๗.ญ/านฏ฿วฝฮใษฐว>ญ„ศ›ปฉฤโฯญŒย8๚cมิึซƒ2p"@๏๒`งt๗-ศ@คธ~EHฦTค.>š"u‡HSอัT๒โ“R4NPฤภ[ YไQ bแเŸL๚n‡ึ้ืNม๛”˜Hr/ &0๋es;?ห<˜รห๏#žซzAฐGรr๎วื2‹1กลล˜g7U‘1‘iามd‚ฉฺี&ผ๔:จํ_๕OŠb+ู '5ล:ู‹Fนbซ 3•ส๑๘]๓ไแ ฟ+_ŸH8ใ+กvฬกxห฿.๔๋ๅูฦVบ†Žฉ฿uย๓“ฦp๒๓‚ ฬ‡ ๎ลR๗h˜ษDุ‰ท[ฌV`Ÿ‡$.ิš˜ร้ภแฅมอํ๊|\จ?ฆ^ฆถ~Ež“A’คฟoA"ล๕+B2ฆ"u๑ัฉ;dบ9šŠCC|RŠ ‚ฏ>ฬg VR–‡9P3ybษyฏ”ูf8}ึเ‰พตฌ| \_ ”kn1ฐัภ6๓'G๋Šžฤ„[ฬง๖r็{2Xˆ/Qข(€(J"/HระอซbW€Vฑย…Vจ4P1‘เงฝU๘ูโe€V>—ร ฎžํdฟUฺ๗.๓ตz› ะ8ภ3.๕dd๕v'?๛{'’'BาEf.jฏํๅZถุง8ta™นiพv๚+U์)xž,o$\7Zฅโมาฺwฬ)Nภัจฅtrล,0jัHgt1`(’ฤ–ร:็฿‹ฬ@ ๕a*฿‘ั•แE |ปZ<ฝจt\หF=้ฯV‹wบ,ะ$๖^๋/{q?SำอDnl,H&๚๛๏฿PHqŠะฦSค.>š"u‡L7GSqศcˆOJัlข|๛ิฎ—?j๑@๘bIk#ตณต=ห๙ฃ่œํln๎ไ:ีๆๆๆๆfe…#šp6ำ;[{B ถฉงKYl&’blๆ?๗ ๖๒0-Dึ6ึื?ฏzj?3 @`9ษ๊r‘€™\N E‘ 1‘$%฿พ>WgUš'›››๛W่F9–nป๓ ƒเฎpห_๔ฏส๊UrW 0าๆฐŠญ;‹ข;1uปH_,amevทถพฅj–๘ผ—t๕›‰อœึฌsa์,]หฟ;฿฿ฺQฑฤ". ฿+ R(๔X๑z€‘6› };B.฿„zKrš๚บ2(๘“ญืˆˆ฿KˆตœtNหธQhŸํ}ฝฤ#,ฤRwทjte๖ฒy็wd[u่vŠ—E‰พ™q(วDq๛ฅูฏม[‹ห*+ศNng๗ข8ํIฌผŽ<็๏ื1‡ูญfวฑpฐYภH‹?ฑด?ห<*ๆฎฌษbงZ}จ^ฝnฝ ฆ(oš"u‡L7GSqศcˆOJั=„าyกืบผแ=จ,หp3Šฮ@{ฺ?sป฿พํ์์Ÿทด&,nŸฯa๚sท/a8w€ 2Žc@ู|~%‰’ @Q”ภ J1Q‚€‘ฤ๕ฏ8MSฌŽO%ฎV๏Zl“y9HXฑ^ฟ๙J`ผ~ jƒwปl 1๕ป๎nM&(Šภ๎VoU0 “TcRพDŒ)งณฟmbk8๙Oวโrาฆ๐๊}๙๒ๅSฬ๛_}yEo6ข1guo๋ฟฏ฿vv๖?„1x€ข?1hUJํFฉ๚าพ6๙’ห3ึ›๎, ฦ๐;o๗,ซฤƒฉs„ษ๎tZi 7nพˆืฏษ˜ŠิลGSค๎้ๆh*y ๑I)บ:™สฒฒ๏u;&—ืFโ8ํ๒8ไN็fพสณ,iwูiŠถ˜) ร0‚ 0ง์งIขLfBy.` -พZXx๗้[ฝ@„N‡ท{ผ&0‚๑น™Nง ธ#”ˆ…N˜aUoด•bขšต–=8cฃqœฒ‡ƒŽFฅชy" †›N†gูgmทQญ๖๏}XŒ/>ด‘av;™^ฏงSฟ๋ ืํ˜>;…c„%ฐ๘~ษG‚J๕FA˜Œrybปญ“๖'b–R:xฦ$ '้ดณ_7ฏู>iHล_›;g่6‡cEำ8†iฝF๚ซQ๑งศ๘u๕|_+ภห„ร๏wา8†Sถ€—iตnบkKha)‘|๓โZ1วaj๛—:gปœC™G'ท๛ฯ{ DŠ๋W„Ž0ž"u๑ัi8dช9šŠCC|RŠยณฃฝŠ'วถไโ‡ ุf>ut{จX>;๕,ผ๚ยฤฦ้๗ƒ[ฬๅ=‰1พy™98๖ฟZ]†ฝfxm5ิ฿แ๚ห์อIMภ๗ฺฌ@‹Ÿ;7ฯำ…ไสง$)๓Z๖8ฯ{u|bM,|,e*ขRL$l(cJ$฿ฮ˜0พUฬค‹< P๐แหดOฟ๎]ฒภฬ}๘2ฒศu›ล๔้3ยณY™nงs[™ลr๎ิฝฐ๔1Lb฿ญŸงoั๛1‡pP<ษXษ๗๋4&tkg™"*ี้œ[ด@Hฝ๚e*ำP๐<แ๒บI3ฌ|mGN6ธกW<๏พ}9 ฒศ6.R‡zLธหรฑW_ อิšIa/k——T9;qล๏ึ)\ไZ•Lบp๛ฬฑ๊ ”ุพyฅs0ณู|๛ฯ—/_677o5yๆขnกxrัsฮฮบลโษEC4@#๐โ๖5ฝ&c`pd ั๘W2ู{Q Nsภ=‹๋๚๖AAภ-ั•ืไ‰ึ}ฃC๓ฤณ‹gศฝAJmau๛. $ใ้aF ๅE=ก00000๘ƒ‘Zๅ๙๐immmmmํรฒ‡ฝ(Nb{Šม]Œูล=ิ?`M“ฒภ๒าอขh,/*4ƒ{๏ žxv๑ น7Hฉ} ‹ฯสํF hMณ‹{<็s žฦ๚มภภภภภภภภภภ@/jฺ๋วรvhwค‡hvcัm``````๐ฃ6"m`ะอเ@Z}?Œ@#ะdŒ๕ƒม!mณซŸ?'ทธ5ธ๘vmใ๓็๕ซ มปฏฤา}๕ำฦฦฺล•PI“ฐ…_ฝ๛ด๑yใำ๛ืsnZ%& {์ำป3โKไZฬฎ;ซc@W>%œจ˜C+๋‹>ื@้Hำ(โ ขุ Fม๛๔ๅหฐžp€m~ํหFาีฟธืป๔๙หjุ4e3‡BฉKฟ*๏cฃvNšLp=V"Lf ธ+สF hฒขŒn2๗˜่๙Kๆ@2vโํแณKW€ ฝ๙่ญ๏บ์b–๐าŠซ๔u?ฯ#cโž….๕๋ผปโฏgนรoู6:Msไํ[{แ๛aกGุๆ^/“ูญtMFฦDขxท€%๒๎5ulœL˜ยซ+ฆ์' ตซ0ฺ๎ฑIJ›ŸXšFOd3œถQ/{์S‚ฑs>xฯดm~m5,_ํ=ibฎฤงๅ@๏๔๋๗หัn€}z]:T‡gˆ๓—$ํ p๛วP"ฯษ ษ #cz'&2PS\$อ˜HEH“Fศฆ45๓>‚ธfฬŠCฟฃŽPpฬ‘nEO฿ฎO/*ืฒ‡น 4QdฝXl @ปา`ƒf3Œ้๐x:๙ํ'”/JณK&๎ cBท–k–บ’ Rณึ’gอ‡ŽฉF{K อWณ‡ฉB˜่๛wQ ภส—ภอ่˜ษKฮ{mคฬ6๓ว้ณ฿Ÿ›๒G–๙˜›ๆkงฟREใ’ณa1๛T)๓๛๚้๛ล๑๛ช้N๖ํ๚aะ๓B=w˜ส?ฎ™ฆQฤ“ี ั1Igt1`(’ฤ–ร:็฿‹ ข4ษฯ‰ไ‰P…t‘™‹ฺ๋G{นึ฿=คตZผำe&้ด๗ZใอฏŸd—t๊q+}ปฑฑPXก0‘฿ฟฦDjŠk˜กฉi’~q๕˜ศ45๓>‚ธfLโ๚หhฬ@u;'่ŠXญ30xฤvฅX๋;ไฏ•U่ฯ*HฦB ฏ“4ัภqฒ=ฒ”๔[8ŽฃiZ)อ^%wี#mซุj+ฅฉˆู2—wwŽึ๙ˆ ่œํln๎ไ:ีๆๆๆๆfั5แ‹%ญิฮึ๖๗,็_ŒผUท๘ุ๙ึ๖Š%qฝจ;•žŒ฿—Jญ4Oถ777๗ฏ๎ฟyฐฤๅํํŸe๓|ฤ “ฆQฤู ‘˜‚s!>ทณฝ๕๏๎yทw๑ฐุoงจาด™ุฬiอ:ฦฮาE๐ธ,O’—g‚%ฒบฑฑพพ๖aๅ๗VOกV“œ.ฺโt๔๊ต”Bw้J ๒>ฆI$‚F์6j5‘U(ฑ๗๛ื˜ศ@Mq 3ดb"!Mา/ฎ™ฆfGืŒฉ_\จn็2B๋ฏuOnr๘~ฏือ๐๙ฃผา“\วeYฦhซรArOยqี1„,o$\Rง˜>8n]็ูb๎ข่U ๒ิยXนjถลKีr2448่ฯŠ] Soษs*] ุ|>ฉx0๐ Rgq@ทหทก’œ&เf+วจiE<๚šกะcล๋uFฺl(๔‹ํAi@ณV—D—ุฉืxั'bิ฿ณtkŸํ}ฝฤ#,ฤR๖.ญG\?ฐฅใƒ’ฎ_ >๑กb"# Mš˜%๊G2IำŸ๊Q๚ํ)P็ฏJ&!ล๕็hES…pฦV]l๑*ŸสึฺผคQ’$ รฤ๒แV€ b’๚N<ฑpฐYภH‹?ฑด?ห๚ถศ฿ ห๒ํฆ8Eม0l0&~๓ึ4Tฤ ุ}>กธ?ธCgq๕$า4Šx,t6Cถูฑ%œEถqr\ฟ W(อฟIเุ๋]ษ์Uนf ]ซ[–ร๙งiเฐ ัฅฃ๒>๖๚แ๗/™ษืฏ็ _„›‰_‘1๕‹ซฃS]๛hโ#ฤิ๏คIšโศ˜๊โฃ)3PNคธฆ#ˆ๋ทำภ`šเ๎pห~?8ฝชจ-@เ8 ้๋jLำ4ว)ใ๕;hY่Vผeู> รค›้#ศ รyŒ,หp3wœhขล ๎C0ž€฿iพ3ŽcNฟ—-–ะ…;ข?๕งi๑ฤะ฿ ้@ฬY๚๏๋ทŸวฅžแM&_ryฦz๓฿ภ‚ ƒVฅิn”ช/ํ#•.^ฯ ˜๗ฑxฤ๕nถ9VZมNยdฟSฟธ:š1ีต&>BLAšค)ŽŒฉ.>šข1ีํDŠkฺ9‚ธ~; ฆ I’2ว ฺี*˜qPa๖„}Xฅข๘ฅใ‹ฯm$@˜Nฆืz`%Lf ŒvyRง}ณ5…gYา๎ฒำm1S๔บ“หk#qœvyrงs“034ๅ๒8ฤvุูข€%ดฐ”HพŽyrๅwwŠ๗žSฃ‹C7Cคi๑ไะ q ฃhว0ใEŽ ผL8~'c8e x™V๋๖ฌ"น‘๛๑๋๊e};  าฅ฿๏T๒>j็ทŽŸ8†มรง จ_‘1๕‹c†ฆ๖ัฤGˆฉ฿!š๎มuH๑ัจ๓ืก์A\WRฦ๙ญ๊L๔Vp%6–ฟ_„‰…ƒฯ,ซk๓ƒฯ%ห‡›ฉ *fฆ”s6 ุiนWปศdฎฺ":อL .,D\f“๘n๊8sูั1k(3I[pn.ไฒšฉืธ:IŸ7nึ7\\˜u™1ฑq๚ ภf๖ล“ณ+l3r”ซ๗็Yv‹"IRฏ~yœนh๊Z…žฤjย-ๆฟ็n๖ฦใžฅต@ๅ๋A้๗‡๎ศโธ=ฉO๛๔๋%;x*ซ#พ>฿ปd๕ง FO ู QPž…ทKพ๗ ฒศ6.R‡็-QšL๒ณฏ๚ฟ;1ฦ~฿ฏ๘VP'Šg~i`L ธญ.rญJ.sR๎ษถ๙ตh๗Aก๊–‰พOˆ/็V@v้€่Py^ฝA๊ื&ฯ\ิ-O.จ*O{fgbWdLโ๊hฦTืsŽ">BLำ$คCฺ‘ŠF+ธว(bvŽ ŽŒ๙0‚ฑ~0Pgฒ๋‡ฟๅ๛ ด |ฏ>zJ–UทฒM=Mฃˆ' ๎Y\ิท "n‰ฎผ&OŒ+8&rฮ ?๐7„c&ๆ'ชน\…ำ?yฟ#๎๑4Vท฿๏ฒ(ผN#ฯํฏศ˜๚ลีัŒฉฎ}4๑b๊wศ˜&!ล‘ฺ๕วิิEฌ฿ฮฤ๕i```๐< ฝ~{ญXเโแqา4˜$Rซ\"#>ญญญญญญ}X๖ฐลฟไ•ย“‚œ3่ fq๙†ิŽ๙ผyฤ๗Aำค,ฐBLำ$Moซ+ญเฃˆ๕9‚ธNKŒgฦ๊๏ s”‰ฤŽe๓็ภ๗O‰,rฌฒ'Eฦิ/>ŽฺฺG!ๆฯ$Moซ+ญเฃˆ๕9‚๘PIม ็ ๚๙›P๓gศ#๎_20000000000๘ร0ึzyฤ๕ํŽฦใaป’Žว#nZ)ฆ~q ดbŽฉHC|$E๊กuฃไฅญhฬ‚ำN”ธฆLฎˆ ”!LฆG-9]pสDีรภภภภเฏแGtาๆ ๙N๎ฒ‰<ธgม ล็ฯซ2ฆ~q ;ดbŽฉHC|$E๊ญ>uฃไฅญhฬ‚ำN”ธฆvLฎˆ‡ƒดอ.ฟ wSKWต#["๏อšKฟ—ฎ^ŸN\H!neh1G|=ฦ~฿ฝ่เถนี%ำ๙^ช ”9ด๒6สK•„›˜o‚„,ƒ,ฒญR6}Rน{6\yg=๛/Sแิhฺ[ŠปšG;ง Y%๏๚‚›ฝ๓‰Yฏฦ„nํ"“พj+‹ผ{š$แ˜[#๒ฉิ…า๙์ไก—HG4:๎ฎ;ท“‰ˆหBส|งvqœษ๘๓Nญา>“ˆ…œBd›ล“tฎฮ฿ทm,.0Š฿m๓‘ฯEงxส4‡เ9ีบ๛M[?7ƒ๖’ษ_˜๕Zi\ูfไ่ฌ. cฺๆืV๕ƒญtMปดพH็พพค๛˜1๕+? %z—;%เ”ŒK้๐=ฅ˜๚ล5ะŠ9ฆ" ๑‘ฉ;Dบ:ุ)ซi%G(ํhEc˜vขฤ5ํิ`rEวlณ ญ–๊}Hๆ@2vโํ–ฮ~Š ฬ‡ npyำอํ๎œq_&้Ž/บ๋G฿o๏e+ู '5อ์dwv/zๅŠญ.ฬT*วƒc•ษ็7•ณฃŒ๑]N˜๓๛;๙…5ศผ๋wˆ)˜œงK฿z˜5บผ<๋-5๎žา“๗ฑเหฉ]v๖อซEn๏ ๔ˆ7้"ฝ„{b‹๎nj๏จปโฏ#อoู๖T`~žฎ์ฝ์b–๐าJฬ_ูฯ_๛้^ญณGรr๎วื2‹1กลล˜g7Uyi‘Œ6Ÿข'3yฃิฯ<๔˜๕ฒนŸeฬแๅ๗ฯUฝ cแpู ึฤN/๊Jd—>fฬ!xฤ๕ƒ$ฐ]•Z–xŽIIไ9น็€8*)ฎVฬ1iˆคH!ฒ–ฦQr„าŽV4fมi'J\ำN &Wฤธ+๚jพ๗s็ฌฃ‰oW‹ง•Žkูร่HาZJ'Wฬ‚ŽศHL…ธ9๓Gjšซg;ูo•๖‡ศ2_ซทษ~m๖๙ฉาอร/ย^Hฬ8อธะญฮฒีžส‹=ฮn wมํ[ณธ฿ ™๛wbyวhOb)แฃ๙j๖0U่๖_J๐G–๙˜›ๆkงฟRลžJลV.S|ฟด–rw๒:าKง“฿np"@๙ข4ปไaฒํŽ@Eึ‹ลถ ด+ 6h6๐kล0t๓ชุ Uฌpa‡*่วกƒฎ๊นรTพ#`&O,9๏ต‘2ฬงฯ<€ษKฬ๙์4pฌDH—๚6Jb๋—ว™Kใrb5๎ดMจษต\Jั๓๎ไg๏D๒DจBบศฬEํ๕ฃฝ\KV๕Eค3บ 0Iโหa๓o‡EQ๎JŠŒฟแ{๕)Xถล3๗a;๚๏ด…n†˜ูKฬzm4๐ํJ.}\๊=Rญชิวp#ยC&T ขภK”(J Š’ศ *%ิj๑N—šคำkฝฌตฒK3ๆLoำ.Xุxa€‰พุX]ห ‘โ๚!S‘†๘HŠิยD44Ž’#”vดข1 nL;Qโšvj0น"S โฅ,กกKlWŠตฎฮ‡ท–™9o+{ึผำษ["ซ๋๋kV‚V๕fŒ3‘ฅˆœM]tฏShžlonn๎_กทŸ`”ำi้ถ;ƒ.ใ๗ใฅRซ)‹ศW?vkะN›jN1ทฯำ.UT!๓ฎ!$Iษ83ณ๔ำฦฦฺjาฏq฿Ž๎ผ›!s๙pw็จaธฎต๘ุ๙ึ๖Š%ึTห{ปTม>›vFๅ%าDวษ๖ศRาoแ8Žฆ้aก•U่ฟc  -ืžyP๋–“ฌ. ˜ษๅดP”Z‹ฐฤๅํํŸe๓|ฤแ‹%ญิฮึ๖๗,็_Œ:,ak}๛๗฿ฏฟ๒7eD๘cI[๋่๋ฟ[฿ฯค๐Bไ1]๚๒นำ6ภ์[ชฉtƒQ๓<€อฤfNkึน0v–.‚วeั๐ฝN`.ฤ็vถท=๏๖.พ๛ี๒aน#)ฑZmX]Nภไrีj š!้‹%ฌญฬ๎ึึทTอŸ๗Jyณึ ี๊DฉิูฯOจ8^*ฝฤ^ฆ…ศฺฦ๚๚็UOํgฆ")ลj5ษ้ข-NGฏxQK)t—>^ฬก๔O ัูVญF๔DปZMd๏2)ฎ_’1iˆคH!bOCใ(9BiG+ณเฦด%ฎiง“+bภ์33v €๔Fg•หIผ ฅ๓!๙|ฏ,@่6ฌ}ถ๗๕Œฐ๘K๑`Meว&]bบgป:๖ี0ณ๏?Gรๅ๎ๅฏƒมg6ŸO*„`IS$๔:ตซLM=Mฺlป n”วwุไ๛_ำ„=๚๊Uฬ_๛YPL^ูb๎ข่U0kฆ8่ฯŠ] Soษsื*y๏vปดืŒม“>ฮรq\–eŒถ:!๗$ว‡ ภM_ภ๏๕บ>”๏ k\;;nพZ๔Yธfฑม‚๊ดฉ[ศๅ€PoIN ภZ+Wอถx  ZฎใQ††gaฌ|5d€n็ๆ)ฎ…ฑrตlK+ฅ๚ยŒ•‚ึd?ต๘ƒธ฿6-fฯซ]€nฅ!ฯ*zšตบ$บฤNฝฦ‹>ฃ0uฯ฿U$๔X๑zโ‰‘6› ่Aนฃ)ฑZmอ;XฑBธœฆฺU๓Z้รfhfฎzฺเ$€ึี๑‘0่็h๔ZGEP๋ IDATญFฬึ4Nพ†๊วA??™โx™ ฝD๙โ1ฆz๘ˆล˜P"iํe[2*&[ฏฟ—k9)่œnn†BฑK#ๆ0Lo ึฒื--”๎Ž DŠ๋W„dLEโ#)าpˆ–ฦQr„ิŽLgฬ‚ำNคธ–Lฎˆ)ฤ฿๏ฃ1kxฦ™ฯิว}ฏ;fg-ลร_,๕;T8๖๚ๅ:{Un‡@qะษ*บ๑P้วUO}bษํ์^๔ง=‰•ื‘ƒ}ขvŸO(๎฿พุe๓™ฌy>พ:c’zสล้iฉซœ.EQ?ษํ'2ศ๕ยU[Aจ_•ป๏mV((–žผห7_ีษฒŒa7C๊ญŒ @ีผหผ Rิ๕ฺใฉ$ ร0ฑ|ธU ƒ˜$ษรแŒญ.บุโU>•ญตy @ฉึAฏxดSฬธ,JD๐อŒCีฎAื†aƒNฦ1์^เ-†™‚ห๏ฝเ„ุkฝ๔ฮ#rฏmยฝš žGขโ๙๛Šุfว–xqNูฦษqท๚฿hCใ๐ีj7๊ดCvZ๋ฅ‡ศf8˜MฑSญ*็]wญ๋ๆํ–ณ!๑€ฆ" ๑‘ฉ;คใI$|ขŠฦQr„าŽV4fมi'J\ำN ;&Vฤ–@ะ’ิ_3ž'[/ ;u&ื*6ส๕c1‹หI›Lซพู๑ลvถsะ›‰ำW๖šƒฝ<ส9WฃอœาYEƒH\ญ]๒Xq่J€9^ถธ;เฑฯศg0าโ 'ฦ~^qฦ,AŽ๓‚žCแฎGฮ๎iHล_›;g]^&~ฟ“ฦ1œฒผLซฅ๕ษ.[HŸ๔‹sN=๎ภMn'รณlจฦ]~wงXุ?b %b‡…ยeใxฦ…€cYสl}q฿!RณvBVวMฮืhN&๏„ษLa€ั.ฏS๊ดฏg„™กqภ(—ว!ถhไd6฿บํ้hTซL`ฦA„ู๖a•Jg˜@’$ๅ~N@ึ:ภกD,์ pยไ๛จzcธล{Žษๅต‘8Nป<นำแ€ํ๕ฬNท•ข,žูq“vธฬ8ฮ„’ฏflฦhถM$Hฯ+ลDz"ร(šฦ1 S~™1’๑๗;[ญJฎHะัฉึฤ›Xˆfุ๋vLnŸย1ยX|ฟไ#•๒>fญชŠใล‚๔’ะ้๐vื„F0>7ำ้tU)7r?~]ฝฌoง๚yD;RŒ9ำ{ ไSY€Nn๗Ÿ3ธ๗Pˆืฏษ˜Š4ฤGRคแณฮี4Ž’#คvคข1 nL;‘โZvj0น"ึ+ฑฑ่\ฏพ๘A,›ฉ฿m๕Jlซ๎ถ‘*g'ฎxโ:…‹\ซ’IดŸ~๑ๅLฺ๙.o์Uฬ7g|๘2ํำฏใฯ™น_ๆ@นnณ˜>ํo4ฦ]~Wปx<8ส๓ญ6_žณP฿ฉœfŠj๓ฉZฉอปDฑt๛l ™wa๓้Kb้ร,)ณญโQFว"M3๏าY}nํ๚!๕Wฉ๔๕k sซŸฉWฟLešZy7{ฑ&>„‰mŽ2C*OŽmษล3ฐอ|๊จภsžล7รหิE5ฝ‰ybKพ^›%1‘ญ]ค;Oฝ${! ฺ&ค็•bขŠ" ‡hi)G(ํ่tฦ,ธ1ํD‰kูฉลฤŠุ@‰ำะ๙ๅ"๕Z“๘อภภภภเ™‚œr™ิŸ!ด;ถw5vNืŸ“ถูๅ7แn๊้ชฒ˜=๖i%D\ผ!neค}& 9-„ศ6‹'้\]แ๔uฺj ~ฐ•ฎษ€{—ึ้ื๏—,€9ด๒6สK]_1ไQญ sซsD>•บh=ใฌtxum6ะฟ๊ท“‰ˆหBส|งvqœษท%“7พ0๋ตาธ,ฒอษัY]ภอ๙ฤฌืFcBทv‘I_ฉ่m‰ผ{MO๘ษ๛7bาs€ ฎผณž—ฉO๐Žš฿i*ทŽa‹cT;ุ ึ^Hฬ8ฬธฤถŠูtVsŒ€วqฒN,‘w๏fอฅ_ชฝฅม ่ฑัƒฉ /าMฦƒZ๎ี.2™ซถ๒ค?ฆ~ๅใ'1"b)ฝำพฝหƒpwณƒ DŠ๋W„dLEโ#)RwˆtuฐSVำ8JŽPฺัŠฦ,ธ1ํD‰kฺฉมไŠธูfZ-•U,S€๑Gม—ฦD—ๆNพ—9L„xปฅง๎ๆvwฮ๏\ j.†ๅฏecB‹‹1ฯnJ๙"3ยแฒAญ‰9œ~ป™ญd3œิ˜ุ}|9ตหฮพyตศํ”žํS|แืๅ๋ใ g|%ิ๎˜Ÿง+๛_/ป˜%ผด๓W๖๓<˜๕ฒนŸeฬแๅ๗ฯUฝ ˜‚ษyบt๐ํ ‡YฃหหณาA๑‰ฏ๔˜tม˜|~S9;ูyญฎ4‡,Žวฐs$ฬกxห฿.๔๋ๅูฦVบฆeี๔Œง๓a‚{ถสณๅแุ๊ม‡‰๎‰-บปฉฝฃ6๎Šฟ^Œ4ฟeŽ)ัsฆท~%žใ@’@yN๎๙d R\ฟ"$c*าI‘บCd-ฃไฅ]ุ๎รกaฬ‚ำN”8ฺ!OVC๎ปขฏๆ{?wฮ†?‘3ybษyฏ”ูf8}ึเ๛k ่ย2sำ|ํ๔Wชxฟ‘žฤ„[ฬง๖r้ศสเ๎™pvณxพ]-ž^T:ฎe3|rระอซbW€Vฑย…Vจ(]จj๑N—šคำk๕G๛อำ์ทJ{เีF{K อWณ‡ฉBWษ๓'—N3.t๋…ณ์Eตื/ถr™โ๛… ต”{ฎ็Lษ"ณfขa[-—๊€‰"๋ลb[ฺ•4›xQเ%J%EIไ ท;lอโ~G€fv๏_eEL๔ปจ`ๅK:ูoป=“'–˜๓ู(‰ญ_g.›Pก7ญฅ#9๗š…๊๑มQ‰u'?๛{'’'BาEf.jฏํๅZ6Tม –‘Pฯฆ๒€rอ-ฦ6ุfไ(W็MBต8”IS ย์๓SฅLฟ >’pฤื็{{{—,บาชfs0Mt๋ะ[Jvo\„y=P๛บล3๛~™ศw"*ิฅ“jนT_‘V๙คn-ื,u%คfญ%ฯš)๙นถ“ ZJ'Wฬ‚joI:ฃ‹ฑC‘$.ฐึ9vXdyG7ฎ็<€Lฅ 1LผO'ฟเD€๒Eivษรd่‰‡˜C0ฝMปd`ycใm„&๚vcc9pw-ƒ DŠ๋W„dLEโ#)Rwัะ8JŽดด`ง&“๒<ฺ!OVC๎b Dผ”%4ใ!tE„๐ล’ึFjgk๛{–๓/Fืแฟ;฿฿ฺQฑฤ"ฎ›๛e(‹อDRŒอผ7cnŸง]ช LิลvฅX๋๊|›c‰ฌnlฌฏฏ}XYZqXNฒบ\$`&—ำBQ*ๅ"ิj’ำE[œŽ^z‘ี<ูฟบฟ้ษ์™ห‡ป;G ๋ญ“zŒEไซm;ศ5hงmฐ”ฅ ๆ๗ูเูƒปย!,ัฟฝซ•U่OžHฦB ์ๅaZˆฌmฌฏ^๕ิ~f*IR2ฮฬ,ฝดฑฑถš๔+฿tิ9ูษuธซอออออL‹๐ว’ถึัืทพŸIแ…ศญฃp‡“ธฑ5ำuอ๘๚ืูLlๆดf cg้"x\ๅ‚ณฤๅํํŸe๓|ฤ€#šp6ำ;[{B ถฉ˜คะโP&=[ฟ/•Z*1+ญb6๏ง๙ฐu่/ฅ44.ฑZmุ\Nภไt’ตJSฉเภ์[ชฉtƒนVคุ>0ฉWษ]5DภH›ร*ถฺ [ ‡q๒#a™™๓ถฒgMพ)8โs;[๎žw{฿‹Uˆฦ๕G๒`์P๊มรฤ 4ัภqฒ=ฒ”๔[8Žฃiฅฏ8๕วJา ™mีjDOฑจีD๖nม!‘โ๚!S‘†๘HŠิ"๖44Ž’#-ํ#ุฉษค<vศ“ีA0๛ฬŒ ฝ‘ภYeศˆ-Œ•ซf[ผP-ื๑(CCƒ€n๑ฌุ:๕–๛z‰FX‰ฅxฐ๖’ญ7_-~๚, \ณุ`AuฦึkDฤ๏%ฤZN :Ucs๕@ฏา€็‘(ฯcIS$๔:ตซLํnn—๖š1xๆ๓wภ+๎~๘„›พ€฿๋u3|(฿ส1ีร๏G,ฦ„ษHk/ p‡Mฑ5Mุฃฏ^ลตŸ…! ึยXนZถ%ˆ•R}aฦJA‹ฅbWh5ฺั_ 7kuIt‰z}"Fฉ\สฺ-ไ๒m@จท$ง‰`';?0Q”jอnฆ2N*ต8”Iฯ›ฯ'4ž$*TZฅl>Hู:<,ฅ46.กZmอนœXฑB8]ๆฺฅ๊w*l1{^ํt+ yึDฐŠ'า$"ฐผ‘pIb๚เXkvฎฯษๅŸษ็{eB๊…+^ฏ0าfณ@ก๏๗y‡กืห5vศจ `˜aโ™ใธ,หmu8B๎I8ฎx๎˜ร0ล๏jูƒ๋žŒ-”๎Ž DŠ๋W„dLEโ#)าpˆ–ฦQrคฅ};ต˜˜็‘้ณ†gœ๙L}˜/ฎ1 “o>๘’eวn:๖ัM์6„Nต๘o-ฃ(JเGฏ. {-ส^•a†`กW<ฺ)f\%"๘fฦกšDปVท,‡๙๓=ชF๔<ฆ์y6Ÿษš็ใซ3&ฉืจ\œž–บฟ็2/ˆฅฝbบ`ทณ[อฬ๋gluัลฏ๒ฉlญอK„ห็๎Rฎ ภ^–#๏Žlซ+ƒ\/\ต„๚Uน๛f…‚พึื‹aฆเ๒{ฏ8!๖Z๗็-์ีฯ๏ฆแ๒3XFูB ๑ƒK&P;•@ฑล7้๙b๗๙„โพ๚ฆ ีJ ๐ ›ำDท$ŠCัฮ‡Wญ๖ข.;ิ(—ตVT|ว$ะูส‹…ƒอFZ‰ฅ๘qXV[ ๋q๒#€;fg-ลร_,ฅ—mvl‰๗็D‘mœฎ๔ ล๑วƒ;ฺจLb˜xfH’„a˜X>*ALReญ?ๆ0L๏ั แž:แ7€ูŸ|z}๗A"2)ฎ_’1iˆคH!&B]ใ(9าา>‚šLส๓h‡’"u‡&ปบฦQrคฅ};5™”็ัyฒ๒›๎๙ฟปe๋ื‡L๖บ“หk#qœvyrงs=ม"ฬ Fน<ฑพ™uYB‹ฏฤ}รh๑”p,K™-บlด„–ษื1๏uฏฤห„ร๏wา8†Sถ€—iตฺ€;B‰XุAแ„ษ๖Q๕†๚็สr#๗ใื•๖ฃCยdฆ0ภh—ื)uฺŠžท„ฑ€รBแฒภq <฿“ูฬณ์„๙},hปjตoF’คฯษBงร=^ม๘Lงำš๕ถ#ฒ’8nr†ผๆFSี๓<ห’v—ฆh‹™ย ืํะ—ภ™P๒ีŒํ‘ ร‚ภdœฒœ&‰2™ S4 ูโ^ ธห๏๎ณ,kvบญล๘ๆ"7ฌRนู‘p0UŽ9ำฟ$ไSY€Nn๗Ÿ3ธ๗ดˆืฏษ˜Š4ฤGRคแณฮี4Ž’#-ํฃุฉลฤ<tศ“ี‰!OŽmษล3ฐอ|๊่ๆ๔า9ท๚iz๕หTๆvO0฿kณ-vzฯ{พ*U+ตyท›(–nฟำp%6–Q๗ี?ˆ…ƒ35เปญž@‰ํ›งgRๅ์ฤOผ[งp‘kU2้์ี๑‰5ฑ๐!DHlณp”ั๙v๒๖€_ๆ }๚u๏’ํ–ฮ๊s๓oื—ฉืธJฅoœะ๓|ซE็—็,ฦw*ง™โภดย์๑ๅำ)|c9 ˜อสt;วโ`€๛—ฟ๘o/nฆ*อ๓t!9ฟ๒)Iส|ง–=ฮณภๆำ'–ฤา‡YRf[ลฃŒ๚๒X,Ÿz^}abใ๔๛AŠ''ถไ๋ตYฺูEบ3\ลE*"[ฬๅ=‰1พy™98๖ฟZ]†ฝKmฒลฝp—฿ี.NหนB๖ยฝ๘ๆcจ›ฯ\V3 ^iuค‰lบ‹&(ukํj•š u2Gƒอ๚Aม!ี่.Mฑœ;u/,} “˜ฤw๋็iต‰ฃ^'O•^๑ผ๛๖็(ศ"ธHž?๓ž่QQ;4{0์…ํ๒ห'GL2n–{ต‹ิ๙ํ‚่`ชs0ณ๙๗ฑ _พ|ูœDฒ: 31?Qอๅ*œษ3u ล“‹ฦ@Ÿ DŠ๋W„}LEโ#)RwHฯ9;๋U4Ž’#-ํโ๚ตi'Jํ'ฉ!฿d^ธ#๖>I๏ฅkฯ}gฯ]†๔ผ)๐z5P~๏ฃyd ัh` แ{๕ัS๚๏ฐ<ม'O•&ฒqaธษ_๒V๗หฯใ\ˆวpศฤม=‹๋๚๖AAภ-ั•ืไษxOโดAN9๔ฯึ๔‹?[๎ RSฟdq๙†ย๊๖๛]๗ŽD"ล๕+B2ฆ" ๑‘ฉ;„d<๊Gษ‘–v qฺวด%Žvศ“ีuคF๖เœˆฝ]™ฑฉ.ค\ฑwo‚ฬแ'nŒ ้๕kล๊D็ตSM“๐.mlฌฝ๑น“gฒxx‡LฉU.‘‘Ÿึึึึึึ>,{ุ‹โsฝ…ๆ%ƒœr่Ÿญ้)L๏”‰ฤŽeŒ iRX~ฐำ@"ล๕+B<ฆ"-๑Qฉ;Dาา8RŽ4ดk‰๋ื>ฆq‡^ๅH›7ไ;นหๆภ1ศ@คธ~Eศ฿วTค!>’"u‡ˆVŸบฦQrคฅ]C\ฟ๖1ํD‰ฃ๒d5dxˆภ๒z  eY‹[™บR|Kไk๊X๋<>ว• ึหํ์œฟผซp&%๒๎ฌน๔๋้*˜ผ๑…Yฏ•ฦe‘mๆOŽฮ๊n๖ฮ'fฝ6บต‹L๚ชญTช˜ษ=—˜๓ูL˜ุฉe2…› ฬก•ทQ๎๘[๊๚pG|MeEถUสฆO*“ธa /$ff\b[ลl:{[cI์๒›p7ีฯ๘o๎8ฤ๛ด"o.2‹?ท2 ัd<่ ๅ^ํ"“นj‹J1‘|ˆ3ฑi๏ศ฿™oŽผ[ยRปศซฏ†8$ท๘ๆใQ•ฦ„nํ๒๘๘ช5์ถa}ํ่ฑฤ*ธ๒ฮz๖_ฆ>ม;j~งฉฑoZฅyฯNย6“L„]f\hŸ์_vi 2อay;€[ƒษDฤe!eพSป8ฮไ^]›ผป|ธ™ชLDยu*]%ํm๓kซ๚มVบ&๎]Z_คs_ฟ+^e๒@๔H:1•ยจˆฅ๔N๘๔.vJภอ82)ฎ_’1iˆคH!าีมNYMใ(9าาฎ!ฎ_๛˜vขฤัyฒ๒ณอ&ดZ*ฃŠX8๘ง“พกu๚๕ŸSฐว>%&’ „ ฬ‡ ๎vœ`ณ^6ท๓ณฬƒ9ผ>โนชS09O—พ๔0ktyyึ[:(ข‹Š&Lํื๎ฏ0แฅื๑@mชŸ6[ษf8ฉ1(ึษ๎์^๔0ส[]˜ฉTŽ็&2s(ล๒฿ท =ย6๗zyถฑ•ฎษๆ@2vโํึร1๏žC ›ฝทถฤ=ฑEw7ตwิฦ]๑ื‹‘ๆทl้O„•,หR4pณ~ )Šk= ›‚ษ˜นrฐ{ะ‘อ…7‹3อฏน?๗‹ก0๙ฆrv’‹‡;i*w,ˆ†0„ธ;2K•vทฏXภฑEiๆ< ๓๓te๋eณ„—Vbส~ž/๚ฏ|}ฐ'แŒฏ„ฺฦ) ฎCv•ท๑๏๕Š„รeƒZs88ผจ#ธ•zo$ป๔q™๚A–xŽIIไ9น็oHqŠŒฉHC|$E๊‘ต4Ž’#Ydปัล๕kำN”8ฺ!OVC๎ปขฏๆ{?wฮ†๏๋1“'–œ๗ฺH™mๆำg ˜่๛wQ ภส—tโ๏Zn IDATฒ฿v/z@นๆc l3r”ซซ\( @zon1Ÿฺห5ํ้;ฃQK้ไŠY`๚ขภK”(J Š’ศ nwุšลŽอ์ฟ*ษ9œ๖Vแg‹—Z๙\#0ธvท“Vi฿wปฬื๊m2@ใsb|ท–k–บ’ Rณึ’gอวทซลำ‹Jวต์a๎ๆเพC8<žN~ปม‰ๅ‹า์’‡ษ*LSPDมฑํ ณ,}Ž๓['$ lE“'–˜๓ู(‰ญ_g.›ืs/Œ๖$–>šฏfS…๑ ท;lอย~‹—:๙|unฦa‚6‹h2`}Š๓G–๙˜›๊นรTพ#+ด#”Iรˆ? ฬ>?Uบ~˜8๘Hย_Ÿ๏ํํ]ฒืฯbf\่ึ gู‹jO Bo>ZKGr0๎5 ีใƒฃ‹N‰bCP.อ4?Ywฟ฿˜ƒ๋๋ซัiขํ|Xp่4Q*Pๅ๗มๆyณฮพ{eส๎UลqํEึ‹ลถ ด+ 6h64Eๆฉ jน”r•#ัลX€กHX๋œ;,2ˆš์N~๖๗N$O„*ค‹ฬ\ิ^?ฺหต^๔ฐ€r์*ฝbซล;]h’N{ฏ๕ฒ^๋๏ฝ…้ํ้&หo# 0ัทหปkd R\ฟ"$c*าI‘บC˜ˆ†ฦวอั4ข.Žvศ“ีป˜/e อx]ั!|ฑคต‘ฺฺูžๅ‹Qtฮv67wr๎jssss๓zfM8›้ญํฝ !ิำฅ,6I16๓‡efฮสž5…์ๅaZˆฌmฌฏ^๕ิ~f*IR2ฮฬ,ฝดฑฑถš๔+฿C’”,"4ฎฮช,4Oถ777๗ฏะ“Œr:-v็qฝJ๎ช!FฺVฑีๆ@lWŠต๎รทc–ศ๊ฦฦ๚๚ฺ‡•… าDวษ๖ศRาoแ8Žฆi…˜HขXVขiœaL"Xญ&ŠฆX– ฑคญu๔๕฿ญ๏gRx!rSkอน|ธปsิฐฮG\JๅA’”t[P;qษข› €% .lo,›็#nLฉ)™คSyภ๘xฉิR‰a ฦ"๒ีถฟไดำv5แ'q๙c๛kฆ๋š๑™$ดำTjสฅ9˜&w๙}ss๋ธ.—77777๗.Uื;Q‡NYC๘ยษนŽ๙iS(่fOซโd์ƒVn๗WกLœd,ด &Žปย!,กr)8โs;[๎žw{฿‹,=จษ`3ฑ™ำšu.Œฅ‹เqYฟฝ๓|h[็๘‘;‰ใ์ABdฐฺrKKK/งง‹QฺฐB ’8{{ฟุ '„๙๊๗ฅEัั9::–%’FXง๋:lW ๘^QฉV5ง‹ต:ฺหzยfุ{cนฅญ… ]lVซtWตSฏVU๑zรaฑโƒ+ย2คข>โ๗Rิ!jทฦ‡ญัS8คท8!!WA๖๑q;0yรฃ๒O#ถr6ฉrุ”5€JฉFMp,ิ๑+2๊้ต?HU5€jฃใ๛ฌ๏ไwท$Nญ—_์6ำaSAxฃค@๐2อ‹r•ํ฿ป"โ‚๑Dธนqุ”ƒืlฺฃํssQ๕oม`2p๚ํŸ๛sBb๖๗šแ3\d๑ห J๏œl%๔˜_Žปดถฐ—oว$ฮ!ญฃ_'m๕วgccี฿':E้บŽX›รAำzWฃ(ส งˆ๓'ึIฦjณษ‚ภุlf‘‘Z€ณIีรฆ  –‹ต้qMD!“ญuบๅ:\>&ผลต‰…ฎฅŒ.™N!“o)Jญฉ9อ,๓)ซIŠ? xŸO๚…B&–1Aท]อฅช—ษZฝ(tT€fฝฅัW•‰วฐ5‡(๓ถF wƒ้ๆา…ฑน7๓บ|ดYผ&9ŒรA™พ€฿๋usr~7ๅAปฎฐึห&ฅ+ชg๓dโy+NC๖V$@ฃZำT—ฺฎUeีง"ๆe}| ผ๋nw•ธ^ฤZ•๛ฝดZอhcฮGทPุ ถKVฎจ&ฯz2ฑธŸ,›ˆ\–!๕ฟ—ข>้ง๑ak๔้#Ž-็ั"ไ Œ?์?ํฃ‘-4๎ฬงjwyาฯื7้บN!รŽๆƒำฑGi˜ฬ`ธ๎๚ฅ]^๕—ณ”#ฑ ["s‘Hป|๎Naงัฤ“R๘ฝ฿qุ์่ ื น–ขƒRห•:‹ผ ๘ฦฟXiถ๕?ัฅ˜cูฮฌญgป@ฑž๘ป7แไฎ_W ษฏdฒ๚ใณำ๐gป„6aš"‰g฿ ‰นR+ฤq MCฉฅํ๏%ำาNฟ ฤไTpฤฦž$JŒรeฃ[๙›ฐ;tห:Bศ<6ฟ่ี€ขีn๓,ผฏฦ<2Žyฌ๓ /™‹:๔™4 ๘sภ๎๓)ยf๏h๓ฉCหTlaฌu๋ๅ์มAฑs›b๎๏๏;–i„QkSๆv6-Œ"Doๆ๓โxค›ฎขFb็= ั…—(ไ๒;‡ี–|๕พngงrุ{ฐ'6ฺ||๑ใคชŠ๕๔ๅe๙r"๙บ๎fWฉb{E€Vตfษว25๖ศึ…†ํฝ๑Y1]๚ ž?ะ๎ฉู ]LฅัโOฤ|Jn๛ฺkDl"V|pEุ฿‡TิG^Šz;คํ‰ว}j[ฃงpHoqผC-B.ฑฦ์ =5y‚žรฺ]6็ะuฮooWo{ ƒ~ํ๙+๋Ÿ ช™ีีŠช3มท๛|พ@[n›ฺ(ืล‡๚ฐๆ‰ฑบœฌูผ๐o่์oว ดถ)SงžะAง( (ืD7œ(Š‚L4:ฝS,หˆํ~yhRตึ™๕ุ(่<€ซiฮ๋15„บบาฉิๅ˜‹‡R—๋dw<ฦๆ’ูำw(gใ E’€eiX–•$ภ์Kฮ‰(Œ?ฑ่’จ๓nk๗ธำ4ซaฏE.‰ ๋z7๗wุ๐ฅBH๋ีิEs€;ฑธ",C*๊#~/Eฝ"šํฝ5>lžย!ฝล๑yดนคsผ๑ํธฟ>#บถู๏ๅ๓ู6ๅ๐8๔v๑/‹ขษใฒณ‘ฆ๕nWFั4tŠฑœf2[hJT =Xƒ3sชฉoษย๋ผมด}=1๓aœฑ‘฿ูฝุD-xฆ็>‘Z?๘,ˆB&๏‰\Žส“Tr฿?ท0›ะาB๐๔๋ฉล•ศ•-bไnKTXต}ฅoŒh๏S๏>%Lบฎ๎็E๓{ik|๖Cฤค‹Ma7e‚Hฬ๏ฆฬ๑ฤ?ใf$7…ิž ร•mg>ฌLž๏๑ภM~X™]•: a๏เNPK™๗๔์ว irงvผ—๋ธโห๓ำู๏ŠิB๒[ ๗I–V>Jปb๑๗ŸJ•šๅิ^Aต”ๅฑ๗KฌญfwŽ[†9ฑฤ"‹ข&)- @iต๔ณ‡bŠN๓‰7KRลjvฏญ@งxT›œ๚็๓,ญu๋น=cฯus{iKlzq‚ฅS;9nBKฦภ7ฎ#ฌIƒ‹๗T๖P.ฟซ%์_๎J…รฌ{ๆํว`'Ÿ:)ฦ@nถะฤิค•Arป|z 1e๒QLว‚ฝ ZS&ฃ‹๋6ƒ76B,มุX๗hญฎษอt!0;้*๏Uี‡ฐspP๙ล฿G= ฦuฺํwŸฎp๙g๑ห่ชXฯ๎l๗Zšภบ฿UPึ๓zมุ\๏ rงูUตี= |—>,ศbนvaeeๅ๋ืฏ#(uhวxิOW2™ฒd๖LNธ!ญ_y:ŠMฤŠฎ๛๛Š๚ˆ฿KQ๏œฌ'qซ=4>lžย!ฝลปNœC%B๕’!ผ@ฐ2x"`ํ›๛่).๐นภK)๓!x)v†๒ฬ|ิ~œฝ^ฆฌ๏˜าฯ๑ รvศqŸqnฐ‡fธI=ŽŽศ๊๒๛=œ h›๏wุI›ˆ\–!๕ฟ—ข9Mœงทฦ‡ญัS8คท8!!๐ุ˜ผ~{U่ฑง็+.๓!x)vbะšฅข)แำาาาาาา‡y˜ศูŠฃ;ไธฯ87ุ๋;ฎ{†<๛ ณ )’ค๊ˆfY“ฎˆ๒ีy6+>ธ"์ฯC*๊'~Eฝs๖ี๘ภ5z‡๔ื๐ๅ› Lผwlฬอ]ท›ˆ\–!๕ข‘™๔Zr!nฒ๙0ๅ<š?~๊ใฟ๛๏สสbxุณmฑฯ„ฬ#ฑŠ๐t๊“มไ˜˜[ดผผ๔ฯLะF$‘ฒxco?|๒ๅ4๕4๖อุปŸฟ|๙ฒiq~ย9๊ลs$>๏ 3๖๎S‰ภt~/~XEฯปฬ;๐œข๎๖ฅm”Hธ‘—ฌแ๗ฎœงฃŸVV=็sิาสrย…(๏์—•…็ ƒํา‡ฬ `๑วฃ~ž่q ฐ๑“j5ฏžŒb ฦ&P๗B—ๆ'฿ฬG๊฿๗ช—หสM๎ุŒปถ๛ป4ภŽjqoญrบ'ษต"HืืŽ`ฑโƒ+ย2คข>โฃS42“^‹C.ฤต\rญtซœG๓็รา<๘๕฿ุฃŸโOขž๐œภ๖ษ”':ใ๎์l์ถ(W์อLธฑzุ6ั<–˜b‹ษีdู&ๆ็#bRPธ@ฤ+fึ–dฐ„ๆรž\ญะ๗Hnยรc๖๙อฅรฺร;Šอ๘็ ~ธ…K$ ‡—˜ภTˆ–ฎ๋ิษฌฏ฿๗ฑr5ณc่ywโ‹ฟ›ึdฮ;ะใ› ตUชsn9“ซซ€Lผรฆ6[็o(.<ึwฒCั˜_^'ฬ7๑ฯ๒๒|เ๚\›ˆ\–!๕ข‘™๔Zr!ฮ…qๅ<Š?E1›G๘บำ๊๗ฃใอ๏?”ญัฐห๐>ํ‹&l๕ต๏?~J™ €c"๎l์ญ}ฑ‘U๑šำ๓อีo฿~mๅฝ6 #ยl6ห๒/cื'›ฬ,H’nฯ&VI’X–>ัฤ่7>ป๘iyyi!แ?=ิH<ูSยKหŸ?Y๐TฆสฝMึ@€>๙๓ใว฿’e*์F`ดุ๘คั฿๕ํ๛๏#-4ๆG็มW็๗Sลb๓โo‹?dญ์ฌฏ๏ีน^žเอb๊ j› กฃ=<.kฯ_Sd› ส™ต฿ฟญwบู฿ยiXnwฌ"#ใoกV*u›หI˜]NบRi€y,ึs~XMf๊ฌ“งLพhึLญพบSตฦฆผดQ‡Œ:ฌ๖!มทฐ‰&ค9^$F^ฒŽOz›‡Gkw=kxay๙๓็ฅ๏ฆวฮ>หฅZีœ.ึ๊ttk๕uฤ๖Cๆผ“{ศะ๙ๅธKk {ษ๓ถแ&fนฮัzQ๊-z]lVซtWตSฏVU๑zรaฑโƒ+ย2คข>โฃS42“^‹C.ฤี.ฎœG๑ง ัh๔๘๘ธู์qœŽp$tT€vญฉO^}นw+g“*‡MYจ”jิวB]ชงื UีชNŒgฯsส•รฆขtฺร?%# ŽีjM$ลb๑aีPฅ๋:bmM๋]ขจกๅเ๕?›ฟ๖h๛ฤ\ิ_[_,สUถ๏Šˆ ฦแๆฦก๑ƒหN!“o)Jญฉ9อ,€ˆ Zl|Z9›T=lชjนX›ท1ะแ,์uม๛|šผ๒$Q+€NนฎG =jMS]jปV•UŸŠิ๓ื)]Q=x"ฯ[กp๚๕ศญvว+226jฅาœr:‘Pฆ]Ns5ื8SŠL,c‚nปšKUO“,'U๊’ะฬํ๏:AW9pิ1แ๗ แซหI๊้_ษV๛ำ2šๆxM0ฉ ~ผQR x‘ึ:ฺ๘u‚ัV|66V} ึชtุ๏ฅีjFs>•ล๗฿{—๓.g ’_ ศd๕วgงแฯvI€vfKpลcมโŸ\wฐ œZ=Lž]ybq?y๋&‹MฤŠฎหŠ๚ˆNัศLz-นว–๓(ฬd2‘HdnnŽaุ3`๔ห dุฑ#„t,ซฎ๋B@๓ม้X€ฃ4 Lfจฮ‰๑p(ŠR,Vฆi!ตดฝ`Cšฆ:่ตBฎฅ่ ิrฅฮ"oƒBรๅsw ;๕Ž ž”ย๏Žรfอะฎซ‘ A‹O„yl~ัซEซๆ๋แŒปฯง›W?บธ๊ไžวาร๓7‰6_8ฉชb=ฝทฺNฦc+•ฮ„ำUึiซOJˆ๙ิกe*ถ0nึบ๕r๖เ ุัฏUSmW*ฦu8๊:๙ญ๕าีjhฒ ใด?1ฃhŽWๅˆDฌย๖–pๅฦฌ)’x๖Qš˜+ตB ดช5๋|H>ฉฑง0๗พเ{๏กrš}๑้ ‡€bY3L/ธ4ะšูt๛็Ž๓š๓zL ก.ฎt*u9ๆโกTะ;'ป็ยฬDc3ำไ1'ํžš าลTJ-Dฬงไถ*Wcฑโƒ+ย>คข>โฃS42“^‹C.ฤžxง,็Qฉiฺมมม}ฦˆ:œ฿ลฑws„f<๎ื๕ซโง๗Bึ?T3ซซUg‚o?๒็jŒ]=ˆž๐RQ$ X–P€eYI‡OTฎ๚ญ๋:ข(ะฯว#:่uท .h๑๑ฉ๋z7๗w๘Eญd|ำ๏…๕>=ึ๓F9๑žฟฉˆ D•๏[รl*7žๆ<^›Z/ี.–JๅŠ๔ึษWX{ฃฒw–จถ๒ฉ?๙2YกฤL„#†gอ๑ชฐบœฌูผ๐o่์oว ด–์Žวุ\2{บn๘ส„ Aณ\l™ๅJผOaํฝม๖งธŽzไผŽX<ฮ{M{XŽgDa๛?y€ปŸภ๙bScผ ะท“๋vฏ\lba/๕ฯL:๚ฑ6งำnฆ€ฒ๐Nงฝ~7ย&bลW„eHE}ฤGงhd&ฝ‡\ˆำf;ฆœG๓็}Eัโt†๓M†—ši วR€—วกถZ†๗คnงmvyyEฑ.Coท%„MำHง{ภiึณ…ฆˆ๎ฉ"ซ'2๎ล‡บ„gFฝRแใ†ฆ-ž•หํกตFญๅm&Š2;ƒ^KฝัPฺmู๎๑š)@4็ssํ๖–โ‚ŸN›uธ,ลsใ<9zๅ๒ปB฿ํฑž7ส‰๕-EB หR๕xKz/ใญมู้xโMิ{ฅอลJEs…วํJU=ฯV†าIRเ๔1{ทำ6ป}v†Bด50ณ8๋3ี}ศจรjRFะฏ‹ึแฏฏgHื5aฺ๋๋QGึi‡฿๏d)D1|ภห5›;้๕ฬŸญหZ; `ะฅ`ฎ#รœท‹ปษƒบ W๗ฆ*ฦKฏ๗ฎ๘๒|เ๔ฺš[๑ƒZH~K•2๎ู้!าไNํx๏บวๅRjฯ๙>ซo์ฮXฮQ๒+€ฎ@;ณ฿x(‚MฤŠฎหŠ๚ˆNัศLz-น?Z๏๘VฦG๓็} ‡Y๗ฬมN>uRŒŸง›œ“ Ÿฆiญ[;ูI5๘่าB๐๔ปีล•ดWืณ]EH๏๓‰™ใ ˆฮnD!“๗ฤ?.GๅฦI*น๏Ÿ[˜‡อ!“๕ฬผjŸ์d+c#ฌแ๑ม๕ษีRz—Kฤ/ฑzทš9nจร%Š๙ฝด5>๛!bาลฆฐ›**ะ8+$ฆ}J˜tน]=ฯ฿mWI\ะ‚Œ‹OEHง๙ฤ›ฅˆ ฉb5ปื&๋vฐP.ฟซ%์๗]‚๕ผQNœ็o+๊ วฟœถ—ฎŠ๕์ฮ๖๑–€/wš]…Q[ื>ƒnW*ฆ‰q)ฝ.@nถะฤิค•Arป|ไSใSถxb๑3‹”N๕่"qไQ‡ี>,ุK›ˆพ9^2ƒzI+ฅ]ฑ๘๛ฯ ฅJอrjฏ \_FŒ^ุW^ุsๆฤ ตOถถ˜๙ˆš.๔\€,–หีA+++๗Iํ๚้J&S–ฬžษ ท"คณWw~ล&bลW„}HE}ฤGงhd&ฝ‡\ˆw‘ˆ[ฝYฮฃ๙sd\ิ•๐šม๖ดฺ^>ดo๎ฃง๘sป๔ะำซŠ(ฯฬ็@ํGฒ Pึ‰woL้Ÿ้ฦ0e๎อ๐อA์ใ!Ÿ-7nRO๗bY]~ฟ‡3ms๛.๋๕‰6+>ธ",C*๊#>:E#3้ต8ไBฤy0ๅ<š? แฑ1y๖ชPy๘๑7F‘ึ,MแŸ––––––>ฬ{ฤฌะ๓4ชส$›ก›ƒ0ุ!วC$พž๎ะŒู„IRuDณฌIWD๙๊ผ ›ˆ\๖็!๕™ขั™๔Jr!ฎแหy4wƒผ „—vศ๑‰ฯ–7ฉ๛์฿:"TYฟนtx9y&0ขฅซGZu2๋7ๆภๆฑฤ[Lฎ&ปศ61?๑“ย].2 „ฒg็ย6 ์‘73า๏mA4ุ˜ๆCำ๑qง…R:ตยัaถาีภ์‰ฦ'}<ฃ‰ต“ิIร๘^ห‰,h<โๅY[ๅฬ~ฑซs‹๏'ฌ๏V‚g็ฃผโp๖Œ9UQnษ‰1y7kŠบYฅ–ูษทu6ดฐ4ลธ—'Zฟ6ND@fO41ๅๅMบุศ๏๏ีGqh๐mŒ‚๓'|๛ัVีวb^‹RูO๎Ewโ‹ฟ›ึ˜อfYฦŒM๚vฟฌ'๑&๊ผ่ฒwMLชโฦ}ๆฑhXฯm,)ฌt๑tฅซํ&๘ๆ฿_[ด'ฑ0n:hโUasš|ัธญนตžlj\h๎อ”ทฒUlญ}=zฯunาH๘š{๔S์zบ5 ทH™'……ฒt๒๛๋‰i์อ'Gฟ๒E|ั„ญw-ูฆœัท3๕๛๕›*F!†žงN:๙็วกk๖Cุg)oWชKsกโ๊ž๐fึeอ4ฎป๎˜ˆ;;kษ6ๅ/ฤC•_‡อปšt7(วdฬY[ฏช`F#Xํๆฑษ œ๙๕ฃฌYร๓Srj[8๊c0ืA;๐˜ฬ,H’nฯคฬ$ฑ< p1เ~ชธ}ฐึ๑Io๓pตมฬ^)ย^XืuU้ิOาฉ|K3™โฦg#!'ซwส™ฝ”ะ้qZึํ;ืตณ‚ DฃQž็‡ญ*@ naตZgffŠลโํŸ๚vฟruํทo฿ไคn๖๗ทo฿พoิ w Gศฤ2&Pฺี\*]”ฌœMช›*่RนXcl6ฦะL\N วIก.išาฬํ๏ฺฯโจิN!“o)บึช55ณ™5สfๅlRฅิ”5Mฌ”jวๆ<…โฦ็ฆ†บ#†žื๊Eกฃ‚าฌทดณปqฃZำTMmืชฒชฉˆ๊แๅuฏงื7dMซร๖จไเมะฤOฤœีิAํั7ฎว„7ฅ{ฑฉ>2๑ผ๕<}ื ฎ@E้บŽX›รaฅu]ฃจ+ƒw็ำ„โลl‚๑O๕ใƒาี'Kญฃ_k๋๋๋ฟ“้บe*6f”ƒื7\฿kุbั๖ฮuํC&“‰D"sss 3ช~“@ g(ŠR,nิท๛ี5UPu]ื4Uํ5f๓ฉCหTlaฌu๋ๅ์มAฑฃBศ<6ฟ่ี€ขีnำphŠอ‰า/ึ฿ต+ทฮ๖ฤ์‹O9หšazมฅึฬ๎คหcฏ{ovฎ_งวP๛ช๑บฎSจ็ไว์›ž๓‹ฉMฬศ๐^v๖๕ผ˜๛๛ภ|ทroีๆƒำฑGi˜ฬPปฟIํ๎›~‹ฺ™_ฃŸ=๔ำŽ oƒฌ6_8ฉชb=ฝ้‘!\ืG;9‚0z4MCฉฅํ๏%ำาดห˜ณ๛|ŠฐyพฒrD"Va{Kธr#ัI<›OˆนR+ฤq-๔Z!ืRtPjนRg‘ทAกz)s5’ฑwฎk๓Mำฐ๗6@ <ฃํ~ีV>๕'ŸB&ซ3”˜‰๊›yIื๕n๎๏๚q๕ ุœบฎร๙ฐัŒ Yีtะกืุ@,็=๏ฆ=,ว3ขฐ}|9y๘๚๕๋๋wWฎe.ƒ๖EVWg?๚ฅฒwด๓–C๗pฐฉ šY]ญจ:|๛๑สซฌ;™4`5ตโ๎92๑vห#œB ขธ|l ๊ฌl|฿๊ožฑ๋๎คแ#™๐E’€eiX–•ค๓]‘ำ๏…๕‹๏^ญ.'k6/:๛ฑยญ%ปใ16—ฬž.น>›3+ส๕o_ฏ๕ŠƒD๒ณุX‚@ ฃรŒG+C้Š$)p๚ธตiณ—… ธ`bnœ7์ฑ9ปถูํณ3ขญ™ลY฿๙ำ'YMv—eXซ…1œGˆลไม้ฦ8ruoช๒จŸ}t;mณหห›(Šuyzปnžข–3™บาษ%W๙ใ๛๊rศเž„MำHง{ภiึณ…>๛้aLา›Gฉ2บ่‘Vฃ/ุ๐ฦA!ฤฐ,…๊ยฉ—๋๎ฏ@๕J… Œ;šถxB>T.Ÿ}ฎDน๎ถPบ์M[‡ฟพž๑#]ื„ญฏkGYง~ฟ“ฅล๐/ืlถดFญๅm&Š2;ƒ^Kฝั2Pnู‰@ ^บ๓๑9€lก‰ฉ๙I+ƒไv๙ %ศ ้4Ÿxณ1!Uฌf๗ฺ๐ัฅ…เ้ว‹+‘ณอyฐ9!ฒล‹ŸYคtชGงeจฅฃฯ๔‡ R๋ฟ“ฃเZ๛dk‹™จ้ํB๗ฎcฎ‹u>ฌLž๏ช40Š็3ฦ๙ž‹งตvvk‡};๎ฮm๎3หนๅฌ?gเบ‹B&๏‰\Žส“Tr฿?ท0›'โ่M:GkdR•๗‰)็zชฆbํฤ6qpญุ๐ฦi๏ วฟL€ฎŠ๕์ฮ๖1v:ˆw]#„ฑซ@xPิRz—Kฤ/ฑzทš9>๊S.ฟซ%์๗ Aญ|”vลโ๏?3”*5หฉฝ‚b~/mฯ~ˆ˜tฑ)์ฆ๎zh ฒX,๗ฉ @ ฏ„ ฿4๐ผก<3Ÿตษ‚ @Y'ฝ1ฅxฃ0แ๑ }s=ลŸฅ'ูŒผ แd๒๐โัšฅโ๘ิ‡Oงmฉ+อ์?ั ž/&ฏ฿^อํ<ี๖มไ@ @ฒ~š@ @ ™?@ „A๙?jช2ฉญ*]IENDฎB`‚aristocratos-btop-d43a485/Img/normal.png000066400000000000000000005011171517514752700202640ustar00rootroot00000000000000‰PNG  IHDR’†t sBITแOเtEXtSoftwaremate-screenshotศ–๐J IDATxœ์w\็๐็’ CdŠ ศP,P\ธฎบ๗ฏŽ ๎ฃnQดฺก€vj•*ŠUT8๊Dซจ d/2 dmภ„a>฿OธrO€rO•Š›‰jลdZh4ำฺšญ~๐c^fฝ3p[zแม๓๔Œไ‡็˜ฺŽA๒๓ถฒํ|Bz๊ฃsํ)๏‚_อืS37OV๏๋ม๑ิV>ฦ๖?๗ฒ๑bovqูlL๗…a1ฆdผLบน}ดตFmžnห"ฟ|j‰ำๅ‰BŸˆฉฅ!๗ี๓ˆฝ›‡m๚>€~ทฎF e๏้ฬ _พ/I๔a๓.3Jศxyวํช_eK<[ถ=๔ภส ะ๚ŽึN:B่s ๗(๗Tฉpฐช[๙/๗ฯžy"แQ๘ุ>s"Ÿ>œm ํ๚v5>-#๕๑อำ๛๗3m๘ฝ†มบvŠีlำŽšiEB๖mฎHV7Bธ๑ืu#ฬ^น๓tพฅฮƒ ํkั๗™ๅ๚๏จฉล€ต๓|ฺ+3$–U$ข๊O5ก•Š)t™4ฺ o ๒ีนตn๚ผะLป๛ฮณz›็ศำ(7.>—น/๙Ÿw๓•l!ิJd>ํห/mฝ&๚ุHูlผ:8๚ห้??ญ๚OkRท>} ้Zžn5งI333ๅฑ{์นu!ภ /ภ\:B่s ๗(๗Tฉxด<พ0-0๑ šcZฤัr€ซัgU๘สมzƒ็ณๅวŒ๖:าOบก”fZA%“(@่$B •ษ,zฑ ่[C็HGwส"ำช›–]^ญผ>๓ผML๕ จ™RP„”sณ€งojP\’›bdโAKง^L(;s*๒ึmmำวAนบh”ภนธmQ๐Mอ _ฬtิฮ@ฒ?až!๔iะ-อ^0gดณฅ4.x๏น>๋K๏๑ฒฎ๊ฉค๊ชR‰”ฦjงฏbJUr!ิ๊i~mฦขี ”ผษ:V๖ŸKดี{$๏T)๗)7( {d<฿/็ฏ}f}=ZCƒBัำeˆตu5+๎œ๕ณ ไ้SŒuจdํvŒvณ๐ฆ,๏ov=ษ+์ฝ๚L&ปv3๏bกA๘ืํ็EีIฮdGO‹N c๓งN๒'ู™T@$€,)b}๕md2H$R นโ7wด[๓ั<‹Jีะ›๐๓3?1P ญฅ]ŽX(’ˆล ˆฬ฿mzž!๔iิž)ฃฮฌtค{z็†๐฿ข“9ฒ†:ว๎˜[็ตP$™vŽ฿ะ~ๆ฿Bกจแuโฉ!ค.jO•TFŸvํด๊ผ๕ŠŸ'ฟ~{”{ชT<(—(&de„้š1หx.“Ue]฿ฝ`๎มxพผ–4ๆcฃ๊ไYบฦ>ฏDE๏๊Eฮษย*aมซgw%Iํ†ึma๋bฯ`้s๚z%ทขแu}8^Uฒ๛๙๏&04(f_Œ์ษสŽฟ_็} … "‘ฐบž Pศ„กaปŽ๕‘@ฉด๓\ถc3๊๎U‡ใ๙ŸŸ„‰ฑ@!˜š™d็ๅA๏€†ื‰งJ„P๋๗ฉ’9๕~ฆBไžTๅž*สฟูVœ๚ืRŸk์\–…lพ.ะ๗้'ๅtซ“ง™์r๊๘ๆๅƒเืฮs๚่9YKGปgฟ^ถ.๖ฯใžพ พW?˜Z™ว]ผ๓ัโA!Oโูเ?dับด.0x๑‚พดc“บล—ฐ๚Lf†ฝ‰ฟ+@nาำr())่0ไ›mย™‡X6ระสๅ˜ฃ{ ์ืญ’฿kๆสQZง—O ‘ปT›'B5;}}}€ƒำๆ[Wx‰QG๎ะฝ7ฬšdeซภ๊9n/žGz3€ิwฺROบพ๚๓p|$GGง/๚!ซIwXพ“ฬ„๗ˆ)†^rืYจฒmDกOF๎I๕พผSeฑยมi๒b๚‡GOx}โ๏๛/ส@,เ๗ฆตๆQษญxrใฑวจ~๕ึšฺš2n๓Œ&ธบi๖๚†i“ืฎ'sณ rCR=‰ะwžพv‹Ÿ~aหช๏Ÿ@ไw‡ว์Ÿรซร€ฤนCš'…๓8} eรฬ ‡Fั๘O/๎๛๛_>ุหkY า<Bจู&ญX(<่ศ1๋ึฌm ฝ>๓ึ๗แO๙๕f€4๙ื๘ทdTท–<;+@wWเ”ฝEน˜ฝ๒ฯ‚๚ึ‰๕B่3 ๘@ฮฉไ?ๅํไ$I8wvเ์qKวX่ษ^งžถtM‰†อข’[AฅS฿P:๎…฿ั ^YVผๅ{ƒ\\H๛uฌcะ]{4r f๊ BกฆPํษ O•!ต๐™œฌษฟ๙ž?B!„j๋š๋๗[“ฐํ ำmŸtD„B!„P๓ม๋!„B!E5๒„B!„ะ็๏@!„B5ึ!„B๊dไ2aฮผI}:|ฺXzึ!„B๊กฝ฿บ๏6ฒmB็๊ืพ๓฿๗x๓๒{v˜๓^ร„อ_ิำ]nPnw€vฎ๓F฿Kz™‘๒ฺ่๋ผอ๐sฅ„๙ะoOJx๑*3ๅษอ[Fvฌท๘Sผ%่9ฯ๛้g้้ฯฦ„-tำ๏}ฏ๒๓oญ๊ะฯหwห-หW„B!๕P๘๔/๏[๒Rjใ˜v~ฯž—ี‹tƒ;ฑูœบKใ]๖G"๐ำ2สๅuฏvg฿๖๋z?RโษŸO๓zMšน ”๔า}JDq3oณบฃ]๗รผพ‚ธŸ๗\ื๖YฟiVฆนใิ๕ฟฯ>LY“Zึ\\-Ÿwฟœใ“ํb ฯ}ป6*บฯ<ธิ@๘๒๊ฑ—šฝึœnศ๙gอฬ๏“›asฐ~@!„๚t‚h฿พ=“ษ$“ษmœ’าะ|ค๔~ร๚kB๎…่@๛^#ฦŒaึy๙ห};/ฝผ]sำDtyฏY^“;u์P,งปu๒3ไtฏ[?€ถQ'Cอช79…\ ุูู}<๓ถ๋ƒ?\eๆฝ˜Lˆฉpslา,ป?Bช?ลำ๔อ๔ลE๑G[พ๏ํช๊ฮ๓ถIv !Iช๗:Td‰‰yoImkยdิพ_พฑฯs๊~ฯฌ๐o$‘Hธ\nQQ‘LVoyS ๋„BกOวะะJฅพz๕J$5Rมเ„๓—_Rs็๎ำ๊ืทVู™ฎ๚  }ไมฤ=OถyŒตH$เ่v—”฿ฝฌœ  งง๐ ฬงvwCื๓๓ญๆn% ?mQ?mdxฺรžlqžGHQs๕@sภฎฟO1?฿=|ะwษ ตฒา2==}I๎ร˜4ฮ>€W๕%C๏ฑ๔ืฝ~ZทNX{ฟ๗Sิihh˜˜˜ไ&xฌB!„>&“™““๓ัโแCฺ๖CF:ุZQt{ Ÿ4ฉW๖ใทณd`้โข p7!AR๏ชคgู๔‘nณ7 |†h๛ยรšY’ƒ ๎O๏ๅL๖ีๆต —I=@p๛Ÿx๓๔๎<’๘~1k๛j๒ฟ๚ร‡iA๙ฃว™`ไเdB wํiG…da-#้ๆอฒ™ฃ&nฺลฟฃ3OK๖"ๆR˜ษkI๋ณ๙ทฅ=hy็ฏ•;›ไ าWDอ•ฟV‘HTPPะฉS'ฌB!„Z2™,”๎ฆ฿oIHอ๏/y/๑†๓๓OฮPmคค”4ิ=ใ—ฅA]ถ~=`ั†ขโgทoฺ|ฅ๚๎iน”฿์ฺ9%A“†อ_Dๆd฿ฐๆxฝ฿‚พ \บฐ๓Ž#gฌ๔พ~ผy[lไ‰y\jm_u๋jผฐแ–มฝผ~ๆbใ ฿ฏ็HŠโXใs‰๚Aสส˜0๓Yโ 9=ซ๚D"‘"ำ๊:๎…฿ั็E}ดB!„j;;;'๖(ฒR๋ไ›H]ถ]nžrƒิ๘œ@„B!„ขฐ~@!„B) ๋„B!„ขฐ~@!„jิb}}ิ:๙&R—motžX? „B!„…๕B!„BHQX? „BฉŒžใคoรOD_‰9วฎ๙}ŒH_]ฟ]ํฦๅณGCzฟ ›ภu๕•wห่ใcฆ฿ผ๊๊ฮgV|5ณ €0พํ๘น g~ tgฉ:ฝฦ#๔y,ฮ:x@๕K’ž_๗ฑืฝ&™}ฮษักๆ9ึcท})ๆt๘๊ฦ5OดฆZx/แ๘น+W/ž๚๙q๖ฺJŽ‹ฯC!„R†ืา ๚“Rc"/Wv๓3y){๒2€๒๚๓วด๏ธั_m |9j5WแuR๕ฬอt5๊F„ๅน%`คพมผ2%ึcง9Ž์Cป^็‘L๛N๘c`ืS/Šผฦtผถdไณ ็Fธx๏ฒ่Lฆ”ร6iœOอภc6…๓๎™}ๆผƒ่ษำnDeFฎฃ–˜คอสๅฅฯ”yZg9ซ35tณฟ๕Ÿž˜๘ฏ[b~cู๔ณแ๋ฟ฿4%q|Xชc€B!ค"6.ฮL(Œุป5์˜Tt;นะูญ'๙"็Yฬ๑c/ ‰ๅup|—.๐XแuRด ŒŒ4๋F๘ขย2Pใ`S๋‡ชJถX‹'ศdา คขขR2‘ษ2™R){|ณyš(tัOO”0ธส;,ฑั?๛<มฦฑ]๕kgฃsNฆ‰d๙ปnU7ำึีญสNอญจคfๆ้บ่Pœ์ข&—Šาฯœพป`š“ค)>4ึ!„B*ยb2 สู…็7ฮ‰gTน{mฑH กุšข์ม๚ˆ[‚Vฌ'H์k+ŽฆTฤF$mrฬซ(*ผrrHp๗‡ป=WฃโkKaๅw•jจ‰h๊kH5˜ฝฺ๖๊K—ฆ]–”œ.จ`ณ้fVฦ๔dฆ… ›อ`ฑXทฆ&“ล…๘=U)58€B!ิ ศ8น)))ูe k้ตoo๎่ร ธธDลนฉ7Fื€1†ท๘e฿๖;ฌdฎPป}๖ธIkcฬฆNี๙kๅชcฯ+TฅRh๖k:IB“ำส๊ Š›ฎ๔ว{ฟบsๅ_›ฬตฤท†W๙†Eฺ๎์ว“ฯ‚จำK"จI•หY„Bกึ@ำภ@SP–fใ๖žP•๙<่*“ฝ฿Zฒฌษฃe฿รฃเษท้oค7ŸOY๎ะ#:๗ูจ๏ขอ3YQaัฮsDล„ฌ ค๘]&*Eqทqณสฝ๘u%ญNX&ป““๐L(ศ=ฟ๔ขž!ไdˆ^Dอˆ„๗ฺี=tI&Uฎ€ภ๚!„BHE8.“ล0ฑศ๚ฦทƒ.ว๎ น”SY–—‘–ห‘”ณหXบ,€ฆงG(++kxจ…L‘Iฅ5™e2ฉ… Lฯ5;Gd๎ ุฯ๓ห๔Gฆ&O8ํ๏๖หฃ+bีฆช C อ๑ฉ–5ฏ]}ฺ๏ฟy>ึ!„B*’ฯํ้ธช๊ฟปŸ-=Lƒ+Tๅ&ฝ๛ขถefฮWƒฝฟู$Lิ๎ใJศrž$”ส_งL&•พ}ฒD&“ๅoงย8…ลๅƒํ่ง_+'[๖ฒฑ*HหNูžท๙|)t$H‘P(A">พฎึกhืตปชiŽว๛Šน| ภM๑๚=ปฝIส$›N7e=Lฏฏ"<}’บdฤ„ฎ#ำลฆCG๕แ&F)7A๋„B!แ^ิA2฿ื๓ซ)d^มƒˆ!ัลเ*ฏ%๎O๋ั\ไ๛ลˆก’7)B๖๙ขžฯีผคy ซuฐi^v฿๏›EKVาฅ์ขŒฐS €ฯ€œQ๙ม๛ฯŽ(ฝฒ๛`ำ~ๅIๅr_]ูส๘“—{;เ=ฮฝด&ฟ›ข๓"ท}gถ|ร‘้†dnV‘MG’•ซั:๎…฿ั็E5>m„B!ิ ;;ป””Ug” iฝาฦ’“{=ดยb™ญUE๎๕ะ7ข ถrฯj%„B!„๊ฅa8ุ‹Aฉ]hก บภ๋!„BŸ^P;$š1&qK$T#:M*โ–ˆe-l น VลB!„BŸ–TPศฏ~ถœ ˆ/hม บภ๙K!„B!Ea€B!„Rึ!„B!Eแ!„B*ฃ็8)`แ(—ฮn^โ•ฐ=awŠค@ฐzฮ Z6สัPœwlgpdZฅชำToไNห‡ููฑHผโŒ?ODŸฮ‘˜฿บ{พ“ๆ๋หม๛๎ฑU`#๚‹๚NYช2'ๆ๒5—nsOtิ”ิผ'8๔4ฌวnZ?รูH˜uใ‡ มื e@ต๐^ผb–—!…“ฒ๛dr…2ใโ๕„B!ax-ฑ`๗~ไ๑หนฬ/'oZ1L€๎ธ๙หŒ}ณฦŒ 8&๚jหL[ผึ$๚ฮkF2b ๕ 6UP{˜z้xmษศ]/‡Žpฅะ™Lชช๓T–นวl ง NไEฺ‘.พ๏rแ๛.ช‹JŸ)๓ด.~=fLะใฎ ํภฤ๓{›ง๛๙L\อ˜ฑiŠญrใ๑ˆB!ค"6.ฮL(Œป5์๐ฅูญ'zyyf}๔ั๋ ^ฮีใ—ฅžžVชฮSญQ;wดอL:WX%W&eุก$6ศ@F&SศdHฅ@n๏ธoฯิฎ4Ugชr‡%6๚gSณnฆญซ[•š[Q™ž™งซซ @upฒKˆ>™\Z%`งŸ9}WฯษษHฉกqB!„Šฐ˜L€‚r6@แ๙sโ•Eภ๒l/{]"์1}๛ˆืก฿—ฺผPuช๊‹ฉญ)&ทŸ8ำs‚Žธ(๕ะฑ‹—Š๓c#’ถm9ๆU^99$ธ๛รวžซำฯจึ–รส๏ *ีptโ1ชรฐq[L(Œ>;–ูwํ๚ฉลแ+W/‘ช:Mฅะ์ืt’„I+วwฑฤดˆ~(zz๘n๋๘jTฤท† ‹š)สบ๑ใฦ็AิY•DP%ๅ`€B!ิh˜h ส๒B!™Lฎธ4์*€ฮhŠHจN_Œท>2IำN็๒%ภ๘ฯณ์•fึ๐€lิwัๆ™ฌจฐh็น"ŠbBึ„?โช:WลPmฌr/~] PงดŠธน58ฟๅฯfpD/"ƒfDึํ.“ี}ิ5A"ษคสUOxB!คบYภยk{kซ:ิ†p8\&‹ `<28"โh€;‰SRBiืฎๆ@3lgX\\ขสีง‚/จศ,•J€้นf็จื๛6?ณ๕๏hริฐืnj๓ตบ‡กŽ…ๅ๘TŸ€ŒA\ษ๖‡}ฆ0tF;Žซฆ… €จท;‡รก1t4ช_๎ซ/ื^ฉ๑ีfG!„B*Fึฒณ1feเ:Q๓I‹็๖๔ \Uu฿ฯ„&Še[ทWOœิ๓Ÿ/ด\' &฿\—ฎ๊<ีš03;u”ฃฟYึน ฯnf๗^Gฐgมm>_  ’D$ E@๊ฤสํบถW๕"อ๑xฃC1—ฏ†/ล|ฌนล฿ผผrŠแDƒ„ผื๕t<}’บdฤ„ฎ#ำลฆCG๕แ&F)WกโI!„RLล‹…K^ย{Wj๎ต=A$๓}=ฟšBๆ<ˆุ] 7พ%h๙๏gฺ‰r๏นทT๕š›฿๊”>ฺ๙ทŠ›รg%m๋9๘|ศน•ผ์ˆา+ปŠT›f‰.ฅ๐tx[›.แ&\[•]๏lฌผศm฿™-฿pdบ!™›wdำ‘dๅNkN๗ยo๎่s‡ขŸ7B!ิ†ัŒฆํฌ•˜šฤWu*Hูููฅคคด่LOฯ>UI๛bณไชšึ๎ฝฉท/ผล~ืฒิe˜W_au—†ƒuืฉxฐแัๅvฏ;บjiZฏดฑไไ^ญฐXfkU‘{=๔จE‚ญใ๓ƒ๏@!„Caบa้iฎv™BŸM‡กv๚๕ชิ๖–C{XkึmIทฎําp๐ฃ5btน๋ŽฎZ†ƒอํฝ”ฺ… ช ผ€B)†ะ0ะฃ|k>ฮ&A๗ ฎ?,Cส/โ ๅNK!hฺFฺอใIตk3uฒ๊. ๋ฎS๑`รฃหํ^wtี"ัŒi4‰ˆ["กัiRทD,k‘`k ศ๕ต*vB!’‰”ถŽ5Hยcณy๕ฟ-T >lษใผ๋๒‘เวjฬ่rปื]ตค‚B~uส‚"พ ƒ๊็/!„B!„…๕B!„BHQX? „BŠกOXw†ซ–ช๓@!Uย๛B!ลP๕๚ทc•>๛-ฎRีฉ ถCฯqRภยQ. (ผฤ+a{ย๎I๎s๗|7.kฃ๗ถปชฮQYzŸ๙ฦ‰๕๖gxq๙ศ6พu๗|'อื—ƒ๗cซ4ฝฦ#๔๕ฒT;eNฬๅk@า๓๋:pฉ‰‘1ฉ๊e๑ฟk’$ a=vำ๚ฮFยฌ?lพ^(ช…๗โณผ์ )œฌธˆ'“+”๋„BH1ผ๔ญs HlŽช๓@mรk้ŽIฉ1‘—+ป๙Ž™ผ‰”=~๙y-Ÿตซ'นRS“ŠT_›Qx{z๐์ฺืf^c:^[2๒ู„s#\ผwY t&SสแU—a#˜{ฬฆp พ4๏ไDOžv#*‹0 tตฤ$mV.(}ฆฬำบ8kฬYฉก›ํฏ๔ภฤ๓หฆฏศ˜ _ฆ)‰ใรR•็/!„BŠ‘Šห_W”VถŽYDmƒ‹3 ฃ๗n ;ผwว_ฉ@wv๋I†ฒ—๗ฮดxIhbฝFM$™L!“I •นฝGเพ=SปาT•Rศ–ุ่ŸMI|[‘ Œอ}š&’„๙ปn˜•หะึีญสNอญจLฯฬำีี :8ู%DŸL.ญฐำฯœพซ็ไdคิะx!„R ำ6ไDึัSำŽ–ฉ:ิVฐ˜L€‚r6@แ๙sโ•Eฉื/@{Wgื†น‡ํ๘B*•g_  ’D$ E@ˆฏซu(ฺumฎ๊Ešใ๑F‡b._0SผพCฯno’2ษฆำMYำ‹๋้.x๚$uษˆ ]Gฆ‹M‡Ž๊รMŒ*Qj|< "„BŠแ$๘ค‚’๚j๗ฺž ’๙พž_M!๓ D์‰.ืี1{|ฐ๋๖0เE/บ3Nต™ชฑชฤ[๛์†ฌX๑M; Qqv๊žˆ'ลภ็@ฮจเgG”^ู}Pอ๏mส}ue+cเO^๎ํ€๗8๗าšzoŠฮ‹๖ู๒ Gฆ’นYqG6IV๎gๅ:๎…฿ั็E5>m„Bจ ำ4™ฒภF๓ฟ‡๎*๕จ%„cgg—’’าขC0=}=๚๐“๖ลf๓ๅห\†{๖Tฟ+7XKำฺ-๐ ๊ํ๓bห 6qŠ็ฉZšึ+m,9นืC+,–ูZUไ^}#j‘`k ๗๘ Fภ)v!„b4t]ฝปxXRUBAทq่>ิ€*?Hทฎ}Wnฐตฝๅะ]ฌต๊ 6qŠ็ฉZ†ƒอํฝ”ฺ… ช ผ€B)†ะะoO'๑*^ใฏใ &๘ืศ ƒ!ๅq…29Aฑ6K็ํปrƒตšถ‘6มc๓xนม&ฎS๑ใ๑ฅ iกฐ<๕ึใ"ssSU็ูๆศ@F&SศdHฅ@n๏ธoฯิฎ4Ugฅr‡%6๚gSณnฆญซ[•š[Q™ž™งซซ @upฒKˆ>™\Z%`งŸ9}WฯษษHฉก๑๚B!ค–ร๊Sฬ?~[วkUง‚ฺ “ PPฮ(<ฟqN<ฃฒ ,|ฦช๊๗ –•ฅAyrน*slŒรv|!•Šส‹ณNžบt&7?6"i–c^EQแ•“C‚ป?x์น:Œ*am้1ฌฮ RอuขV]&&Xษ$b~ฦ›๘I‰ฯ$l6ฬส˜žฬด0aณู,Kภใึต,.ฤ๏กจJฉมฑ~@!„#โผˆหะฬUฏH}ศ8น)œท/จฦฝ†๘ 8 eู™-็จ2/๕—}kึ$ Q-\‡mื3๎ป‡ฑgวา;๛ฎ]?ต8|ๅช๛%๊ua‘fฟฆ“$๔NZ8พ‹%ฆE๔ห €Dั›ะรw[วWฃ28 พ}4|PPXิLQึ7> ขฮช$‚* (๋„BH1•™วƒ2Ujร4 ฬ 4e๙%เฒไะfทผ่“Q฿†M}ƒO-l"qUqiอ์…<ัฯจ@ูจ๏ขอ3YQaัฮsDล„ฌ ฤUiž ฃธธYๅ^บ ฮœ+กˆ›[sฌp~ห/žอ4เˆ^Dอˆฌ]&{๏เ$’Lช\๕„๗? „BŠัฒšบ{_  ’D$ E@๊ฤสํบถW๕"อ๑xฃC1—ฏ†/ล|ฌนล฿ผผrŠแDƒ„ผ๚nิ<}’บdฤ„ฎ#ำลฆCG๕แ&F•(5>ึ!„bุ [‡$T ฏ~๛u๒ Uvึ0Bเ^ิA2฿ื๓ซ)d^มƒˆ!ัล`@šร๖๖ฎU์๚พฏซ0K5W•xkŸ+พiง!*ฮN๑ค๘|ศน•ผ์ˆา+ปช๗ตัฅดžฯ{kำ%„‚kซฒ๋-A๓"ท}gถ|ร‘้†dnV‘MG’e๕5•‹ ำ้๏^๘อ}๎PTใ๓F!คVฺ๕๕๗ฅ๐Ÿโž๑UŠZะด๙M7๚[แแฎCfgg—’’าขCะ๔-ฬ๕ฤ%ฏ๒ซX:่IJ^ๅs๊ึบšึn_PoŸ็›้้๋ั‡Ÿด/ถฬeธg_Aาพุl>ศ ส]ง โ๋””›g‹๎ฎาด^icษษฝZaฑฬึช"๗z่Q‹[นว็5€BŸ/F—.^ƒ;™RU‡บ ๊9๎ึŠธ๋P๋Fึึ34ิี$€ขฅ_ฝ๐j{หกฝปXkฦก๛P{*ะญk๊ ส]ง โ๋””›งji6ท๗bPjZ(จ.๐๚B}พ( †Cฦ+ชเ+wํ๚sEPu4 ทŒ'ล]‡ํ\ ศT*E&ˆคo›jGะดด ›ว“,Cส/โŠตY: )ฟˆ+” uส *พNนAนyถ่๎๚(อ˜F“ˆธ%ช&qKฤฒ ถŠ\Pซb!„Pณ๓x%sX? „ำถ๏แๆggLSM๗ฯ–ญรป๕นํบบŽš—žใคoรOD_‰9วฎ๙}ŒHฺฟฺ๑๛ูหฑWฮ;Kๅž Œ@วย๛เฆ ซํh<&ฒvฅMk~Ÿ5ฤ„๙๐mวฯ]8๓k ;ซตv„"ลCจ~Iา๓๋>๖บ๗ยไ!ณฯ99:ซฃึcท})ๆt๘๊ฦ5?ลEต๐^ร๑sWฎ^<๕๓ทใ์ต•๋„Rcล‘ฟ๏ž๙คฑฯฉmb๗ฯMIิ‘wป๋suuท5'†ืา Yp๏Gฟœหr๒ฆร๔ฬ—ฮะ๘{ัˆมรงํฮp฿8ฯ ?ฏ)สภy๕ผ€฿|u‹ห๋’ฯ พ๙๛=…6๋ภิkLวkKF๎z9t„+€ฮdช๏1˜{ฬฆp พ4๏ไDO฿ะžื/f๔Ybข @้3ežึลฏวŒ zuฟ=˜๘ฏ[b~o๓t?Ÿ‰+ฃ36MฑUn`<BHI*x์’JT‰.EƒฆฉAjl๗ฯ™ดฮ๎๚vดีloธ-ฐqqfBa๔ญa‡๗๎๘+่ฮn=ษ@d=t๔Rv•DT–p๏™ฌCU็ฉ6* ๎ณ๔—KI๏=ูฑไๅ.•%’ŠฤิY;}ŒLฆษ$J#p฿žฉ]ี๋นรณ)‰ูo_;›๛4M$๓w:0+— ญซ[•š[Q™ž™งซซ @upฒKˆ>™\Z%`งŸ9}WฯษษHฉกฮ?@„๚ ™L_ธ๕ย4We.ฟM™ฎK#บฮ>็]WwUซญํy“ ภ.gž฿8gฮC๑น7G>ฉ 4X]mx)ieชฮSmTๅ฿|œšU๕~๐อ๓_๎พช ศZ๖Vฆyๅ‘ิ{หฑFQW+'‡(>๐ง'๊๔3ช„ตฅวฐ๒;๛J฿>ฏฆพ†Tƒู๋ ืค!ณฃzุ[UฯUช`ณ้fVฦtz' 6› ภbฑ ˆบO$—ช”}>ึ!คฦJฏœๅŠr]สcฯ๘๎Ÿณฯyืีvีjำ{^ำภ@SP–_R!เ[ึ7ZCวbศฺํ›ˆoึ^-Uuvjฎ๊ฏ๋.5;8ู:‘8šXF6๊ปh๓LVTXด๓‘E1!kยฉษ->w7ซ‹_Wิs%“ษIx&”dž_zQฯrฒD/"ƒfDย{ํ{ฬ7‰$“*W=แ%„RcCวฬ3ฬ^ ๔ช^hzP๑‘’–Ÿl‹šq-”ซๆูŒโ†7S๑#ค‰5๎X’Kั2€ษb Žˆ8เNbt้?ฌg;‰ธYท•นปูื;๚8†I๗กu@&แg'ง—ูuฑฆ็šฃ^๏ ุฬึฟ๛ฃ Sร^๛๛ปฉอื๊†:–ใS}2๕s%๖™ภเ—‰dต•ไฝ*ก.‡Cc่hTฟ W_80Nน฿๘ย๚!„ิอฬขK/S]  ™ึ,4=จ๘@HInหOถEอธฮ ส฿ฑญ/ฯf7ผ™Š!Mจqว’ฟ—‚dาโใy`โธj๖ฬลซฦ‚๐ษรDฑคใๅฃํuH@า4๏๋า9/7ฏะวIฺ๗\โ็jฏI‚jfo๙Mi>pโ๖,X๙g2HI" …" Hฤวืี:ํบถ฿๒~ห๓๛-ฏˆ“$ฯ9t?O๒๏›bื=ปQ)ZšำMYK‹๋้.x๚$ีiฤ„ฎ๚tำrฤจ>ฤง%JOะ้ตƒ๑›;๚กจ&l BกO‹ ‘H “He๏šT| Fค$ทๅ'ขf\g‹ฑญ'ฯf7ผ™M<ภš๑`hxำฮฮ.%%ๅ]C็้๓}{uา'๓ ž]=r๐f„b5zร๚๎™PYš่ฤwม=ญจo ๔พ.+6N๗ฉp[uืญปำGŽ;อฎ„ฅ%้‘gฯœฬ~wซ4ฉใศมsดJcw†RฟYb4วใล\พ$ัถใ[kR2๓๊;>i†,Ÿ้ekHๆfลุป+ข๖๛เ๘ฌ๖A@ฆPjฏีุ:ง=ฐBกึEำฒ๒v๗2[ ๋แ=bข)Q–ิuเศฏฬ๘ฒสฤะไเเ‘“ฬชeIšd^ี<-฿ๅถTผ{ทจ9ืู’ม๗vˆZ'ฏ๘Ÿธมอlโึœƒ๎ŠCจึฎ]ปืฏ_ฟ๛อ/Hธ~๖ไฑ?8q๚๒ƒ,ž คe)ืฯD๙๗#วNœฝฌXูลYžC|ฟ2ิดnPโ6ุwRอปhฉxฐืฉธาป7ฏ๛๎ฟ๎พ๑RŸ>8qใฦ‘ท"<{ฮฎ{ปฐŒz%๒ุŸวฃ๎f๓๋[งฆ๕สn.โ์e—u๋ํ(ฮ—/m‘`#HŠNฝLฯฌู~Jั๓฿2ศHˆz]ะฝ’๒๔;"๙ใ่_฿x๚๖ม๑Yํƒ็/!„บกถณโิZดlบบ ้าž šึ5 ฤ [m๐“ั๊าอiจm;ช ฆuืw๏6ขฅโมf\งji6ท๗bPjZ(จ.pBฉ‚ฆcคE๐8ž„ฬ`2าส"žX[‡ษU๑2ภ 1ุ:ƒีไฮi^d“ษUq29AฑvํปhฉxฐืฉZ$š1&qK$T#:M*โ–ˆe-l ™ฟ„๕B!„ะง๓ ๊„M‘๚็/!„B!„…๕B!„BHQ๘๛K!คn่<{uฬ\!๋ห>ใLซโsคฝ๛๛Œ7ซŠฯ)1ˆมึฌ&๗๗mj%๐๗—Bจ-ขต๏๊ืัV ดํ{ธ๚ูั@หึกzƒฤ`ซ สฅ็8้๐ัWbcNฑk~ฃ:อHฆ๖ฯํ+A_ึ)†มi่ต—‚—žZ6jL a>|๑sฮ่ฮRuvG่/๒Xœ1t๐p้67c๘โ5o›Au# ๋ฑพs:|uใšGไQ-ผ—p•ซOํ8{meวล๛งBHอ่บๆ:$vi)[Ba้้ฑคผ\ถPGOŸ%ๅๅฒ๙Rภ 1ุ:ƒีป?•แตๅฤถคิ˜จ{•|ว๔b฿1~๙๙๊ง˜้๙„›nมืK๑vW%'›ถB‹‹-bBฃc^“l‡Nm๒pยกR฿รมZ;g>›pฮ๏ก๏šหb 3™RGจ๊T•bะaไUkฝJZ๚˜หื\บอ&ˆ๒ฒ์ฝF”~฿^•2+่ฌฮิะอไใ~z`๒U๘ฯฎ7–m>!1พ๛ฏ^,–Zำ^‘๛งี๊วfB€ดช<ปชzQRมc A,ู…ฆล์ฒ6ผ[hrหwAฉผ–rƒ-ฑED๓ญณEƒuwˆZ'ฏ๘ŸธแอTiโ@;–‡ ‡‹3 #๖n {&N.tv๋I>M@wž3งำ•๏OYฎตฌง/RตsGฬฤ……U2€ค๓ฟ “ LAF&SศdHฅ@n๏๑อๆiขะE?=||uญนรณฯl5ิL[Wท*;5ทข’š™ง๋ข @upฒKˆ^˜\*H?s๚๎‚iNFZค๘ะ8 !„ิ˜ษ๔…[.L๛‚FSๆW/4=จ๘@HInหOถEอธฮ สี ๓lฦ?qร›ฉ๘าฤw,ษฅ่?“ ภ.gž฿8gฮC๑คŽ_-๊๗,๔็๕๚BผubjkŠษํ'ฮœ{fวาศŸมํI๙ฑIฝท[`uตrrH๐ˆโ๏ีชxยฺาcX๙}ฅuฆ V]&& ๙๚๑ภ้‘={t#@›M7ณ2ฆำ;Y˜ฐูl‹%เqk:-‹ ๑๛ๆ„ลเ๕„RkUู)๗ซสDP•“™r_P&j† โ5"%น-?ู5ใ:[4(วถพ<›๑O๐f*~„4q ฦK๒^ “ฉ%ใไฆpช๕‡.+<:๗*่ˆFAท68:๑ีaุธญ&ฦnŸK๏์ปvิโ๐•ซ๎—ิw‰จuขูฏ้$ ฝ“VŽ๏b‰i2 Q๔&๔๐ึ๑ีจ ˆo 5S”uใวฯ‚จณ*‰ Jสม๛B!„>๗ๆ—๗฿t{หภิะ‰ณๆh˜h ส๒9ถหฏฎ0๙วง"}ฒ;†๗?4I;ฯi'- ๚-E๚๎‡V๊Z}แูจ๏ขอ3YQแœ็ฮpึ.Š Yˆซ๊\Cqw˜ถC|ั;น@Ds<฿่Pฬๅk๏ท0์<๎๓_ป„Ly ว…ณ๙ล{[$’LZ[=แ๓ใBจ3:f๎ža๖ZJtั<๊]—Ftœ}ฮปฎ๎ถซV[๓€ษb Žˆ8เN๊ลํM'†^ฟ}๛๖ู%=5‡ํบ}dVGUgชฦ8|€์kฉTLฯ5;Gฝฐ๙™ญ๗Gฆ†ฝ๖๗wS›i9†:–ใS}2๕s%๖™ภะํ8๒o'สษˆzปs8CGฃ๚แพ๚ยqํ•_mvBกข™YX๗โ&i(ำลิยบWEu—Ftœ}ฮปฎ๎ถซ8“6ถ็ำโใyฃ=}WUใw๗ณแฃ‡‰โ”ซc๛†Vฟืš03;u”ฃฟYึน ฯnf๗^Gฐgมm>_  ’D$ E@๊ฤสํบถW๕bํ๕ _Š๙Xs‹ฟyyๅร‰& y๕=eD๐๔I๊’บ>ŽL›ี‡›Uขิ๘8 !„ิA"‘@&‘ส>T^—Ftœ}ฮปฎ๕lo๋ษคฑ>˜bเ<=pพoฏN๚d^มณซ‡B,จ3๋‡fA้่โฝbˆm†ฌ8+้เ_ื๏–ฝ;~HG๎ ž๋ Uป;0ไVฉ*ณl”:๓—4tบms๘b S›.แ& z––Y฿?Zง!หgzู’นYq'๖๎ŠxZ๑๖-Eๆ/a€BjLืc๐เ>U๖“ฮWA๗ฯ ณ๏ ก}…ีป๋suuท5‘ฯgอ‹้้ใูง*i_lฉห0ฏพยค}ฑYฺ`_ั–uƒต4ญ{So_ธy‹ฤh๚ๆzโ’W๙Uฌ๔$%ฏ๒9’ฎ šึ+m,9นืC+,–ูZUไ^}#j‘`k€๗? „PงeำีyHCชjบnดฌkwื็ถ๋๊n;j4m†ฺ้Sn]ณP7จxหบมZิ๖–C{Xk6} ฒถžกกฎ&-๊…ฎ †ƒอํฝ”ฺ… ช ผ€BjŒฬ`2าส"ž Q“9šุsCf่0ฒ๊๕นํบบŽš่\ 3X †”_ฤk3u2~W(ซ eŠถฌฌEะดด ›ว“4q ‚LฅRdbH๚vAROKี"ัŒi4‰ˆ["กัiRทD,k‘`k€๓—B!„Z—OP? ิh8 !„B!ิœฐ~@!„B) ๋„๚|้ป9;ะลŽ๑–€n><ะ{ดpื!„>cX? „ะ็Kวฮn ฏ•9Mีyจ šณฏฃป pืกๆฃ็8้๐ัWbcNฑk~#๔Xz๖๖?๏œ_้ฌ๊$ีฆCฟq‡ึญบดu้๏ณ๛ป0€0พํ๘น g~ tg}ด{ซE่/๒Xœ1t๐€๊—$=ฟ๎cฏ{/L2๛œ“ฃน:ชa=v๛๏ั—bN‡ฏ๎o\๓ˆ<ช…๗๒ŽŸปr๕โฉŸฟgฏญไธj๕cQ!„šU้SหฏสสนชฮC]pSฮฬ!8lภ]‡š รk้ŽIฉ1‘—+ป๙Ž™ผ‰”=~๙yศy๊ิ฿ณT^ัษ๋[Oูแฐฑฅdซพc7ฐ›q”๋5ฆใต%#ŸM87ย๕ว{—ล@g2ฅŽPีฉ*ลภc6…S๐๖ฅy'๏ z๒ดQY„Q ๋จ%&iณr๙@้3ežึลYcฮ๊L ์oง็&๋–˜฿X6}E†ฤl๘๚๏7MI–ชฤภx!„>_"6;?‡S)Uu๊B*โผๆฒ+ค ฎจ,}])ภ]‡šศฦล™ …ั{ท†ปใฏT ;ป๕$ซ:ฉถFืฤH?๓YLQ•PT‘0ฅุบSŒLฆษ$J#p฿žฉ]ี๋‚"นรณ)‰ูo_;›๛4M$๓w:0+— ญซ[•š[Q™ž™งซซ @upฒKˆ>™\Z%`งŸ9}WฯษษHฉกฑ~@!„รrXu.`๋$ฐ˜:๕—sีxโjXL&ปœ Px~ใœ9๓ล@ว้‡bbb.œ9บnด hำ$œrŽฐƒUom€ldืฉฃถ–.ไวF$๕rlQิีสษ!ม#Šฟ้‰@ี™*ฐถ๔V~g_ฉไmDS_Cชม์uะknาูQ=์ญช็*Uฐูt3+c:ฝ“… ›อ`ฑXทๆqืฒธฟoN)58ฮ_B!„#โผˆหะฬ@eNN|\U‰Hี)กถDฦษMแ๏๐œ วษ@าฒ๐]ฝmลจ๛s# ๎Œ๊ฆud IDAT'M๙g๏ซ ›ึฏ–Tr’อ)  0v๛์Xzg฿ต๋ง‡ฏ\uฟDฝฎ&า์ืt’„I+วฺ Aqำ•Nบ๗๋2ฒ้า~›ฬณฆไT‚๘๖ั๐AAaQ3EY7~๘€ ˆ:ซ’ช$ ฌB!ลTfFeV/–\ฝฒ๛ชjณAmฆนฆ ,ฟค‚S\P]I@มษ+/&v้ €๕Cใษ\:vเ๒ *M*ฌขป์๋o!ฒQ฿E›gฒขยข็ˆ (Š YHMniขธธYๅ^บ ๎œ+™์NNย3ก ๛๗า‹z†“ z4#k๗๓ฤI$™Tน๊ ็/!„BŠัฒšฒ{\oœด„š‡ร`ฒ˜ฦ#ƒ#"Žธ“Œ‡ฌ=ูๆm™ ๛บ)a6ุฅฃพXX%`0๔*๘l`zฎู9๊๕พ€อฯlป?ฺ05์ตฟฟ›ฺ|ญnเaจca9>ี' cP?WฒaŸ) ~™HP[Hซ๊โp84†ŽF๕ ย}๕…ใฺ+5พฺ์(„BHล4,t’4TjCาโใyฃ=}WUใw๗ณแฃ‡‰โrm็แร\.g'pดlX&_yก๊<ี›Fว1ใฌJ’Gu๑่.๊ เˆ๗,ธอ็Kก#A’ˆ„Bก’ฺ”iEปฎํ฿UฝHs<฿่PฬๅkๆoŠืwู่ํMR&ูtบ)๋azq=OŸค.1ก๋ใศtฑ้ะQ}ธ‰Q%J๕B!คvยถ!I ไ…~„ยฝถ'จƒdพฏ็WSศผ‚๛Cข‹A๒ฯแฝฎ+VvฎMP”|=dว฿๕}D ){ฐ็oำU“ก ^=ูt"ฅ๘|ศน•ผ์ˆา+ปช๙ Mนฏฎle ษหฝ๐็^Z“_U_หผศm฿™-฿pdบ!™›wdำ‘ไ๚.UศGะ้ต๗๔๛อ}๎PTใำF!„ฺ0M‹฿tฃ฿นuโOีฉ 5fgg—’’าขCฐ<‡๗๋รOุwหะ} ๛ฎฟโท๊เ+G’W-M๋•6–œ๋กหlญ*rฏ‡พตHฐ5{|~P#เ!„bจzŽƒปนXแoiขึNำฆปใP;*hZื,ด๒เG“W- รมๆ๖^ JํB ี^@!„CPu4 ทŒ‡S˜Pใ}‚๋dK‡!ญ,โŠต™L†ฌฒˆ+”ต๊ P๖‘ไU‹D3ฆั$"n‰„jDงIEฑฌE‚ญ"ืฐ~@!„๚t>A€Pฃแ%„B!„Psย๚!„B!ค(ฌB!ละ',๎;รUKีy „*ฉีอ!„ Q๕๚ทc•>๛-ฎRีฉ ถCฯqRภยQ. (ผฤ+a{ย๎IAฃร €Us๛Rธฏ๎นk{dŠ@ีyช5M‡~พ‹๛ZZะE…™๑?œผ/‡0พu๗|'อื—ƒ๗cซ:มF"๔๕ฒT;eNฬๅk.ๆž่จ)ฉyOp".,่ hXด~†ณ‘0๋ฦ‚ฏส€jแฝxล,/;C '+."d๗ษไ eฦล๋!„bx้[็Fฎ:ซฎ5Pkฤ๐Zบcม ๎ศใ—s™_Nดb˜>€‰ะ7ํฎฌ™8|่„ -7{KีyชทN^฿zสNฺ๏ท)lg†ลสvZ`๊5ฆใต%#wฝ:ย•@g2[ม/ล*วภc6…SP'๒"ํH— ฿wน๐}— ีลฅฯ”yZฟ3&่qื๖`โฟn‰๙ฝอำ|&ฎŒfฬุ4ลVนฑ~@!„#—ฟฎ(ญl?ฒˆฺg&F๏vx๏ŽฟR๎์ึ“Lu่e—x๑\W(,O 5xลE,Z›BืฤH?๓YLQ•PT‘0ฅุบSŒLฆษ$J#p฿žฉ]iชฮT)ไKl๔ฯฆ$f7L[Wท*;5ทข2=3OWW€๊เd—}2นดJภN?s๚ฎž““‘RCใ%„BH1L}XGOM;Zฆ๊TP[มb2 สู…็7ฮ‰gTkKLฑj๛‰.ํDY7รท๎Žษซ:S5ฦ)็;X๕ึNyPA2ฒ๋ิQ[ค ๙ฑIถ๓*Š ฏœแ๎ภcฯีi’am้1ฌฮ RอuขV]&&Xษ$b~ฦ›๘I‰ฯ$l6ฬส˜žฬด0aณู,Kภใึ<๎Zโ๗PTฅิเX? „BŠ๓ž>ศัฮฉ:ิFษ8น)€๖Aw๊*Zผpอswm_2์AเนRUงงพค)์}5aำ๚ี’JNาูป๓@จถ?เ฿ูฬุทฌY**ZJฺ_›าพhัข~ฏๅฅขTา+ฅU{ฝH๛๒Z•„Rด#ฉ-–"ฤX cfR๎0๓๊๛๙‡9s๎=฿3s๎=็e๎ณู@#ไูถเฃฃzูy~kข๓ึS!้ฦ๋:๐}#“ กื—ด๘ไ ƒRI@ฆ*O3ฑ๓าOŸส^ฤYฟa๎‡ๆqำ๏๓-‰Dชต*~e$ƒ๓„BH<ๅoุาA Ÿ˜ดชŽชte!S( ž_I.ๆCqฬๅฐŒำ;Cะ“–Žฎ ~บu๎ะํKRtง‚ัg`=!P4ฌ—yฮS 8lพ๐ฟsnจ๗:ฟ็%-ชxจปXdฝ ึ5WnIf๕แ ึIfU๗ฟ๛\ฺ‹ …ตฏย$‘ษBdณ'ผ!„Œฒฃ†ษทt่'ยb•((*hฺ๏ผpแฌsr1ซX๐uˆว็Kz|}Cฎo}๔Uxœ €œœrปlืํ_ฐ฿ู๓MืI=žoœ}ธ`า$ห6sX]ีFM^ฏำิค1ฮฉร๕ฃ3หYN~B/๛ีi/ ‰\œลbัๅไiU/Hื84E]ข๒ฬ…Bต0ชlืฺŠฏฑ๋DM'๙ล‹า ถcVธU6=ฺฅ„ฟoฯ’6[๚$2Ÿหแpธ@"‹qท2นป๎ุU๕/ฝื๙มGBo฿šUgฒŽ^`iVUmบ–j\Vˆล+_ฟLZ9nZทXž๖ศ๑Jโ๒%*w‚!„xX ฮc’@ยีงไ๎w]b;ณ(ฅู1x็ภีm้ฏznกฒ u่–แ๘๛KRณ'Pmๆ๒‰tNvฺหอ—ห€อ€๗˜;\๗9lทOพท‰{+๙พmฯก!รe’ธ์ปn"ฏฦส๒๗ฺืuใG5JI๚“3›ฯ$H๖ณr$ƒ๑ๅลุ…‚Ž๗ธBกŸ˜ดึฌ%]ค?;%ัฃ–๚†‘‘Qbbbณกh;zะv{Ÿ๚Œb]ท^ปฤ4v‹%m0`Eฉˆะ{Š้*z:สผ4f…ขฎฎ2??ษโKฐธ๘qถ,iร5]:ฑ2๏๙–้นt5(หผ็๛‰,‰ญa๛nŽ€๗? „Bโก)๕ูฆS›{ศ๚ๅHw้ัkค‘ชHVำ`bƒ‹%ฅn8ฒ‘ก4Pd•ีิ”คI@•Qฉ๚Gขลลณeัิ~ำ1(G๚O3%ถx!„‰ฆขฮ —–”แ%L่ฟ๛็(rŠ๒r‚๒žฌ‚‚œฐ<ท„#l ‘#l`๑ฏHt9 R)ซค”OขHIQ…ผJฎ ๆพ$‹‹gห"ำ5้t>ท$Ÿ/ฅม  ธ%๙๏ู๚๘ธW| N์1ื\ƒ“~๏;๏ๅ@Jo๘๒ี๓ฉQY้O.x๏พœ ัRใ!„;}๓ึ\ri๋ธฃไฎฺพd09)ิvywป‰37“3ฆบ Z3๑~๕ฯ–2๚ฎ๔™”„ฯŸnMSง^ลGvŸฝWJึถžvzhท+๏rNิฟปาอด q>พอ†‚‚€ลโดtจQีฑY@eeืผิ้0‘0็~@:IcEฟ๑+ต’็gฒ:`ึ"™›๓'^—Ÿํ๋9ษ๘?oด&mXฉs฿ลqu*ฟhฟ6ฯŠŸz8I‚‚๑๚%„BH<naQ๙งŠึ๑#‹่็ะฅนไ๏z๘่ํ“€anู›"`ๅUษ—:ฅ๛ใใW3[:ฮถญขผ˜ว-ญไ …ผฒJ~YY9„ คPจ  จฌุฟgv7zK*Š๎ส.*ืใ3j^›ซj<ห|ฬๅWr˜ปšŸษURชศHส,+O๙ฅคค ีำิ(.๘rย็Šสโ”kWฃ”MM5$*ฯ? „Bโ‘5ฟฃฏโอ‡m๕jิ๊(*(dไ„้๔Bฎ<๗๋ป4‹“ฅ—GTดTx?‰ย Cทธฏ๖ ‘ูwWŸMฌธsแ•ื–ssสgz๏์๑t๗Šsoาฯจ’ ;ูŒ*Š๖Y๚PuŠด M@S0๓้jfอคdGนผJH”3ฺh2๔ดŠ‹‹+KKชŒZ๘ฤ{์SฎdM ฯ? „Bโแ—ฝz“๕"ืาq Ÿ”•™˜˜˜QX๓ฑต”’า’Aไบ9OT{t๚๘ข'ไ๕\7L‡sg‚)๋Cฯž-qนทะโ่ฦ๋:๐}’ k'’จ–J‚ƒO๔{๖Liศf^ฤYฟ ปรWถ™ฟ9x๙-‰Dชตฟฒ‚+แ#1๑B!$ž ๆ!_fK~bาช:ชา•…ฬช'œSฬญ,?>:œำาaตy2ฦ&6ู/7ฅ|d?x;หตงIpๆsŠ†๕2ฯyŠ‡ƒอ๒wฮ ๕^็๗ผคฅcตKƒฬ›ฟ—ิพๆJ(Œ๗†#ศ8ล|SY >ฆp฿๙ปฯ๕‡o๒}๓@p2Y(l็B!„Z‹U  จ iฟ๓ย…ณฮkgFfฆ%ฯžแญFฅP…A๕Y(ะจR `ปnว๘‚ฮžoบN๊๑|ใ์ร“&Yถ™ร๊ช6j๒zฆ&qN6จล๘่˜Yฮr์Bฎเ๋ฬ€/uฏ‹ลขหษำช^๚ฏฝqhŠบDๅท™ !„B่g“โE้1+*ณ{Œํ œ็OใซฏS๏ั]5แ๛–๏งภสษ+๚อxˆJส"J'ณ.ูษ€UธgI›-}™ฯๅp8\ ‘I ฏซuศu๗ภฎช้ฝฮึ8z๛.€ฮง<?ฝ๚@ัvิV|š’'b๑สื/“VŽ›ึ-ึ?…ง=r€’๘€|‰สว๙B!„P )นปว]—ฟุฮvฦ,Jivฬ…มีƒ>ชฑq็๔”nหฦ๗sH‹๐Š๛วฒ•k‚โิรWbs€]๕—๗˜;\๗9lทOฐ3ำยถส g`vP›ykSไMัY^๛ฺปn<ใจF)Irf๓™ษ~VŽฤ`0พผปpBะ‘€6B!„ช—‘‘Qbbbณกh;zเ€Š๘wำุ‰Ÿ๚Œlอฉz—0๑+iCซ}ค"nTฒ๋lYา†kบtbe๓-ำs้jP–yฯ๗ทY[ย๖๙๏@!„๚ฉ0บ๔4ูUUŠ8‘aุใหป„‰_IฉŒ์ำีPบลืูฒhjฟ้”ฃ~ง™ <€B!๔ใ€๓9Ey9Ayn GHศ“UPVฝK˜๘‰.ง!K*-.)ๅท์:[™ฎIง๓น%๙|) ]ภ-ษ็ ›%ฑ5็C›š์ „Bก†๐K‹‹JE'–ฒพผK˜๘•ฐฒ4งฒ5ฌณe *sุU!Wๆฒ+›1ฑญภ๋—B!„Bโย๙B!„BH\8@!„B‰ ็!„B-Feาม{mšbMฆซCŽอะช7‹๊dŸˆ0›๊'หuเdๅš7;ฮ?ไjN hูฑ๗฿๋aแกW6Œ5 5Ep„HŠฝ็๏:sV่ีใ›'w‘i0?นƒใษ‡a๎V`ฒ๊zฤร/Bึ˜๊!‰,$฿c‘_XMM๏ŸF!„๚%ศY๖“Oส่iู‹่™ 4:๚ํj s†xจ๔้ฃs>^๊ใ ฏžป>Uะq๚๖ฟ\ํŸ,๖๕$ใFaุฌ๐ดJ<s’t๛ทฬ{5ใŸ$A=๙•G-›.“S;”วfฯ>•Ž!ีSบฮ˜๕k๚I%ฝสmย˜๐B!„P๋Bึ์r๐า๐ฐ ณป็›)U%ชXืละ;แ7ฮํ[ิทๆฌYหvล๓!aแ!็W[5pธ\สยR๗‰๏๙3หฎU Ÿฃฃ?˜๖ํM๎ำทsl๔3.ะzY˜ผ พ”๐นขฒ(แ๊฿˜์šฃอŠƒึ^ >๙ฟ”ฆฉฅู@ิภณฯ สJ?†Ÿฟ-ฐต5จ/7รษฉC˜Oณi ICชฃ๐ใ–ฏ๔/iย˜p€B!ิชศๆ์ึๅ…งร˜ฑ }๒GnZะ›@๎=mฟ7[gŒฑ_pบิnอ ใ๊œ+ึฟ๒r=jฺฺ+x๕ฎ•ljู5.๚๙ำ˜< หUIฬ่่ฯ}๚tŠi_“„่6€’’ReiI๕ณKbฏœˆฌ+u0ึVT2์ชว Xปไีิ…๙วmฦ่ๅ็ๅซฉฉีผŒeƒ๘‹ใิNีw<zใฺy฿ บ4ATm=$‚าห’๎ŒJ/k| ตแ๕K!„BญŠn็ฮ๙Q‡^UD{A_ะY^ผ<0s”•qb^fธuoz]:็Gz]ฬHOอๆิทRRห^‰ัปล™O*6YjžHห€wัั4—>:๐ZฅฏyF๔‰b ‘H ;zg๐j ‘ณฯ-r๐K€๔+›ืๅ–ว?lšั(N็๑x4๕.ฆฝdธ™\):]d^•‘K'sฮ. /†I_าŽ:M;OฒŒžZฏีใฃ^ศ•Cj†าEภ๙B!„PซBฃQ๙|~ี<Fฅ€ŒัDีc h<.INžUฝKฅ~อู€ฮ––Zว฿พท€B‰ณTผpญ@๘::Z}v_ๅ{ส}*Ÿlb…UฯA.ปแ6๘๔^่สฏ9ฏQ’๚(4ตษjYษแP(”ฒp๗Qแ๒จ\Žจวจัอœœ:่ฮP๙šสeๅeณชอพ๖nz็Ž.ท้šฃt๐๚%„BกV…วใ‘)ีc4 …ยใ๑ิว,›V~dดKN%ิไไ๓๙_r’ษ๕ ๋ด--ูพำŠ0ดw่ญ"#ซ3xฺo”Sช฿ัŸฒัkอบ=+†WฯT}'[Wท๏%๛ๆู๋วำ‹xฒๆฃG๕Qcะ่*ว้”๐๖ฏRs”.^ฟ„B!ิ’hฟm๘ญ๊฿๗พำ็žอd…ุcฝ็ลYJW›ทฦ ฒoฝfปๆ๒-็ฯ//๏\ํ=zวแ]เดไ|จ฿น›^ššzaใฟ‘ใ็Š*Bึาฒห›‰ีฏสโ_ๅ,ฒ4!E<”DGgฌ3ฯ{๒ฒๆGAsถ๎ิt]{|–ๅSB่๖mมŸซ฿(สHส.Q+—Y๏}โc฿฿็ูู๕ิตvฬ่=N~๙Yาขดท™ล*ๅI๋+จโแัฝVป jGฏฬMธ็ฝ=ฐ ~dถ-‡$ข๔~kC๗ุษภฎˆQP์2rว“FฦDb0พž„ปpBะ‘€Fฎ!„B‰bdd”˜˜ุp>„Za๛nŽ€ื/!„B!„ฤ…๓„B!„ธp€B!„ฮB!„Bโย๙B!„BH\8@!„B‰๋?Aอ|PCบฐ๚'๕~ภำ\Šฒaฟพด้ยŠข์„g1๏ ฟ}ปzŸ ฝKo฿N,ฑVบz~ๆ†j2‚า์ฤ˜˜ไBžจ‚•.มโ!„B:~๓ใŠ_฿ผ๙†U;Eฺภฌทtๆ ;,’bW›กfฒ๎ผc‹ฟBŠŽ™•v๑ใ[ ฉZfƒ๔(y๙YHX!Qฅ‹น8B!„BฟI็jๆใอหรCJกึi5๓๑ๆ์่DESSm้ส์(6ธฆฏdดด…>ภ็ฌฒฮrฒl ษ๊˜Z๔าW•v™€ฦKนธ†ŽN๑๛ภ\6 #1ญงตŽาหฯ…"sำu-†๗iฯK‰ผŸ']:B!„Bจฎฆ: ะฑ)"์ZŒ\แCปkฆEg‹œ@(t>ษH(ไUฒr“Ÿ?{Wศƒ‚๘ะGีoาฅ+?W€”พ™…jมร> ๅ ฌ~๋(ฒdบŒ ฐู|ต๎ึๅqฑlถดŠ4@!aAt9:TไฉวโาE.ŽB!ิ|>ŸFฃqน–ก๏ัh4>Ÿ฿`ถฆš?ฐ>ผ๙Pฬ(ส๛$4‘g@6๑!Oฏn'’€DU่ิฯบฏ๓vRPdี๕ :๊๋j+VผN)yee63ฎ Rภ*.ญง" E ฅ•ีีจtA ŸBกิSฐ=~Tฆฤ+ศฌตีึ-]ไโ!„BQ\\ฌกก๑้ำ'6/x@ญNืาา*..n0g“ ึ’ศ"ีIภ)/ใT[–œ^hคคPFำ4nฅUšš๎q<๓3[d2Y(ˆQ0Ÿฯ'‘ศŒˆซR†dŸ/ช เgฅี\Kฝ8B!„P#ไ็็ซฉฉ้่่T๒Dจ•เ๓๙,+//ฏมœ’ฮ„B!‰Dช๚ห?ต‘ษdศqฟlKs้ค‡ …ี๋ €าพ‹!๛eภรTNํฌ‚† ชQษf“ฅฅi\–‘.gณETEJA[[™—Ÿ™WฦQz=‹#„B5‚P(ฬหหg”†P๋$้๓สสสไ4u”าJ๚ฝ{ดง}I—’W’กศาZ:๊ผยBQงใ*TŽ5ค)d Cี@O้ำงB)):ฟœอ๙.kYI‰ฌฆŽ2ƒก kาM›Fธบ*นYYJFj *MNืHŸœ™Y$ข P่lekูH๊™a้ขG!„B่W&้๙vj\B๛C์บฐRb’2;ีคำ4{ ฿Ÿส/ษMŠzš/ji^ๆซ็Z}-FNฆ๒ห?e<y_ Cjวำฟ!y!๊cEฺซCฦv-NŒJศ2่.:$ว็ัJ๚Žด—”f'Dพ,QTฒ ห8าขา๊s$$ยาE.ŽB!„ะฏŒฤ`0พผปpBะ‘ษWR๛G]B!„B?๏ๆ’^ฟ„B!„๚u5ษ๏/ๅ?ฟฺ๋A!„Bตjx!„B!$.œ? „B!„ฤ…๓„B!„ธp€B!„ฮB!„Bโย๙B!„BH\8@!„B‰๋›๙ง‚##/Rก „B!„ZyูJveํ •๚๕rtiบNg๒า๒Š2๖ !„B!ิŠศ+ห›๊“›‘Ÿ•๗%‘ฤ`0พผ P(]๛๋tึฃKำ["B„B!„Pkมฉเdฅ||_;๑›๙B!„Bี๏ŸF!„B‰ ็!„B!qแ!„B!$.œ? „B!„ฤ…๓„B!„ธp€B!„ฮB!„Bโย๙B!„BH\*•ฺา1 ิ2ศ}ฆฮฐ๋%—๐‘%h้`Bจญk+;ี–ณญ|Jจฅด‰า4็Htีe=อฮZXœ๊m<]'$จ•ขต๋zลาาS“V๕R}์†}ž›ผฝฆuฌg๚คำL&3pก๚‰ต. Mฏพ}\ฺต๖}šโ€mQYLf”{๗šu—Swb?คผ}v๋ศr+ั9้ํท๙?ŠONŠฝ{ฦmฐ&EdN’ฮศM—ลฝK๛๘๒มฅ-๖๚T‘๋W/๗&3ฮหชฮV„3™}FJบB$ฦdห+:[4้JลฺฉŠิิ฿;นoNiธ IDATzKห+ต”๊ผ๓}œฒำฮ1kฑ‡z›Bใ>ฅ:š-NิผD๎๋k!๔I'˜Lๆ•y’ศio0ึ1๏หWkš~QMAฑ]Eถว›<=C๓ๅํUƒXนeMฒ^„šSฮIGซh=rVbjKG‚ZฉสฯgS9•,^Kว!š๚ •ฮำ;ห”ึŽ‘jใvศe8้ฑฏืmi๛•Žk๒ž๕t? 'ษศ๙๘ก9 ํ=ฏdท๙๘_™–Sญ“1rร฿‹ฌ+ŸsOvฬ๒้ v- \@”ยฺสN๕๛8+Ÿ๘ฎ\จ2h•‡ฝ๎—L„‰อQz#5[œจฅ4๏vDetS n๔jšๆC^~ชWZฑœŠฆ•,YB่๎๖ˆ๙ภ‚y—โž๛Mเไ๚ญ‚N ฺ้แะg‰ฉ๏_E๚o›`Hกฆขฎาas๏>็,๚ะ“ฏNา]สd23ขn฿:6฿เKฮvVœ ‘œš๛เ๊ๅƒดฟู>ศฦ.แ™ฬไSS5ส‰~๒Nๆ–W๚™mํฌำ‹๒5•ขoทสใท)๏โœq ฺrแี1ถ5g๙น๎ลญ•จIญ$ํํ…ฝžGo>  าฝ›qNใqใป’bปl๓=ดfใฟูt๋๑ฃฺ็T`ฟ>ิw็ฟภเฐ๘‹(]bสƒ7ฝ|Ÿ๔๘ิผ.T›‰ฬจ5(๖ว™L&3qง €ชๅRฟะg‰ฉ๏_?พๆ=˜_Žแ—’}vกqk?Qิj(v|H|๊็d& ๚{'้ฟะำ1๑ท์ปNF'/ํแล‹ƒใ k/C˜( E…๖kMฬฮZ๔=าซํ•ฺจฎ‡ึuฺž '‰้YL&3+3“ษ<็ +G'"N์คฺ%›uWc฿'?ฝฐคง”จBาๅy9๊mJ๊๛๋๚}YฒฉถŽฆi”œrงฬL6hiVๆ๛eTŸ|ฑฑะ)จิฒswาฮe)Y ้'Cถ้„ปฃ Ž‹|?อ=เณศ@Dฮ& ! จ8j๖ —edFฑkฎ$|Ÿซซ๋‘Nํœคn~k~SŽน๘-งcๅLŒๅk_xจ6yร๏xฯ๗y9ทœ่gPr๔y๔ค่77ฟ+L๔๔๎๑x™M๗^ฃทๆL>ไjIjฉ๐jค๙Lฐr<๖บโ›ฤŒSsฌฌ†mšึF‚โโRโœํทaVฑษžG7œUณฒtttˆsๆ?ธqใiล Oข#Žthๆ๘/E”.!ฅKfศ>{œFี๎พx’7ธne^žpuuuเŸ @๚็qw;ญ”3๗f๕pุsly๊ลUฦฬ^'ะฒ~๑JฝEก์‚ฃฉc8Pz35ี'๕ร6€จt์อ_ผ๖†q๏:๕ฺ„;UPฑ_=‡zๆ[พF•N™ถWzๅ็น-ดุุฮsว"พwั!I„ฆ6GK†W’y"ŸKผ๓o 3บ่๖ฅ–ž๗tnฉดฌด4ˆ่zจรV๎ša’slสHวำ๏Kโฮฒrb€˜!์คฺฅัk–้พ‰N%ททu[2œJBdวli€๔หร[๖ฟcW'งญฃ ปฌฆ™?tQQUญฬ๛ย-)ํ![X'ส๐ำlเG^$€Fฃv25S€ยGW= ิ๎๚ศ็l’ฐบl2”fŸฯษน˜_sa]Yยญs็ฮO๙ๆฒ ชฒ’UVIบ,แ๚๎N>I_"ห ^ณfฐ๔;Ÿ๕Gา„๕ๆD?3ƒ๎ณ๏\{ฉข<3,่1ฃG๗V{[ CoุาA1ัGง้~~ฒkoP)q6บ |]ฑŠ<๐ธt)ฉzึšฒyB็ฑบK|šูฑizข’ป;wผ๚H€ŒŽŽ2ไ>๕?_ Lt๎นsOs:™š)AัญผŽ๘l<H๚˜U฿ำQxcง๋>ฟ]b่ZฺสMาฯS๒ ๏S @XŸ—žWศีA@nศv๗ฟ N“— ๊ต wชภบ้ตl็มmฦPฉ*Aa ‹ค9+๗œ8ฒ/0 @OO@ไ๗.*$ MuuM)์ภดœฑ๓o$ช<€D‘ฅ๐ำ?e๎Jฮ(ชt^ยƒ;™%น้i้lำฉƒT๒KชF๛b}t„ฐ“j#*b๖.Xโฑ๚XMMM™ธ…่w๋.…ท}v8๊ํ_(๑ึAณ4์น^T‘3PงPศ†;kII5<€?z๔ฮืตHภะ๘ำ\ ‚้๚2ƒx))€๒ดcoฦ๒@Jdeุ89 m0„๊๚ฺ>I$ _(lxnจ๗š ฺ๋&บฒuVค฿ฝdกฯ‹ชฝธ๙๊}ๆ/ถœyล™ณๆ 6ฺถซ๖nFใ๓ช๗๋<.V{ฐ-ฮ๗^QมMKห{8™ฯ` •Bิตkฯ๖ํ้ด†ฯB๏ธqฃพทฉW\[ำK*๗ูีN'ฐD5— d ๛บ“q จฯ เp๊ปฉรใะZึฯ้œรIFงฝ๊ษผv๔hq‚็sy.d’ˆCZRt).—59้๔๊^P(@ี็Y{qQฅสh6๕tะ\.˜'ฆ'U–้ฏฌ\‡+เ๑๘@"‘@ ิ{บห๒!]T4iy€r’ศ™(qHี‡ฤl` ฏปL 4#ฌLŒ^@l —.,ผšฏชง:อฐ4ไe๎Kfพ#< @โ}`ฒ฿๖๔5ป๘cไัGใj๙๏]ฝn-่ป๖YQPP @๒ขัจ5อเซzทŽ:(๔ŒW(qOe ”คฟูอŠำุNRnn๘ท<ืพ™'˜›wRT” ˆ))aืY฿๕”1๏c&ฝ&๑qp8\€ย๋ซ‡๏xZP\ ๙Gq7ิฃฃ_…“ำP1รทํS( ’IP5ัญ/้โช1—ึk๕๋โํ9zร ปำŽื แฬก๛%ƒ็-๎wใI%qฮห_ท[lดm‘GฆT_#CกRชFU_5๘ฝหหKุอผSLฬ๛๏ฒ้YUV๖DddQyy+ixw฿ืมฉ—l%G๋a ”“ษ’–ฆ@hทืศศส"ฬHท๗K>8๊ๅK{ฟ,™Lh`cขซจเฉT pนU'ํ|>™FฃT๕V@ŽFญ•“'zq‘ฅ|ึŽ-f5๋|๒B€Dข’ชฦีD4@ืZKpสXMpี}ดž™&๗ึŽ&;็L๐_ก๏uB๚JฌVž{ำnผ’ฦ8๙œใ%MyOCฅ ?ๆงฌอ ,#oฅำiพŠdีํ๙|จซR๏ล‚=ฆŽ็6pRD๔GWWิฏฐuดBqๆ&j.อก}y่BC[ว7ค5jหะœzš;€๐Sํ7l J22cLLl:wพ—˜๘%๑›๙ƒๆอ›/œ@wๅ๖ ๕TT”jงษฐ7Uํj@P2ํเ`–y>ขpข_๐ด‚Kั๏ ว(ษหซนฐป๔๎yฬู่tฬ๎Ÿ4๙I"sขŸYjBB๛๖ฆgIdX้ฯKธš+ู๒%%์ฺ๗ญ;่ฆญ}1&ฆมษC†o”!ู + @ฑ๗”ล‹-ŸSQศVํ;gฑaUฆา๘€3‘ ‚œมม)หŸ๗ZrคขC{N๔฿กyฤ๋Œ‰|ฮทณ˜ฟm-ๅ™ส่Q2P๔<๖qฮ%ช€‚ๅŒ%Žฦ:“๛dฤล39นzฺ,๒Zฌ‘ ้>aiqq,?b™{ฒฑโDKf\|~ีโŠf1ืXkR?€ฬWฏ‹$๔~eœL6dวvะVฎ„OฬgDดw”ุ๋#ฉe$Sจd +i๋uถ์kฎXZ)o9w้ wฯฉ๛ฝ‡$แ…_œ–ีณ—H}อฏ™9„qfu4ตฟถroะเเ หz}#๘ญ2AbผุmŒาฮต‡Zqง7l€WศJl6t่0น8ƒ+ไWeผŒŠอ$์Qˆ?บร้FuใLŠT›DุBฒ33`5rลถโ1šƒ{W็”h๋จ๘ZคนHฎย‡t!€ฐ๒$A•—‡ฤว;ZY‰œ?ศสา‹Šš๓—W+รtB8oใ‘๑tv๖๋›๛Ÿฑฅlšฑ@„€[p1ซ*-Ys™ฯ;ณK- ”Tญ๔๖0แฎร!d๑ฅˆ๐ธ ๋CLY5QOYXtk•ื>ิ\+(L=ถ้ิœง?6ุŸw #ส‰~*๒NๆGU]Iิr”~๑*ฐฒศฃ[Ÿ}พQหTyYOฯ.uŽ”‚ˆ’6ƒAp…’<ƒQP*โ.…๚Mเa_uJDyภ"ฌ๓‰'๎h ]ๆQsB%็่๓3‘*9;฿YiืŠYซ๛r3Ÿฝ`อฟู"ึ้๒๏ชฅทฏถŸปฦFP๐.xงงื โœโฯRฎl?จ7ŒอŠMฃ99o.ญp ๚ส^ํหŽjlšaoorฺอ๘s๖l๗>‚ผ7๋=๖ล๔ ฉ˜;ฎฅศNนฑลํฏ—’~ฟ.แำ๏Ch๚ีtg *‚K˜ฯJ:h ึGธSM#ศศพฑkxื•‹ํŽฟดy๒่ใฎใฬUนŸC๐ฝ7.ค/Uญศ9‘ซฑUณ์vyปฅ‰โ,ฐXไํ=จ*ทษ,o๏Y)โ‚Sz$Š?€ฒจOJฃีtl่T!—•‘rถXบDฅ‡]:`ๆๆี{‡W/ศ}ื๘DวV‰?บ“qฤNชm"Žฏํ=8ษะฉ็ฐฎA๓จ7€xD-rตยŠ[ษIสŒMฅR/gW‡ธŠสหฅฟฝ;Žฤ`0พผ่๚s…ฦ+ต~ญฐ}ถยาัึศ/ฎ‘ํSข Qฺฤต„q6e๐ฝcn.ฅŸ˜หเ y[๙”้็k6โk๖๖ฃJ7p{ไึ๎า๏“๗ผเรx๙ฉ“ฉซบฬบะ|GsพฦะVด๐'Oฅ)๒นล฿๖๚ฯ๛ก#„Bก–‘z2pŒห่ฟNฅ‘€ฯฮKบ๑ง๗u|/jzvร>ฯM^ำ:Vฝพ?ญjeY้I/ยOaฉะT๕l๑ํOม๑ไรˆ0w+ั‰ฆซCNฮชzฤ)ฃ’ำW7V๑qŠCฦๅิุฤ)oŸ:ฒJEtขšี๒#ทbR?$พธsสลFY๔:[ถ%ำ;ฺo๓Ÿœ{๗Œ`MŠ$9U‡{ŠKMKz|zพq= "๔5ซๅGo?K๐!แ๑๕‹mดชŸS"^ฑๅ๖Ÿ_6รฑž-2บ O:มd2ฏฬS1ลิ‘[whgน๔๐อ˜ท)๏^E]๓v่&๓ํBŒ'1๏ฏ่\{๑ฬ 1A๛งui๑C#ช‘๔๔ณLf˜s‡š๔โ™‰{~“ฦพŸž๒Y‘:อx พ%G,’5“Œ[๛ถdหZำย‡พ‡ไC^tc๘Y๙ฤwๅส@•Aซ<์EOEPใจZ้แ<ฝณL)๏๛w/Nธœฎzh;9ตพuˆ•Sn˜็ษM(/ฮ๛ะฯŸ์~”๕ฺt๕.ไœtดŠึ#g%ึ^4/ฬ{{(ซ฿|๗้๋v- ณƒื๑61šฌŠ<๋K>ปธ˜]!ๅQหฆหไไ}›Ÿ0ธlฒzๆน๐ง:oตTทC.รI}ฝnKฏt\๋—๗ฌง{Œ5AโซžGืŽ.นฝg๋}‡5S\ญ‰6]Ygซ€–nษ$#็ใ‡ๆ(<<ด๗ผ’r็ใeZN—๐YืD9 ฦอ6|ฒf๊‡ลืฆ ั:žฅฯa?่3Vใ‚B?9นQ[Žฏอ‰ฝp์J™บูoซืŒน๖่hvKG%‰O~‡๎Uo'ฅ๑P™๗KŒ.’ฝถ$Qk ฬ>?ห๙ั^วว ž๕ Tนภa๗๑โ$๋-ฯฟ์๋dFL%ท๏๊;€ี'ีฟOํ๑๘ึ์‹-๚(๗FีˆญŸU]kPTR&“๙ck๐)ย๏ะฝ"ฝ ๛lM0๋฿ขŸg๓lZ”yฦววว'$‘ P๘๔’ฯ•%ช–KBŸ%ฆพ๘š๗tcุ์LdFญ้@ฑ?ฮd2™‰;m@ช๛œCทb“>|H|๊็d&ภK{x๑โลเ๘ย:ลužw1.๕}๔มqํšขชฟ4c[s–Ÿ๋W๏฿~zไI๔ร[ื._ผข พuˆ•ณ็เมชyมรe็Ng—Mgฮ฿ส‘Rฉ>}‘‘u๛ึฑ๙ตณ—ผฝu๑ัƒA๏๔๕š`oณ'‘ษ|ดvฤคฟ๎พIMŽ๔จ @ุ>%hดmZ;๛ืฎq~eอฯ%0ฬœ:„๙|ณS%L i๕pั p่ๅy๔๋ Iญ$ํํ…ฝžGo>  าฝ›qb%xwy็ใพ๋ๆŽ5ุnwฌ€x-’ว๏JŠ=์ฒอ๗ะšfำญวฑ$ส7ดh่ฮ๓‹ด_~\d8๕ะ•ญ&Ÿ˜แัึ่ืbhnฎ…กปVm๎ฑ|Šu฿นณ%้ส s๖ra2ใผฌเ๓ํฌ8"95)๖มีหiืŒDู้—พ{\อjTŽˆัQ๐ีqŽแ—’}vก1Dลฉฺ้แะg‰ฉ๏_E๚o›`H ้Ž๒ผ๕6%๕ํuj๖#†1้๗Ž|;0ป๘๔˜ุุ*A๚…kvz-๑พล%้ ดํ๘u…ั“‡3b2jŠž_๖๑๙{๋๖ซ้@ํิI๗ว฿ 5b2™ จคจฝ(„™แcงจจHƒฌฬฌ[ฃข็—}|๖ฏ๓บš๔๎ ˆ[จKV>‡[บ๘วพ๗โสJSF}#–Sอฆ8ญB๚็qw;ญ”3๗f๕pุsly€d ฎC™‚—'\]]]7๘'hฬถmผา+?ฯmกลฦvž;ๆwจ7ถ๎ฌี2zถ–๕eCbH๓™`ๅx์uEw(รผขข?๛>6`e™บ๏K˜SEEเ๓็ฯ$9 ฒว>}9–Ÿ๏๏suu=รฉ“Dcศสk๖์ช ‚w๏๊=๛!{Gณ๗ฏฝ!w๗๛„NฤํSFถe_;{็หภ๑cภ™U%"๋ฯX6่๏ฑธฺ_ a"อpฮ–นCฯฅฆo2Nอฑฒถ5hZCŠ‹K‰UTT(†ณNFฟy๕/ืj<๓‡–mษํทaVฑษžG7œUณฒtttฤฯ™ฐธฏq/ำ๎=็>yแ฿Y๏ืNqปลQO„j||๗พ”'o?พnฆm'yงO% IW.“4ภอoอoสฑ;ฑๅtฌœ‰ฑ|u๋llงฏ?๏ฬ“j์DuRขว!*cๆ/ ˆ่ Yฟx…8N๚ฐM'ํไmp\ไ๛มh๎ŸEฒc6ํ4@๚ๅแ-{ƒ฿ี>ฬาrรe%E€โข"เ~.PQzตfปq“’ฃฟ*ข*h๊๊u4ต้ฅPTTยมปFL&ไ•บตkW3%E๘œ•Uะ5โrน4)ฉ๚Fฟ฿XˆจุฏžCฝ๓-_ฃส ง‰โ~P5›โ2ทNฆfJPt๖ฏ#ๅXVำ๗ ํcฆงŸ๚Ÿหื™ฟnคF๚ฃs็BซrJบุ'R>ะีm๊ฟSNึฝvE’œค๊ฟ2cvGํฌ๓3\๎:—ƒอ=~Dง%A๏–@ม หฆ4QฝrCถป๕ช}ฅ๒พตa่ [ฐสูi‚น๕๓“{ƒJ‰‡t4ข๏[ณ(ฦi฿†1›ืŽป6๏ ัu=-’้R4๐tลv*๒ภใะฅค$ส)เ๐tf๘žXJ=8g๊™D‚}๏“๊E†[็c๗ศ?&W์ฎœ0ง&QATe%9žฌ’tYไ๕ว*khlงŸดi}๕!๕WขZ}กศqHแฎ๛"eฒ,ฒฎฅญLg'S3(ผvลQ„ฌvฌ๛a๚ศ๓ช[w(ผโณ๋ฤ#:kภาZMUฃๆก1~ฒตเพKPญ๋๔็y2€Ÿโwญ๊3lม๚ฆF์ฌฬBR—.ๆ*ด๒๒N],T• +ซ๊๔รซEฎ–vฝก}ี2ณก0Iไ่ท๎ˆฅnK`๔Zถ๓๔4‹y}†ตSUย-๎Vณ)ๆRt).—\่t:qNR๏้.ห‡tQaะคๅสI$โ|ี๒๎lŸ‹ฃh>์ิศเ๊#ฅมEf๓ฮ์ ฏ P5+ ซดWแๅfณx ๆVอ ณ"๒๏E^๎#ศ|~=!d]^น๔|v‡I›๖nฝฒ?ฟ๏A \#hddTฯปี?ƒฮๅr€ybŠัyReูดOฑm%ถr‰‰‰ Lนt6jฺ†ฌำท>ฬษฉรอ๎L•/Y q ํฟึeสํe—?  U~ ‰๏)+ฎญ้%•๛์๊Ž~'ƒXBjw‚D!ภป ฃW&’่๗ึ ›าตk#ฃบง ฑq-y;‚q“ตu{qซฤแrLa_w2๕yฮ—Kฟ6 sR4|zฏํ๋ต.1#๗=Zฅšถ๕๗5ื3ล-ข๘™a^ำรtฐ3{ๅบลc_d™8N))€๒ดcoฦ๒@JdedFฃ๐xปˆึ8Œั›8น/็๖โฺNr‚ถ\Tqq๐ษwขภš›^Zc๐„พซ“ษ‹พ}ต†…i[˜ึบแ‡ีจร‚๓ฯฐSฯ๏ป‚N"7™:#‚<WPำฬH๕ns?ฆšM1เpธr4*Pฉจ–๘|2FเะGปํ™iroํุaฒsฮ!โ„ํl]ถ/1g‡๏v;๚ข•^x–1์}โ๗ ้e3๕D6ษคšf =dWฤฉYZผทปG—P_ฮ: ?(+ซ๐3Ÿ†&ณ๖คeืw]๓uL๔›าใ3็™›@ะ๓๚cn่IIj_rสXํS์F๛<›ฉ8์tะ\ฅ์sฑี฿YG umM฿{ำซ฿๏at|ฆ—Aโ์ภOฟธูฏŸ็‚ธEG’นญ๒้๏ๅิK6’ฃ๕Šฐฒ/‰} ?P(d S($€สJqTี’‰Z๒—‚œœ†6P#&“ $-M €ะnฏ Q}์๛m“0g—?฿๋๎|๛ํ์%QธๆŽ8ฑbฺแ๋{š๊ ๚9Qต t>งค•ฆE^ย๎:!๘wm€tIบ๒๏sV ษฉT IMํหลุผค‹ซฦ\Zฏaิoฌ‹ท็่ +์N;^.ƒา้78ฉ้8ฤqพๆp ฏฏพใiU~NqP5‰๕›aU‹ cŠŠY @UT’ศ)ช><ืyา$“าะฝทฟน%ช,๕แž“:ำฬ›>oุža-๑๊MรrมfgาSี1#dก๘ฦำ๗ ัำT‹@้ึH 8P!2gฏ<(œ7~๚ๆ]์H๙ัce„๏Boฅ‚ฌ๑{SีฎT%“ัf‘็#@พ๛(‡Yz#Fจ€ 2ฝyŽถOฑmุวf ๊‡โฟ9ฝr๛ห่7ัwฒตoีฟ*“^4:7+ ˆM@˜ไตท๏๑อฤ.ุ๛ผGG/€lีพsV%”ฦœQ"JŒŠdอณ›บ~อ็H๕Iฟั /๚‰ˆ›Zถ%'ง,kษ‘Švํ9ั‡V๎๛~$ฬ™\:k๐แ\6˜’ศP–—๑‰ 2+ชอึ5๘ธMาอ;ฯR UMำ๋๗5/ IDAT„โk‘Uว๒ล๋สนŸSw™ŸŸ ;โ/ฮผ#:U—ค0ษ/xZมฅภ่w…ภใ”ไๅUW้+™OYผุถ๊า๘€3Oคี]! >@qภ์?ๆkM๊๙๊uqœฉ/bY0มl่ ๎ๅlณykฦห\uu๐Nฮฬ€ีศŠวh๎]+ข2Œัผpดีภˆ w๊โล๙ŸŸ]บ๘*โkฮ˜i›ผ*ฃ•G AึฃGU๛:ใษ“บ†lป[็๚.ใรว^ฮqŸฐd๚ฮฐ“ู?*๘ๆจ'+ณ@NN-6้ebQ6c˜~r๕แ—Xฃ๒ด'aแ_O…‘‰7ขsฺ„ ฌŒ #ˆฑ j6ล}{“ำnฦŸณgป๗ไฝ๑_๏ฑ/ถ๊ ํหŽjlša7๖o ๏บrัก๑—6Oเquœน๊IEƒช–0™ๅํ=+ๅ@\p|€ !:ช`จ)๛QLSX๛ 3šธมรพjก<`‘วึ๙ฤ.วWนw๚๛e‡r๓]฿ถู3ฌjp˜๛ูะธโQ๘‹ช+;REๅฌฃไถวผ-ค?็ฺ๎ฤฯ}qสyํมท|ะดาร4†ปz‡ล—"สิ‡ญ๒ส-๛œ}uร9ย฿งl4โ๖)vฃ ๆ…๕;g๗vz๕=นaตํอ๋RZK#h ]ๆQsX?็่๓31D‰‘! ๗ะ6ฮ˜ฟพ???1`๓Ÿ;".^h้–ฬฝwพณาฎณV๗ๅf>{มšซฟภ:&qฮช^_=r฿ฮ#ฤ4?dK€ˆ?BีธัW#ทl๊xงัิ’ฌื=ถlบQu=ˆx]๙?๗s๊ๆ|โฟ๏่ฤ3M๊๎u>@ ฺ=€t}่‚)ซ&๊) ’ฎ{ญ๒zP5jlงฏjฝศรบ๚œฃฯฯผ์H0บุO|Iลq(Evส-nฝ%Œ3Oว-ิ๓6Oggฟพน?๐8ื๖œd่ิsXื ๙GิG๎Qัฦtฑw๗˜Zuƒ”บํ๏ถrเแลงม๎ vยฦู“–šps\pเ”$ณษ;ๅ_[๓่็02N๛p๖๛ฟ…fgธr๑ ณญFฃ๋ฝ]ฎ?|๘๐แฃˆˆ‡>|xlf{š๎0ืƒCยn_?ป{กE; ้Œ๖:tใฺ‰›ข\„jKMwžพv/์ฺฉK‡้ำบ-๓ฏฺžqิoายพ฿๙7 ยNJžKTN’|E~aa๎V๕—ฮ่2ม๓ุีะ;wn๘๛mด๏R๕์ู3ถŸบ~๛NXะูฝ‹ญิ%ญแ:_ฃ:jๅ–œพบyฐj๕;อำk“;8ž|QGฺธo๓Gืจ๙™ฌบ˜๑vณภ๓ฟˆŽใษ๑›=zศP๛%ืis‹“๗œ๏9]xลeส่ฑ๓ผ^๖ZปZ6+<ญR๗ฯŸ8ู๙wฦ–y]E6๕๑๎nฯทฮ;fบ{d๛ๅฎ๖_๖™9|w๎<๓”U+๓{?ƒFฮฺ›6ภmvo‚ตI๊ๅžqถถถห>ฟ๗sฐตต]๐ohNr_ฉศรaฌฝำ\n+ ฺ'๊฿]iฟ๋ศqจ ฉ&(!„ฺ€ž 6Y4vฤ๘ฅbิg/ฆoNฎฺ6ui;&GุI‰฿sๆิณเูณห5๓|"คช๒%ชึN5สม=B๋็1ชะ~าชนดภeใ~=gwj?YJ6เ"\g#kT?ล.›ฌžy๎ธ๗ฉ:กYzmๅQหฆหไไี›ง‘฿ๆฎั/ชiๆ2งo?~/,เ๘–yVํซbd-.„ <ตmFฯ๊ใd-ฮ‡„…‡œ_mUk๖จ8hํฅเ“๋Mi’€ะ๗สŠ‹9ฅๅ\ก€SZฦ-+.๑ิ]P24T‰ปs๓C ง๒sยอนๆๆ]ภl mjเู็eฅรฯ฿ฺุˆXœึหยไU๐ฅ„ฯ•E W๘ฦdSภdี๕ˆˆWู2ฯBฎ๎2ผย˜็ษ ๔ฆฉ๊๗คLฬบล฿ธ’\\มฮ‹ ฯ13๋ BR(T … PิmV์฿3ป[3•Bญ ][S%๋ulNง,+๖สฆykoˆž3ˆ๎สฟK4YuคฃลˆงCn8ปiŒ.น:ฑ๎ฮkฮ7ฯo›ะฉช฿W์ณ`฿ูkืCยนvbืYIชDุI‰์น๊ 9sพ๒ฯ๒•พ๑%฿Vgq-นุ[7’YNQาฃุ\m ฅG9{+ฃ‚ฯ-Œ{Fจซซ ’ \งุ}ฑ9ซดฦzธ่n8๔’ ะ|ฝ6รษฉC˜Oณ\’}›-[ฃFป'โซ0๗~ bD คvƒึพ~๓œื๘Nญaจ$๓๑ฮsW–Mฒ›ๆโฏูทป€o+ปฟวฤq†1z๙y๙jjj"WRRช,-แVฝ(‰ฝr"’ ๑{วY[[/นJEQ”๚˜uJOz_ูุJSTTฌ,-ฉnl%ฅ%JJJภผsแU฿-็–h„—ฯ๔9.๏ฏผlฆ๒Bจuฉ|c๔๛ีSฌ:ส“A(ˆ~๚–จฎผn"t9‚zๆ๗ฑ๖ห๏w๘รั‚ ขwวŒ•นฐt์8็ปํ—อ@m๛%“ fŽ3rฮ้ฬ็R&A;)ั=ื๗CโœeI๗nFฅ„Qgฤ๒ฺoฎ๕’ขA'ีขโ"ศ|pิe‰ฆุอผKibrก"^ง๘}ฑ๘9€f8gห\๎ก็าช๛สๆ้ตษ๚3– zใ{,Nิฬz‚o5jv‹ตตตตต๕จuท r๏„ฟ1ข1ำ:<8ืqkฌม๒yึดzV๛ƒ4ษ๓ใศ$2M^UUŽ”•}y{tUขn็ฮ}สPv/์น๛,#%H(า๋า9?๊ะ๋b.@zjvญ”~e๓บร๒๘‡’์0๘”‡ฌt้๔hรขปน4ƒษn๎Ž‰ ฝๆeDŸ๓zว–ภ|V~x&0Ht:วใัิป˜๖’Qเfrฅ่ขๆ่$Rีฒฃwฏถ9๛"ฟ$น žนท(THฝผฦ๕CTณพj%ไูถเฃฃzูy~kข๓อT:Bต:yืๆๅO™=m๙แ฿Wง>ืม€/aWN˜้7N„|(xโญp‘ฎ*D็‹ -่p@r @I์Ž…ถ @n1“Yฺ‰L"‰LQ์nฌ ื๋?D-ยNJtฯ๕C>Žpq)MณcG2 Sแต-ซSๅฦ๎ u๋วIนแๅฒ;ŽGธฒzิYงบุqJV#ร[ ?œp ฯo๐1ฮ๊ตUF.ฬ9ป0ผ&ี›Oยoณkิ$”บฌ6‰ฺ<็I€ˆ50o๚žŒLHป’๓?-€ฏชkf฿ฯœœ†V‘U7wbข๐ฏB(@vภ๎๔–บ๘อาเeพผ{ๆ๏Cแ้\ ัจฺwžฦ*ฃ‚๙F จT*Ÿฯ' ค$๕Qh๊—WFFFฝNจŽฤŒNฃlSƒ7พHd_ธ;็๔H“CฏŸๆ| <๓๖vi)>ปBvย_ณz *9 …R๎>*@~•หฉ$Ž?Uทฒnƒo@๏ฎzv™)Gfฯ=›I’Rท]๋ณoถ๋์'๔f๘…฿5Z €ขaฝฬsžbภแ`๓…‡sCฝื๙=$5Bœธูฯํz|oซY๋ฝ—1ว๏|BxH‰ฐ+'L„๊+€@( R๋;>Y;'™D!3>ต๋š/ฏด,๗ฅ๗žg’U‡จ“"Nฌ๒ํฃพœ„พ[d-V๑ดฬ พฐ้pTางฏŸdi‹u0M^oฤ๚m›Iฌ—เขuŠงd5zฤ-ดZ—)ท—]Xมด๏{ํSโธ้fNNnntgจิŸSาoณฅjิ$”ฏqํ~๏ฯ9ฯหซ^Žจเหเ™ฯ็Wm2-์๛ํ๛่ั;๕ๆ7(aษศT฿ท ##ร*a”']พะ๔อฆฏ฿๊6๖ๅ’ซ</ใ’‹ใ้ต็๓๙dJuตษไฺ๕—ำทะฅ"Qlv$&&6ฆV่{Š]ฅ„|^๕›/เKI}™ธห jT<์iVี๙ eใ้ฯnผส**ลลEฌ|jปvฒe ึN-//฿}Gtbบœ< € tu …”๚o“!'๏๑ณ/›.๔Sท๊๛ใฌ’ล*ฆหสR๘ '+W\\ ถ๋vŒ๛ฐห๙@้ฤใŽฯ7ฮN˜vu’ๅ๑็aBกถ‡L& !;3๒ศฉ‡“ๆ๊+รย}5aWN˜X•Jๅ๒็#ขจu๎แ4ฺํ?^ƒ@ิI'V๙vศQ_NB฿-ฮฐž<>๏ ๊เฺว ไ:ถ‘}u๓e[’๑ผะลาย#ลฎแ:๋‰๓ปฎ\ย๑ำ/n๖๋ใ็น nั‘ไ†ฟธฏฝ6|๛ŠŸŽฺ๊šพ๗ฆWฟ๎at|ๆ์ใ้b฿ kิTFฌq้พม3–%‰hD#›คS˜ฬทoeึ[‘Fื6,็ํ’คณw็q1u}ภณีดO‹’$ด( !ั“5YขวšGํฒ…T”ํEษพ•=-Iฺmฅ•ฅšiำพฮ๚1•–™"<็๛™?๎ๆœsทนหน๗œ{mM5‡Hเiตu &ๅๅะิ•็เnถรcน:(ล%ฒใ T$$†Nตฒœุฉs”‚™มปู๑z๒อj๓๓jฦN—ๅวb…g๊+ๅๅทืฐฬwน;บ๘ุตทใ$jš9ู.Kโี[b$•’’ภJ‰‹Wšg1VBPhฐแ’™ธ˜ุ<.#jM}๙Fc๎ฒQRDขฤ่ฅ วคว$|๑ข>–(ซฏฃRUJ๙1mkFZ๖“…Jขฤc็O—}šuฯ}6:^หl,ห QฉT`ฐ˜/—… ๒๛“Yx๘ฮZƒE๘ย 3Œต฿ผๅv.ฦ๑Pฮ1"๒รค๙ฐษ‰SวถdgโR$G<Ÿธ”‡รaฟagฬ๑ ลศี”ฃ๗ว8ŽูEDลจŽu c{›j"Xภ ึ7ฌค˜Cซ๎8–ษcŽบสฟrŽX”P๗รE&n›ต{q๖MGํ,ฟEzmๆIm~เจวฎ<๔rโม9๚nา&ฮ6Cน๛ฅ~๎‘ส๙Œ๚W๔ตZใOะฺแ.ฮ $฿< P•ƒ_ณูวZ^W—w๊`XิG;<สๅ๐]+ฎ™๒ชG ช"ฆ์9qsq๕]ืๆฏ๊(ทๆc6ฅ~@SN1๏N5ศทสธผ/ฤy‹_ฐณ ฃถเฅฏ๗=J5๏Šk%šฒ‹ฺ—<ๅŽ๗Q5็=7อ„Zศ้aป=b ๙้‘ฝสฎ๖—๎IัŠŸ]y1›๋บ,hฟื@{็๓+dpŸ2#<„U€ฦถS ู7,ฏวo€์“ๆk) ดแzญฑช(-ฬX๚๗ฯฆฆรอ๋Qฎ฿าUW‹ษท'๏ไqฝ4=|ฏ็ำFhfW๖‹ž‘ฝŽ…ฬญŠ<ไ๛UหA~WeaวZo๙Ÿต‚(ฝ";๖’ำนท,u› ำๆ์>ฉืโญฺ๖Ÿๅƒ 2nใ้ฐ=‚-ล)7vzฆณ€๛ฮฟ‡’๐๓็ฎ=Y Œ&๒๋+{]ฎผiๆ””#Ž)ฎGฎงœSNpŽ๐1e๗_=?ย์fy>็ƒมฬ๖‰Ÿ15Q;๕vG?=sย`ง็] Qhช๚˜|ู๓VAฏ็†k™็จ๛กผ๗Gํีั^๎ใ/๎p0Xใ+ณŽฺฝŸ๘฿iŽzG`ย๔Iข๒เต ๙‘๛sฮgิฟ" ‘๘๙‰G๋ึMR๛%้7ชชชาฐ_bศ`qzEนEL^^œQQ@ฎc  ~!ศว=ญณ‰‰gx๘#ขฺ+rขฑ-d[๙ฦUW‹ฟ%3มะ-ฏ๓ํ๏7†0l•๏ัอ?–ึวำˆ ศท๊v๚บ` ศฏ '$>`IxA ๖ ขเƒ‚๔ํํำวbkn„ บ{็ฆ๗ิ๒+~‘z‚  ๛ศoฃฟฎดap||xฝ•ฦl`  ~)ศบ€๔•_้‚ ฒnฉ>y‚ษX j+๛|ฐcQ๐KAA๙Sก๖K‚ ‚ ‚๔ช? ‚ ‚ า[จ€ ‚ ‚ Ho๕IAc[H|l‡๛Žฺ ฝุ?พ 7Cภ 6q ฟwมvขX_ŒAบัtธqลเžร฿Vินeฒ_—Ghิ2K!ข"Cฏถž$อŠjX์?7โ๑ฃเซ‡ฌฦKbm฿+;อฮ๗ฦศ่่‡!W}ึh‹p ๖>;g8Yอ‡ฏ…D>Žธ๋ฟcŽ"กใ9s฿ˆ๐}Fขํ฿5๎ววฦฦฦ<}|ฦ ™พ˜Mš`ํ–”‘›Ÿ•ไ๒#9tฉA๙e๔U้็,-/v T†:.|สว&Ž฿๊k–ƒฆ,Txฒu%กs'œHzDขจ(ณฎฝ2๙3ศ™m[EถšL๕ฯฑƒ๋_ฯŒ9zอฅฌ36ๆ‘d‚โขฝ๛ท่Y๎ฮ๏†€ึ–่ก5$ืเวห‘„;ฉ51•8ฉ.gรญ•ส๐3ฅปิQZห๏QEไH„ฎู‹+@ๆW –Tszฃ฿ฐนVำJ-ท<ฉมษ-:xuฅแํไ:ŽA™นd็˜Rzพซ“b’รชํ๙ฬaK=Žฯ{n}ปJcผส›_wฮ–๋oฑ๊j1^|‚ํ้]–1ฑฉ‹์=Q๗ ;็`ำoป eฑzฃ6wโŠ๋ๅ฿Y*‚ ‚๔‰๖%fsM9๛อ‘˜แซอี“ฮบƒฐp8<‡&pา๚›๗M๓t2๕งพ.๙๏T_บำq๙๘!ฤ๚ฯBฮ๚]K,ก`e ถ8o4R%ัKSฎ{{fิC[ะฺhไจ,ง 6฿l/Alช๓ฝฆkOงrพฆ0๑L๚ร- hIKzหZ// ฯhJJiท|จgd>ˆ)[ฆญyฝ฿pŠโโ]+Œ7 |๊ค%;›iฯk๙ดdIw6QcชๅบDih 4Iสศtอ^Z ฟ\sกฑถ–Jjhขฑ˜Œ†FZcm-•[ฃ^ง$ŒััศšYEศผ{ฦ+€‡N/ำอ๕[๓พฆ[z๕‹ไ๗ข&2฿นSญงO‚bฟํ6) ฿ |งพก.z๛JEA>ัW7ลVž‰ˆˆฟ่ทc ฑ๓/e‹๘‚ใ[ศQื3ฦ๏ ุ(๔ธiนทื๒ใถจ๒€p2๓mfูdfบฤฮ?}เxuaแ™ถฎ๊oฯ6]wฑy๑๎•jmมํj๎&ณ—8฿๙ะ้d4TmIiฤ"็Qฐวœฝฺ€!ˆิViศz_ PWVึชช3^ @ัีJ"‘ะ†๐=Joบ๎oX}็แ๐‡็ “ถyฦดp ๖>;'$ฉตกพญSŸr็BาฯีำำxทŠciœึ๐ย์๏_—โโ$€ชช*€โภ ณgฯ=˜๘…"‚ H฿่“๛™gื- ฤVpˆฉณปรgVื)mฟ ˜N- ณฬ€าจkฃˆรLท๏ด,๗wtzVม์‹ั#OX – "))Œ)ษvหใ;(ฏฌ\™ไ—ูศ„ฦ่ศdืช$ศฌขข\‘x๊M-  0Ÿา้สtแ7—Rฅฆ๔ุฦ/LxŽO„ำj^ธปก4:<ป่๓ฦs_๐#F]Ezx:ˆด!|๑i[ํ†วํXคŒ ธศษueึฺSohƒฝฯฮ)!ร~‹ด‰W˜ƒ`ฐ”€๕ู\ฆJั๊J๔Zภแ!–ฃ‡>™ัฌš‚ด๎w:Aค๕ษZ]9…BกP(%yฯoEๆ()๋๘ ง=Iท(.ถดซŒžอฑZ‰งรฤึบxb=ฏ๎‹๒ตXฌn_Y@ :t’ขi็|ษf†€@ภZ่ฐMซ…|€วใ Žํ“๊๓ใ"%“น^ึ๎ะjงงo8oW๚Œn3$€Yแถ|ึฬ9 ,s ศjbO"ฺพ•เฤู๙aฏ )ไ๘๋OZๆฮาเ์}vŽXmฅฦp'CCรญ๗j˜ ญ‡๒ฮXN™พไษ๙ˆๅ0๎ ฟ…ฬะกCŠเ๚ถTA๙V}Qhผใะr•๖o,ด]ธPีาฌ๕ช˜Eิภลs~ๅQ›ฝoG˜JeyบาฬLฝ้;๕๕u‚‚‚์aAAมบ๚:€ฆ์{[–5kแ–S๏G:9อ‘:๑ฆ……………ลโ…ฆถAๅภ`0ฐธถm‹ํผq+L26า’ๅู|IXูp๖X)`ั๊ ใ“ซ'๊ช€ธšฑษXqjs @\Bขถถm฿@เc1่mีD“มววฯ%ศ&ค8e๎_ใๅ๘xe็จฎฎ–_XคญO7ฟดŒhY๙ป/ณจๅIฏ๒†ฉชp+ดืชkjฤล%[^LLŒู7 ๓ฅL‚ ๒s๔Eก†.คm2{"_B}ฮดแ™๏rฺ’ฅ.™™™๖ญ๎นฯFวk™ €ล`4*•J ‘พS๎ะไ™cลฒ3ŒดJ฿ฝซภ(˜9ฺšj‘ภำj+*๊L(สห ฉ+ฯภ?l‡วruPŠKdวจHH je9Q่sน fnw๎>fo$ศcไ c{›j"Xภ ึ7ฌคธˆšfNถKว’๘d๕–Iฅคไ|ี†ภข1™๔.‹ลข1™]?,‹Ie0บ~˜,ณ•ม่๚aฒX,f7 ึฏไธถFDู9jM}๙Fc๎ฒQRDขฤ่ฅ วคว$ิ๓X๙€%ส๊๋จT•Rพปฤ›คฤ:_ถื~››๗: h}๛užFA~}qัณ%๖์แ NCฅ๘[ห2ฃฝ=‚ฏำแีิ” ๓๒:šท6ณษT๔4ˆ์u,dnUไ!_ฮญ”ไ[ดฦŸ> ตร% \œAIพy  :+ฟfณตผ$ฎ.7๎ิมฐ*จ8vx”หแปV$\3๙ๅU<TE๘Lูsโๆโ๋ปฎ%ฬ_ีQnอวlJ€ฆœb^n~zๆ„มNฯปขะT๕1๙ฒ็ญ ๑>ชๆผ็ฆ™P 9=lทGl#๔zChญ สฌ์>›L๎<”Pุ3่๚8ทg๒ขคg0ใื r’qy_ˆ๓ฟ`gAFmมK_๏{nA€š‚wลตMูET^ู9* ฺ๏5ะ๙ งฬaUะ้๙Kืใ7@๖I๓ตPฺp=~‹ึXU”ๆ~,ฝwณยCmศ๖uรฎณญ7แ๊>>=ฝห%๋„"‚ ศO†!?7ษXทn๚ูณQ_ๅฅดwIัฎๆค็ˆkนIัฏๆควptๅ๗เ8"Dมn:UUีฌฌฌ๒DŸจž–อูฤฤ3<ผ_ฆ๙}กฝ"‚ ?Gทƒฏ๖Kโ" +dไTฐ .6๐ƒp ขเื!‚ ‚ ฿€ื>ผ ,žUีา‚„gUต4ฑ๏ทแ8"Dมn:tฅ ๙3 ๛H_A{EA~Žn)^๕๙ฅ #%๒g@๕คฏ ฝ"‚ ?วWด_BAA้ ีAA้-๙ฎZZรSR>?]FN{›šTCY9]VำNm@CY9…‰‚(ุA6))ฉสJ3E฿Kท=-›žฒr|Nว๔ย ฺ+"HยสŒ[ผฬtŒ@yfQ๓หษcRผ๎?ค))(โ@LขmQฐ_‚ฝฆn๛ูi?๕A~†‰๗?ytm‘jว[ˆ1"ฃึ๛GFบNj๛:ุฤ=04‰b?s๒l2Zๆq)ไQTd่ีรึ“คค๛วwแfศต@œฌๆรืB"G๕฿1G‘ะ๑ƒภฟ: IDATœนoD๘>#ั๖๏š๗ใccccž>พใ„LฬŒัั2[แ๛ิงWwฮŒn#Aึ*˜L&Gl0ฺ%‰L.๒5ํ๏‰โŒุผทใา฿gง<นโd8วกฃgJIฃฝำ๒ ฒ“.ฏQ๛บc๒KฐไR™L&ว9ฉ๒H4iห™‡/2๓?dฝŽบdง/ คต7๙ปผย‚๗้๑w<อ†qy) AzฮŽ#{๗xป/ฦฑ๗.)ฬ~๘ยf]QฮE๖x>‰_DŽŸUY฿ะย'2˜ŸUY฿PฯBA์‡ [/z ชนึYœฯหษ.๕๓๛`ซ๛ƒbˆตGฟนศแAํเฟถ;[Lเหฮิo>eไžrหฯz zฎ~ป$tฮKS—Gt ŠŠ2๋๊8ฝ›NPx๘aพฮ‘ฆ†<พ๚โƒ๕ี้๘1ณd„:kหž='LX$'9XUC0\=ฌหญ๒Ch8a๖feR็`Yฮ›`bซ,9XšsอทRXŽD่คึW€LŸKช{rI @๎๏๓็5ยฌvSFs์ ้ิ์ฯ@€$%าถ<‰ใท๚šeณ& ˜c™าf'ฮ๋'9์ฝ“ฯถิใธnิr๋์7cโควจ5ฟŽy_รNฉ้p฿†๒ฯชซลx๑ ถงwมฟผSyN๎—๛O-ธดธ>Ttอใต+u„mั\uปฆทห๙ฯ๘ังeญ‚“ฦณ^์าœVิ๖qฌใHF๐zy๋ฐ7ฦo„Qu|ตE4๖ิ™8’้–๊้บ‹ฏ•๕6eๅŽง๘—}ฐพgpGg๖ษ๑ ณกฏ๊~๖l ฿BไTูyโ, &ุ4}/ฮƒศ,฿็็็ึ?๒9\มยั|dร%sM—7‹ofz๋•ว๙๚ว‹ฯตYชม \ฎbอ๊™›ื†€ช:[’•ฯ>d-ธดธ&า#ขnยืฅ๊E>ำ |ˆgt๋?อ๋ำtZsZYภj@A์—เw’0;qC๕‘;m6ฃม๕๑>•`e ถ8o4R%ัKSฎ{{fิ— ˆMu>ใ ืฒcํ้Tฎ/Qไญฅš~c~= รoอL‹ีนI๗O^‹อเญฏ–,รaษœดๆฝำ6LmๅPฆภ@qมฮ‘FY@As`— @-+จ2yH—s}J๋๋ทฤัFสRƒE-Iฏฦฯีๅ"๙‡ฆจขž…๖ ฮมœฦฐG`ฐ\[ฎs๐}c๐™fI™.ต—fZi5๔}๐+๊2ฆ0๑L๚ร- hIKzหZ// ฯ*škสู๏ฦ _mฎžtึsๅ€0FG##lkf ๓๎?ฌ:ฝ:ืoiGกฝ๚E๒{Q~๋๒ซี$฿๒๕} ฏฤg[ฉซ+ยํไ>(Aพ“ฅ9P,Œ4]ีพC–œ๘๏ซงจh”ิPo็Aน*Nq‘V);eทlชูทๅลาำเˆ้ขs๙’บz์Ym Bข—ฝ‰8ๆฒใzf ่๛dXVq|๕ัAN{MืŠ9/ิX๔‘ ฺุš`ฟธw๏ a–K50ี5<ฮ9zl๒ึฯwj@ถฯ4รNต„๚woพ}9`๑R๕Cไˆ๚C7ผnŠ+^˜ดxึB~ฎ>Ÿ=€‚(ุ/ม๏G;Žxcำ…ž๙—ฯ ย3m]ี฿ธ-žmบ๎b๓โ+ี€[€4TmIiฤ"ื1ˆ‰‰ั๑Jห\ }qื฿ูXะ˜ ฑฐฑsBrิ๕Œ๑๛6ส=nZ๎ํ5ทธ-วสา[2@qฬูฉ‚ุHm•†ฌ๗ี~$่,[ฤ฿ยญH‰ิฺP฿VƒฉOนs! ้‡็๊้้mผ[ล1Ž4Nkxavn฿ฎK@เใ๛rJ๙!ฝ{?qฦ‚9ำ5ฒฒr€ฦž ฎฆ"q;Vฎ๗๛ บ๊˜๏zEิื\ู*k๊บnPYiาด ‚ำwŸw5•อปโแ๓จn”…ฯน-ฃฺKzU๒ฌ๋ืVไ:›;=$ูmู=—FํูRอ;ก„„Niลลgน9 wO@gBใญ๓ถ„Hุ=|๕ยยช3– <_๓(ขว†P๕๔ˆฝฝ™=`D!‘ฃG fNN4ˆ๘แxีjษq%e&4ึSุ(ˆ‚๒ซฮEณEธL๎ˆถคFD63๋ณา3[€ไ••+“g62้ั‘ษ$UUท @แ7—{mผ5re CิIป๘ฏ๙ผUžj๖[gKpIYu`ญนล๖9KK‘ŽN๏x‹|แ9>๑qัANRv'า่Ÿใ‚ฆSKย๎็qฯ‰ม`@ศฤ+:::๚iLภ๚S+Z]‰ŽŽŽ=8๚ูฑ{{F+œฐ”์ กฆ— )}T*‚|-JB|๑[ื๑‰์ปwร5ตDก:๎ฮํธ'CSฏ>aœ5๑๖้—`$8๚ผ€@ภืิ"Aอร“๎g|wOฬะqZํปลฒ๛ฎวOŸ { ,"YIIี 8~Hภ๊LิมัŸ็˜'ฃทi๏jฑ ำaฺVงn”Exป๘' ืปง5„ฺ้…D†o?เ†ูผq}œ๖$ขธำฅนzขnGs4Pีาฌ๕Š็ษA]]-ฟฐH฿_ZFดฌผœWzต<้U0U•พiuG ฑ๒o 3“IฺSํ}๊“"ไ๐๑eœณตณูyซ˜ืฆRiี!3fฬ˜a ซญญฝ—Ž T* €@ภƒ๖บฤg,jc]]C+ %)้5€ฦ๘9S'…๔จ'%Jุนp|ฆpG&“#;P` €’’˜v01ํerZฤV5๎)U6_9:&zผmE[ะฎ;๓ญฐ]ยซนิfัXUuŒ0`Ža๔{ฐงO–ท9๐ด €rฯiนgL pX๏ีUี8ฐ8 ต• <รรถUน้ฑ!pืB~๓โY์อปI5 ฆญ๕g•xีEd& ”’ม‚ p ข`ฟ€ขผšบ๒รอvx,W'p (˜นน๛˜ฝ‘ "ฉ้)Yšฆ‹TฤˆDsฃA้i\žๆ_๗gฃใตฬภbฐ •Jฅห๙ฆ)‹ล 3ป~X,“Nct๙ะ™,&“Fet๙ะ˜,&ƒฺJ๏๒ก2XLFk3ญหง…มb2Zšhญ?อ ƒัาD๋๒ifฐX,f7 ึ ~ฯ๊†‚ฑฝอ5,`๋VR\า“๔(uษฬฬ\žู[S_พั˜ปl”‘(1z้ย1้1 _ผA„%ส๊๋จT•R๚ฆDSม๓ศวO“R jx๙@Ž[๐4๐ึ‹า๖6A๙ฏS๊€ค5}ชบ๚K๏;wNญหๅ|ช -ญHฦ›\ืณ{ฅ.9-ฝ‚hJ €0ัzญไG=)hc๕๖—มิE[ฬ5xLcfXXhใํผฺcฏ…๕Ypปย/3ZSภ?rฌ*ื”๏ฯญ0\์๑ฌฐ,4–ิ 8์Aฎ ˜ษ$ `H๛@ฟ{ งดตWŽNฃะš _Fง—2€รzฯHLจฅลืY{ูฬ$@๙ณ็๙๐.=JKw๎ุธๅ ํlจšGcฃ‚šฑ……ลTE<IรฤยยBOกํH.ข>bลj็ฦภ,(3od๑z~+`08&‹ล๊@A์— |ว๓[%ฬNP hฌgœ {— ”Hธf๒หซ๎ทฒZธ@ฬะๅฌฃ^S๐Žต~ฏyœห๑)ou^k $ฮฌxqาห7ก” 0ม9ยว๔๓ล“†0ปYžmญšฐ ๓<ฝฌF VEฒ๕Žใ'้ N 9Yqมฎซ&*ˆBSีวไ›Gผnผa๗3มOูน๖ใสฟฯไY&~ตzฃQ2ธO™งœŒ+e~~[๖I๓ตM‡๛›'ภข5Vฅ…๔8๓œwOพ^>ฟต่˜‘พื^/ไฟ่ง<ฟU่ภค' @ว=ํ฿‰๋ๅญร$&Xป๏Z=uค 3ๅอƒฃv.ื๙ถฦEZงญิI”บทh๚‹5Yžเฌบ๘2Qoซ็nหIJ$f๙วพ;ท_Lmh{RGmb๔}XF(9m2ญใ!ศ#ึบๅชูno๚๏=ฎ•e๓ฝmg’ขฟผน฿๑`™@gtq“ZKžE_)เ•€0rํล๓NIQ๛Vs-๗?…‹ ƒ๕y ฿ƒผt๛SqX๏2๚vžป–MTgTd==ฟ{๛้Wต€Wœ๏ๆฑํฏ1๒ขฬชผค@w๏งŸ๚หyC8 ฿๑%ถ๛ึCฌšผ .-ๆ๖ก$ใัq—ู๋œฯ้๖V^๕Y๙๑ๅจ!ฏา Ž<˜๒*ํ%Qฐ‚l?๚H‰ ?ว—๋า;ฬ^;Tฯ\[+=i๕ถล˜ำŽฝ๏๏)โŠ_bศ`qzEนEL^^œQQ@ฎcAฬ,5์ :sW่ฉbg2˜ปrXMD๚Wทƒฏึ!ขรๆ—ŠQ๑ก์Dม~ "‚ 0aํฟ๗๚๑ฐัo ตท>๙๋V'$>`IxA ๖ภuYฌ™4†`d๛@ฟ‘_ ฏ๛>กfmSs+APšภชmjndก ๖Cํนา†วก๛H_A{ลŸƒใใรณ่ญ4f๛ใO ‚(#สb‘[Aธ}€ู฿Aค_}E๛%๙ฅ #%๒g@๕คฏ ฝ"‚ ?วWด_BAA้ ีAA้-T@๙ X™qKึญท˜,^๙‡ ‚7}SAr‘o|ไNo}3ฐœนoD๘>#ั๖๏#7Ž‹ฟฒRwNm!W ๎์}๖4‚ ๛7๎?~๒0่ผ"U3เ˜ฒ๗ูqฒ๚›_ ‰|qืวลฯ’๎๋]ำแ~|lllฬำว๗oœฐ1๙yD3,น”E&“ษqNช\ำเ•ๆป฿ˆyŸ›‘zdฅ†ศ[G;Kซร5ฟธ๖๚“๗Ÿฝอห{๗2โ๔ฟบโํq้9;Ž์ใํพd๛ปััva%…ูฏ_ุฌ+สญฤ3:Z@&ว9ฉ๚ไv #ศื“š`ํ–”‘›Ÿ•ไ๒#9tูA๏๖-;a "ูG๋Ž๙ฦฝPiŒŸ—ื•—uํ฿฿Xd``ฐ)่_Ÿ๕ู#dอ\7KEบ,5™ตdืห!ฌ&๖U){Ÿ]zพซ“b๒UsZ๊š ทล~žt๛/ื;ไ๚[L™:kลแ‚ษN–c๛fN‘?Ÿธ‰N#‘/ผกZ~๕ัใซ'๓ง๙๏๗ผY4d‰ว™ญฺm7 ˜ฏ/lmณ3(ŸKvแ{/๎Y0์S„ฟใOรๆธž>ฅญ.\zqๅค™ฦz Žu~ฝxyค๗V๛}๗+]Zqฏำ ศฯ&jโ~a็<ฅฺ'็|๏ไ‹ฯุ่็ตX๚หนAx๚†*ŸŽฎsฟภ<-์€€‘WดŸน๛‹า†๋A›FH่n8~#"๊qxภ‘๕ใฎil ‰น{r฿jaNewย);Fjชหๅ๐วฎํ3Uเ1๕XYcื๏?Œพt`ูh‘ŽธุT็›๗ร.3๖ฟ๕^พัZช้B๓๋ฉิš ฟ53ิ~Mสg'Œััศป™YีาZ“y๗Œ฿ พด้ี/’฿‹สศ๔ลžฅ&^|๚}~vJฬc[ฆยโๆ๚’ใีฺฬ<žG~น{,๐ฉ}๊aJ๖‡Yฏ"ืi Œq}A&งนฯ7vฟŸ–—์ช•jก๒ 6ุน>„<ฌ็™Lm๔h<ไ๖๒9v฿‰‡๕ ฏ7y๛ึง็ฯŸล>ผw๋Fศ๋J.ูGJB๑๕v^^6v{ฎ>,ๅ“hป}๑13๑ัรsk;'ฏ๗๐Fเูก9 Cไ๛b6คOŒึำ'AqภvCฎำA@฿Pํุ๙N__ภj๊ŽH{–๒EนŽ๎PhNŠOQฯ>1”ีัNLx€ปฦyยหšท๖rƒฉใ2๖๙[๚แนzzz๏~๑^็์ oฒH.ส๕๏ฟ๗ฅ(mฑœภต <ำึUโูฆ๋.6/ฝฒ#?iจฺ 1’าˆ!DnYHbbbtผาฒWCE๕w6Vเzเ˜ฒ๗ูI$RkC=ฅ>ๅฮ…2|iฝใHใด†f็ถ~ื,`&;๙;ฮO๑ฒผ๏rŠฐ†š“QPPฒฒฒ‚3๖ปฒ~”่ภPPX ณภ๙ค ฝ"jีL๗zฎฺ^†ฤ_kŒ*ƒƒา˜Cฆmทž๖฿ชf๘'8z.Œฺณ+คšwยššY๑Cล$FS””d‚›แž˜˜”.7%h๋8A.ู%$$ชชช0ย2 Iพ๛฿ญ”:จzzฤฬ jไQHdเ่™“รํž‚|โโ$€ชช*€โภ ณgฯ=˜ุ฿ำ„ ศo๏ซ๋˜Qบcฒžฅ2kŸ=oัี ๑oฦ๊hฤtt&%ค3˜ฉว–o:ŸQาHy‘๚QJJ๊๋Fร5;9โฬตE•ไฤ˜4ฆ` n๙ๅ••+“g62้ั‘ษ$UUR…w\๖๏ต๑~ิ๘ตs[ร`0Dอ‘ด‹šฯ[ๅ™กfฟu6ทEว1ๅWe!ฏ่่่่ง1๋GpŸ,Eซ+ัััักG?;v๏รwอ!เลIยx!’@cfศกต๋|ณ>€€ฌ์ฤษ๓tฆ›่ju…5ีมv๓ฬ๊sแฬ‘เl€!C:บีT‡{ู๑?xฟ์ q^ฃC~:จ-^ซๅาN‰e‘ˆœ ธดร)้ซซKจžแ™˜™่1ืยoV>ท~๚๕๋ื[๙$=ม‰[[Ž๖2:”˜˜˜˜˜๘hป.4f> xšG๏‘|๘ฦะœ์฿๐tื–ณy}5ปางX5iiiy•=ภ‚ _ฅ๛uไu๋ฆณโใKzฆฮสสRึี•2Q๔..MW์๚ฝZ€ช„๘‚5:ฃ0ฯ$uT^D&3U๎t˜ฃH ำ0ย2๐๊k'Œ[vƒั1€วsฝ N เ-๔ ˜A<ฑ…–ฏ—๚ธˆฯ—UUM•ณ>ฑXฬWawื2 ๖ลญศ—ี•!๔9งค,N)๓9sj9,บฌOmาร รaฌmฐ=ƒวก*๏Œๅชซล>ig฿#–๖–ฯ๙9•ู้ํHผืWVV„ทใ๕A. ํNุฑZ ฃmด๒}]๐ก ิงฎดTUsVก |๘PLาุฅv[ฆฉH "M˜ŽSP‹ ฐ์ไ๒ปจจง‚#€CXชˆXIUชlqฃ๘%ไ$่e”:๖?Ž๙์ะแC%จ%9๒N้๚cY,4็'„ตma5Zkฆ,ช ฏชสก6œีนข%แ๋žฎฦุ๖]G%ทถHjถ็๐;G+&อุ3žž\o็“ีฝsG‚|!™กZ>•ึ๓๚7#‚|I๗๐/ฝzฎnณ฿Rร Vว%xแx{›สใ*อuTวJjผItokำ’ฆ3K—ฤ50%ฬN๙ฺg‡|9;งัi๒ำ้๔7ํV^.๊๑‹ฐยคษ*-้q)”่zn๚'ใSจe|>a|>Rœ2]ต)9๒e  ถŽCJNAฮ‹Ž_ก–_X„@~iัฒผ๒/M‹Zž๔*ฯ]_…าร/ฌŽ/ฎฏ์บน]Fuย;๏ฝ&;lM/ฏL(,ู3ฤ^]พ$ทr…Ya1ฟษIŸๅัฮs–E }%ls๗‡z๚_๙‡&๘–็ฒ;๏ซ[ู>ต๖ž“ฝ_L L;i…,!“G2@\g•๕<อ†‡Nว฿†ธ@Qe%qžoบQชปโ ภb14๓*–จช—`ฟŒx_w €Bแ1a-ไ7/žฝ}Iฺต|ตถ–bVhrฯ4#๊ธLรUUU€ธ„@@JJ ฒ๒ำ——‚๔T]S ..Pƒ-/&๎y฿Zั*ธฟ' A฿Wvฃ’ะี•ศ๐eF™o฿ผ฿งซMxO ววทn_น@,7Dเ๐xข๘%G›Ž“njฟXื˜žQบ^WŸฬศ‹]ฝผ์˜Oใ9)แg๏8zhS•zหหมฤ๓๔AXท๑ํฒS ูฎวo€์“ๆk)๊6Aงอภตx+ศ๕[บ๊j1ว์a/พg๓๙Pjษ๋ป<าXภ1{}ฤฑรฃ\฿ต"แšษ/ฏzไต฿ฉจ๙˜Mฉะ”Sณไr๗ภq็VโฬŠ7๛ผท?@ฉฆเ]qญDSv•WJฎู{( ฺ๏5ะ๙ งฬaU ฑรzฅ ืใ7ฐhUEia๎วาฟ{.iก!ำืšo[8DœU™โพอ=†PX๐@&-ํCZI m•qaA!4็xฤึ๕งฅ฿t[dด๓ผ\mษxŒ„๖สํณลš๓ย๗9O๎IB~’’„ˆ”*%ต–ธวฏูeฺำKนญ˜็d฿Jy{ั๕ศk:ภ๙mฎส๛7Lดk:ญ<'ไ€H.—๊ํ\ฝณ{•้†uŒฒื—lœOผc€ิญ;5@ฦศ๎[฿Œožฑอ{:ญฑชไY Ž€ฒ๏›ฦศ}๋}w[L]พ˜^–~รูๅิ[ิ~ ๙&ต!ื cธZฬถ„ซ๛๘๔๔.—@^wาAzC$~~ับuำฟิ~ A๚ชช๊mM4ฦ๕ลƒ๙/,ใŠžO‚@๗ดฮ&&žแแ2=ศ๏๋‡๏A วA ฝˆAAA‰๐ฎ IDATBฏ‘Avi๎:ƒ๛{"AA~i่‚ ‚ ‚ ฝ…๊‚ ‚ ‚๔ช? ‚ ‚ า[จ€ ‚ ‚ Ho๕e;tๅลุ๘HืI์ฏBฃ–y\ yz๕ฐ๕$iภ 6q ฟwมvขXŽAฺi:ฟธbpฯแo+๊2ูoษูuCภสNณ๓ฝq?2:๚aศUŸ5ฺ"hC๘>D•{ฯˆŠ ฟํฟkž ๗”=wA ชaฑˆว‚ฏฒ/‰แž'ซฟ๙๐ตศวwwฬQ$t g๎พฯHดปฆร๘ุุุ˜ง๏฿8ac ๓ณˆ }Fึ*˜L&Gl0ฺ%‰L.๒5ํ๏‰B~ษ…งBœวแ@c[—#`๗=X”ฉฐ๒bฦ7N3๒{๊ร็/‰ฯดTฐดใ%ฉrfV‚ญๆSFs์เ๚ืณ๗MYจ๐d๋ผทKB็N8‘๔ˆDQQf]์Mnศฎ†0lฎีดRห-Ojpr‹^]ix;9น๗^X[ZX s„ึ\ƒ/G๎คึฤTโ คD:[+”แg*Jwฉฃด–฿)มอS•“่l)น”฿,$G"tRkŠ+@ฆƒ%ี4่IาtหFษ˜[`‡-๕8i๓WฟAœ฿Cฯa๔Œ9zอฅฌ36ๆ‘d‚โขฝ๛ท่Y๎Žใ9้๙ฎNŠIซถ็3‡-๕8n?๏น๕m๖Z-๑๓*o~]ื)qฎฟลชซลx๑ ถงwYฦฤzฃ"ฟ”ั3ฆKŸ8+:}บฃฟ'๙qdgฮ’>•ย๛ใ๖`฿]&๒฿ำg๕ข๖บuC#฿พ}8;€)L<“๐c Zา’ฒึหKยG`แpx L&เค๕7๏›ๆท้djk_M‚p"จพtงใ๒๑Cˆ๕ž…œ๕ป–XBภสlqhคJข—ฆ\๗๖ฬจ‡ถ ตัศPYNlพู^‚ุT็3zM!;ึžNๅ}๔ํฑ!4ึึRI M4“ัะHkฌญฅซ๗N@Q\ผk€๑ฆO}€ดd็`3ํy-Ÿ–์ ้ฮม&jLaขผB—›( ญ†ร”ไ;๋Z๎|ฌ–‘้RQiฆ•Vƒd?9ืd%„S†ฟฏฃdวฅ”™ ภนภa๔Œฆค$‘v๛ม‡z&@ๆƒ˜ฒeฺ*ว๑dŸ0FG##lkf ๓๎?ฌ@ๅ7๖›ิs–ฦผฏ้–‡^"๙ฝจ‰ ?ฺฉ!ฟ&KsบกXiบ ฝวO6ุx–Dคgณ;Fjชหว้ช“Nn฿Vศไผำุฒํำ@…M[๔ิฝ๒w”ฯ่}™รื\^3เTผ9ปไUW‹;ศp๋v๋้ชโŒาิ ร๎็Sj:hฒTuาI—ฝ๗‹˜€ฎ๚จVaูฆฉoฮฅ}พ„Zs๖vj#† 6R[ฅ!๋}5ฃฎgŒ฿ฐQ&่qำroฏนๅวmQๅ๙แdๆอผณษฬt‰๚ภ๑๊ยย3m]ี฿ธ-žmบ๎b๓โ+ีฺ‚ี2-Lf/qพ๓กำๅาPตAb$ฅCˆœGัŽร†Pzำuร๊;๏‡?ศgฎฝ((ŠIcZ –จเ–ต ๔tะ๛z€๚”ทTAe฿YฆผฒrEโฉ75ญ ัฏ๙ื*KBj%†_ธก ๗๕;๖=aฎ“„๊๚ข๖วฏตnะปM๎๑KCจžพแผ]้3ธอœŒžอฑZ‰งรฤึบxbฝถHฯ๒ไ[uป9ฯbฑ€t่$Eำฮ?8"๘’ทอ €ดะ+ `›V ๘ว3'ี็วE!บI\<;*พ†ว฿VcึŒบˆG…B‡3ƒว๓บ\ฑ#dฒ˜XLว‰แท—I |>˜า้tžะsDผ' ๙ี๕ลฺฆฃ#=h _๔าถ๏cใUฯ/ทŽฎ/”๑ ต’Eซ/ŒOฎถำUƒ8ฯนฺkXx~e๒.หฬ%wอtฯ'Gขn9Hฉฏฏd ึีื4e฿๓ุrข ZKท๏wš“บ๑n%Nxำnๅๅ.Wฏ ืถ๋ฤb;Wฎ…&MViIKกpฏBp6}โc1่mปL“มววขhC๘VDฝE๓หO˜:„ี๗๘IHqสtีฆไศ—%Taeรป ว โjฦ๙_…ง~q ‰ZฎอŸ๊๊j๙…E4เ—–-ห+็’ด‹Zž๔*ฯ]_…> 6Lศฏƒ/ใœญ]zSt๑๔ฅ_N๊บํ๋ฏ=k*๙แj ว x<žF็ิŸŒท—ูตฺt:ฝใ`Šรแ่๔๎‡ทoœ$ไืั๗ฒ้ต™{$ต๙ฃžๅ๙B†‚ฑฝอ5,`๋VR\uฯ}6:^หl,ห QฉT`ฐ<žŸˆ _ฉ๘;กษ3วŠ๘egi•พ{W€Q0sด5ี"งีVTิ1˜P”—?@SWž€ธูๅ๊ —ศŽ7P‘:ีสrขะ็rฬ๎}ฬHวศ9nต๙y5c งห๒cฑBŠ3๕•๒๒?|ี†ภข1™๔.‹ลข1™]?,‹Ie0บ~˜,ณ•ม่๚aฒXฬ:ฝห‡มdฑXฬnฌ~r\"ขbิŠŠž•๓]๎Ž.>ถFm}T8ํ‚ˆšfNถKว’๘d๕–IฅคไpY›ญฉ/฿hฬ]6JŠH”ฝtแ˜๔˜NcํK”ีืQฉ*ฅ ส๒Kแใร< ผ๕ข”Ÿ๘u฿ืt r>๎๚, กƒ%X‚ิ$Cอึœ๗œŸ3มรW”YYZ&ข1iŒ4Ijศ` ็ๅห่NWใ#JOœ:–‘—WษN("?LšKœ8ulKv๖WO๒ ๙awšŸž9aฐำ๓ฎ…(4U}Lพ์yซš› ่iู๋XศชศCพจ‰๔ึ๘ำดvธ„‹3(ษ7ไTgๅเืl๖ฑ–—ฤีๅฦ:V๕วr9|ืŠ„k&ฟผ๊‘G€ช€){N\œ}ืต„๙ซ:สญ๙˜Mฉะ”S๕ฮธผ/ฤy‹_ฐณ ฃถเฅฏ๗= |ล†ะZ”Yู3|6นgkA8”Pุ3่๚˜CI๋ะท=ƒล/J8L}ฟ9ภ`0ณ}โgwขv๊ํŽจ)xW\+ั”]ิถŽ8๏‚(wผช9๏นi&ิBNํมฝGKYะ~ฏ๖ฮ็Wศเ>eFxซ‚Nฯ_ธฟฒOšฏ ค€า†๋๑Xดฦชขด0๗c้ฝš๙Yˆ์>T๘t฿ืqฒ๑ฤwVwJ๕แแล—l>*#@-y}{—G ธ๏ม8้m™อัggฐ๛@ 9_cสึ…”ึE;4j๛+HŒฒŒ`ท)m)Eฦm<ถGฐฅ8ๅฦNฯt๔4ฐ฿†H\ƒ]ทn๚ูณQ85ยƒชชjVVVO‚|/Ž{Zgฯ๐๐~™ไ๗…๖Š{ะ{lถ3Šgฝ~/Sc[ศถ๒์4!ฟŸn)๔๔,AA฿”ุ4cค‡๑}Xy๘1e"ิ๛AAไ7Uฒํฏ฿ ฬ๔รsW๕q‘HA๗AA้-T@AAคทPAAAโU›2๑ฎฺ“@ึ@—=€‚(ุ/AAAไมซ 9Ju"ล‘ 1r{Qฐ_‚ฝฆn๛ูi?๓›ฦถ๘ฯใพ๏จ D•{ฯˆŠ ฟํฟkž fฐ‰{`h๘ฝ ถล~โไ!z.O.8ฏ‚ ๛7๎?~๒0่ผ"U/œฌๆรืB"G๕฿1G‘ะ๑ƒœนoD๘>#ั๖๏š๗ใccccž>พใ„Lฬ$‚๔ฃฃd2™L&|Ÿuูyบzj ‚ ฿ื๛๘IbCIฬา๕อขbรHฬา๕ตLDม~ฒ๕โI็๊6Aฎ๕v็๓ฤฦ๒EB>mถผิๅ5n’‹N\7|๑ฏห๕์ฐฅ''>ˆkHƒบยb๖ ข`ฟฟ†ชsั–ะ๚hว,vด%5"ขฐ +=ณ…ศ๒สส•I~™LhŒŽLv]กJ‚ฬŽA€ย;n.ฅJM้ฑผFyv’@`‡˜:ป;ฬfu|ตŒ็ฬš>m๒๐๊{๛‚‹ ๊ภฺ(โ0ำํ;-หžU๔ล]–Žžห“#Nซƒม5GาถkพO@ร๊เญณ_ุ†rฌ `02๑ sะ –ฐย?›หธญฎDฏ๒o9ฺ๘๎9D‚ลb`ฑ่น‹‚|/^ไ—๒อ$ฬNP 0rO์ำุrlZ ฅŽxข(๙ส rŽมo›X‰ลพw”ฏบ' ้l=ณWท$์VXdtb๖'v}'ฃทi๏jฑ dmซUฺBe.ษ๕Š! ˜4Oชk๛ฅสคDC+๙ฎํ—Šยยˆ๓\”ปถ_สนr•h้3บk๛ฅŒใ'ถ\ัฺ้~้ล๎ฝDืƒฎํ—bท,ศ“าตYQqZจœ`Zq3๔ฤqy~Q๛๊ศ1?}gฬuรั ต<Y๎ด‘็sN9˜ŸP9oไฮqฌmฐ}ถ็๒@c[ศถ๒ซฎณ“v๔ภ๐I8๛ฎ+ดทผฤณ๚? }ฅ—ŠŽ้{ฝ…ษZี|fž๖๎—?k๙Ct;H๑บ1|ฎq๘้)&B `jฤ@A์—เ@งำ?ดณฐฐฐฐฐXผะ”]Oเa…IฦFZฒ<›/ 4qhนJ๛7 0ขข๙ๅ'ึ9œธำqฒ+jเโ9ฟ๒จอท#ฬF%๏ฒ<]ifฆ‹Šา+œ–g!ล)s/ืœใ๊จญซe|๎๓ภ`p๋ฮRWWห/,าึง›_ZFดฌ‹UIต<้U0U•ฏ{j‚‚eEศJO‚ ฟ=^๕a๙A†:2r6€‚(ุ/ม (/€ฆฎfo$ศฃศบถษ์qˆ~ ๕9ำ†gพหฃVTtฝตP๗gฃใตฬภbฐ •Jฅ‹แX&‹ล 3ป~X,“Nct๙ะ™,&“Fet๙ะ˜,&ƒฺJ๏๒ก2XLFk3ญหง…มb2Zšhญ?อ ‹ล์†ม๚yAŽ „ำ๒l[Gๆป]|lˆ{๐่ใ"†๔bป[FvJตSowt๛ฆ0ฯำหjด`Uิ![๏8ฮ}r‘.ธ/OฑฉNง๔š‚\ืMgp^| ฦ[ื(‰3+Dœ๔๒M(ๅึ๙?ศภฺ~ฝั(งฬˆSNฦ•2??‰-๛ค๙ฺ@Šฆรอ`ัซŠายNzœy^อs&P๛%คฏ๔ฒะJsž๔p๑~\ย}'† ยYทƒฏ๚ƒtฝ]SจW=_ไL˜์fHป๊๙"ฆ Qฐ‚lฝจ? ศoี~รงฺh๒ลG>Šฏ#้ฯ4ššr,ฆBศXšr,&ฏ๚7ศ†๖Š‚_ัA\Uyลœก*| >B‰=€‚(ุ/AAŸOJลXK]IUิต•ฅ๘@@i${ ฿ƒ‚ ˆื>aYVUic‹๐ VUic=Qฐ‚l่J๒g@๗~~ALC]]',**ฬl*k  Ÿฝ๓Žงฒ‹๘๏nตณg"E(Tาภ+HS‰B{XEi’Jั.ข๕ถ๗ฐ"šf*;+Dqอฒ็]๏ฉž+ข๕๖|?๗{๗ฬ฿s~็9๛t~igยฏฒ@kE”ŸC?ึ/ก V oJ”heฐ@kE”ŸC?ึ/ก      ถX((๊$    ”พ‚๖PP>+6zžร2๋๑า่…n(ˆ %ๅ/ง฿ขŒฑั+กั1๗o1GตŸทซป„œ[$ี฿857„Ÿ^ __(`ๅlฯ=‹‹๖ื‹ จฅ๛.„DE>ณsถr็…i#์๙7ไมร่ะ‹VŽํล;N|ยฺ—Bขc"om™ก๘้7ษ9‘ฦ|]ฟ57„ว={๖์้“˜๐kวึˆ 0k ๎xBกDฎ‘น)‘By0›พHVg)สญ%™ฑๅ ื?Ÿy๒ฝ๚เ๚๏ร”ท…ู/ฃ‚ื์ี1สเ‘šบใzl๚›โทนiOฏ{›หฒkลKฏŒค๔$Kธต–D<ฯ.,)ฮฯˆปตืJžwฏสDฎ‘€ฏKˆ๑กb–ƒฒ’ผิ˜ณk๕๘ƒกŒUฦาำ^ส๛ โFวcฎฌ~FG็’–ฺŒ๎kๅ์๏ๅfŸด$wึฺž๛๗e”วNJŸ๙VrŠI๑า๙‰ษEAA๙eฅ๖ฮ=๏r๗๛%ุWงฆ฿๔ท nตลY*ัหvฦด๙รx์v.๖C’…๒c0]3ŸซขชW7œผฦZ:k๖๚หิK†a@าสลŽpoอฬฬ๏/ป}™‚#jแ้ฎ๘j—Œi๓=ใ%ืน™w๗5*ž๚๚^xัะรqAตมฤIS(๏n3jภูc1าศP@ษะP๖ปผWœณ๗‰พๅavเ'ธŸp5{{ูg฿ฝrูiAฎใ๏Fd8ฆn9บL_ ่ชมˆ I}๛}kฦ๗ๆœ‘zึน“ญwŠ๘อ=v˜"ež๓๕ฃ ปx๏š ศ๎]ิAooo๏หฉT€ชgม๑uภฆ„TE๛9ปy‡ื(šlฺ็จ2hูํ#d้๙|˜ŽŸmo$jถผzi—ž๗จ๋ฒ(ฝฟ{ƒฑgu]ฟSv๊HKK[ซ5‰DAAA้ว9NFa*ืทํฯฝ๏ฝแ1๑Y)IjyมQ?ƒ#ŽิTIป‘๓ฑญฝพ๐๎ํMM1ิ[qไZไร˜ˆห—่ Zjฒ๋ัซแั#on4–๎Ž #Ÿ˜i Sำp2CCี๎›ซ…ฦฎ>๙2ทจ 3ๆnK%Fฺิ๋FBvaQ๖“Mบ๎X#ึ๏rD^ชุ Qm๑‰จ”ผทos_F9h๑H(ˆ4g_=เu๊ไฮ“ี†ย สทแkอบr*ะื?่^XtF 0๋j๋{sฮP๐yาณจป7ฎ…คึะ๊๋š€Yš|๗๎จฬuตuLD๑ยsฉต/ฎJmD.!ูQืฎœ:๚@VFz30\ณdณ)•• ฯd %วยฤ'<ฝ0/้ขฃ*&๘็R(ฑ&VGฝ.สœ% คท:(๒enQAVโ]ฟ๙ชฌ๓๘„๔VF$gๅผ?j3‚1^vล๗๊้]Vภ๒สฃsuŒชt|า)”w/๏œt™ุ๛$‰Šk,…๒lใ๐!w) …ณF+mบ๋zBV^njฬ้•ฃ๙YnE—*8ดhฺพศ๔7yฯŽฯ’์W:QNญ๑5l2ˆ๐๑IธŽะWG็_อ๋ลธYWt 3Dˆฝ‡ ฟฌ(ชง0๒๔˜1G”„…ัdธ--ต๏|Y ฿œฒ]›K6ฦลฃต์รŒยโ7)QA.ฦr$v๕6๖Ž;bD’ ฝ๊จณcฦœRW6็พUฅ8yYo uQ"•ฮึBญˆX–:…ใเซี _B+~vํฺตฐŒฺฯคHMมลท>› l*ˆ-ฝMกPฎ HญŒคPrฒiำฺ‰CถhhxH ผND?Cโ็็oojคฒ~0Ÿ๛อX{ฝฐฃ–z่พต`šน๙ฆ้จ๏ิu*ฏ๗ฺฮ0ท5QมuญQ็R'้i๓ไžmณณ•ขธn‰>xq๒Tหฺ9ืtบรนึนmU%ฌš้cmf:ฯใึ[ฺง$ๅT%๘ษJรd๚๗JCมส.X3้uเ้๔G)๙ED™5ี๊ถปทL“ฉฎช€างงnฆ5`รต•›r๓kูx'“ษŸJHcสญณ๑ศ80S__ีํˆ~pไัZ %yํ฿ทždg็5ฒœaจž›[$ฃg=ง๓ฦnฑ]๘Vล๎pภ2E๎iŽ:Œ็L;้} ์Mื่่ว'‚“?ำุยป-ศ™A^ป#๋Uง{ํ]*๏]ซ]‡ด^ฎซ:ย๔P‹ใ ง๎้Jฮฑ๚\มVšฃr Wอ๊}ั! J_Zโk‚ล&ƒ–lง,3Žิ๓}l‡ผ’% b˜ฝฤgˆ|ๅูฉE๏ศ€l2อฃFLœฤ =q"ott*—€`\’6๋้gf9ฺ7Yj‚๔ๆฝO ;b์ˆแ&ส)*7ฌ~๑rc)cบ’ค˜แใ]1bิ~!ๆว"ทิ‡์ฺ!์kEไš๖ปAlr4%ธนนนนนm8๘ธ€ZXX•‰ EZcFใxฦ๊ฉA๛“ว๑lบ?-aูiฎEนD‡ฅบHˆ“s ฉ่g_ ƒ้9ูOooฃค^ธš›ฉษi๏ีX]_)Eฅ๊๘ใi5m97๗{a;ป*”๛็โKŠŸคu,จ”:ด&10ง™อฃ_y.R!CNŒ๒ะ๊„Y๕T€’ข๒ฏ๋’[;7U(ตdงฎžqั1ฆฌzuG"‘h4ATYSƒ‹ZJ%’บฆxf๘Gบ๋vF๘ธ๎OฒญาEW แ6๓  l๙ๅeึAyl\+:^xl8<ุ่๖๖ป๒๕ๅ๑q\ 78So^เPUM->จฝ{๋flทDŠ็#ัว3‡ซqAํญ€}gcI ใWOhฮ‰บœ“ตฝ{,ฤฌฝ็jž‹{›˜๗Q–wฮ\U)€bเ1ฒwY๏`ฉ-†๘๗@(ฺ๘yT…๏\๚VJรf๋๚€#๏ฬๆž‹4‡Pๅฝ์ฝเxGฬw_7ัอ}๎ฅ9Wไ6๛Oงpw|(0wงว๑cลำ,ฯ"OA €XB@aU่›UP๓dหบS…ษ\มŽ ๓q๒๐Qวเ#9|dmzๆจ๐u;ฯU6~™žฑธDืผpe๘ฯ#™’ํๆKดษผผ  ฉE†บ‹ว}‚Ÿ๑4Œ›ะpด– ะ5ต๘ก๎โฑ]มฯ0I Kน `p๚๗฿‹ขšZๅรฉ h ป{x†ค}hMผuใM3@ZrZ+':ช„า7พดฤืหฟ0™a๓๖ญะs‘Kiจ๗XยP<4UQ.”ืc่ aR‹l\YHa"วฟ6NGCอ“V:@SN3ƒ„6&ำเๅŽ‰๚„kผ“&I?<•ฬ`็มธฐX,_LŒSœ๛่”ห#VฬlฝฏbGŒˆSŽปใีปฆ€–5JŠ( ๖=๒’แ๒ชๅ2สZูO=€bญ๐uYช์-˜oƒุไ่(ˆน\ภฉต)dทHรณMKŽไ`kaแ˜1รแ๐X-แั“6๖แา฿ี”l๛X5VRึVQฺR/ธ eมมม๕%.ฎ์kืน˜=฿ด,–ษ`pฉฬฺบa†"Fล๐ˆมKึŸžF๋|อ… ฑy ำปฟ`1X–K‰Yพ—h€็hฃผ&๏v๙9Eฑ‘Ÿฦ๗TT~๚Zใ?ท\r๗ทyRพฑำทฝฃ‡ร5วxšฦ๐Zโฉ]อ†ฆPW0ฏŒษๆ;1k7—Š"hพป„4GธOŽ€QN๗่์บPlcwฑC5๐8hใf๓œ„f‘z๕ค๘ว-หํ฿>Œซณt  ๓NฟžA"psq€่. ฝม š๏บnŠฒ “ ƒผšำป5ˆ•/o๏t.,ง‰ลŸซ0ดผMŒ| ‘อบ—ญ—Zฉœ๗ห’ ค ญฒผUโZ‹โร:+Šฐ:ญฅสษJƒ๎์ „7'.„็AณมZc๋ลรรูFิwสn8ฏพR.gตใภฎ[‡ชวz3ไk7๚๚฿X_ใafึว่z\โรx’๗ pJา’‘yง๋ ยd2€Ngซช Rฉ@9;Gๅ ฆฝTฆจTPi4 ‘H@$u ™™Wทf๖)‘?๘๒; cw.ึ‚xฎ–๗ฉ_.w|jŒžฟ๛ฎฬ?ฟ'งแ‹๒๙ฅu พ&X|a2:ึ3gอ๊yFBvมกฝqƒ ฬๆช3ฌ–Y;๚d\ˆaชLGŠฝณ}ืO‹kฯa๕QMฆ:๊Aพหฤ1˜GขG>ฝKc๏ฒฦ๕_woลญ{ยึHR‹Cํ๔พ๛†ฺซ๗มจ.บcGŒƒวLU4&0Kขทฝ้1ศ—ุ™8 –€ @o#Iˆตขปš๖ปAlr`ฤ-YซJนdณ฿ทt`พJHข.4ี#ฆ"ฆวฯ|๙๐Qใ7ยฦ`0,‡๙,ง฿]|ู๘ฦำ$ู/€ ˜ฑ‹,^๕tโšy-ม๓็ล61ญŽRc9ฅัhX\ง&ฑ\dLำวfไN!F{wี๖g[H่t๚'๏ุžO„GvxๅถŒุ”๒6่k/Ee…Žจฤภว๓;ŠS9ณะๆL p+N4Tiyขฌ กบ/,Yw‰‹TUU๐ <;๓~Z “ฺX๗ชึUOvล#iž$[ฉ„Dล๘* {฿ฎ ฬŽชฤ—…>”IF}ใi๖ธล'‘˜yฺษ5ฃๅqฉ!+ทT€ฺ ฦ{_ฐœuิื€"ƒฌN๐ฝอย‘ฬช?๖˜ฑ š{๑…ฐตฌำรฦX;hpW_ทีwŠ๎๎รฃE๑'@2ส?fšๆญgT†มb1]•+็”}q.งe๏73:˜ภaแoœๆ3a๎ูrภb1ฌW6Oภใp€มใฐD"!77ณื8๛D%+9้u2&qย%ฺZŠนกฏพvำ]Bบ‡iพ ๏Tไ๊พตฬ) aะว•๚๙’+fGsC@งu๐๐=\า ฃฝฃK’:ๆฃ๘฿ฅ>Iฅ|ชพฟN็ 7a ๆณzŸFฃ/4<าŸตa่}(,ุ•ฯOึ๘š€็รt›LฌปŠ„๛—qIQ8ฑฏ>7พฒฉ๎ ขq๕ไs3*๖O|—ลฑ1™๒ั•๖5๔Du^D;ต๕ๆ‰ฆŒ๓.sฮฌ4~ลมเ -ฮU~ร{_•ฝ๗=GL:ณ-,'ใ›‘๗oล^w:ซhพœ๔juแฉ•๏Oฟฏ,`7เ‰X+๖๘SYb2™?1""ย฿สิ— 798ิ]ฮ˜ม๕bืผอป6ต%&ฆ‚ฉๆ˜“$ๅ ใาฃvเEฅ์ฅลไ๕๗ไ๙|๒แ๛^=์*ตgฅๅiฮœ7\ƒฤง0ำb|cFV5เ๐xnN,„FN-ฺ"$%ลCฤBia‘ุ8 ![fฆืๅ]&l5|_X$ขฉ'M )XmูณPๅฅeโc ”ๅ&9ฺŒํqLฌฌีฮ}[ทv3™ปไxrg๋w2๓`Z๋๚ฌฮ€์œm>7๙;wฮ3Sbใ”ฬญG rqKMž๗๎้ณBบฌ‰zKU^,`9ฅ๔Gห—•"4T =ํE–๚ฬ#„98GฮŸฅ‘๑4[=bภrˆOะQXQ>( $ˆDl๑“+7’+HDึถขิ” kNRSำต๑ปu๋ฤ’Q$(/-eyชำnO฿#Ž]ห5นUMฌญญ')โศ๊fึึึ๚ฒ,YBfจTmฆv^=ปี“† ะ„ฦ,^ู‰อx„๑f”Aง=9งฝtทวสตพฮฆ\P๗*…ต๐Mlคฆ8€4|”  -๓๕;.=๛๋—:zญ1แ†๚/ ;# J๓ทnYตnŸ“)'4ฆฆ๖gฑR aรซfjฝh‰ว*A`—”vพฟ๑6kํ์=้”ffี!;*NOoฒษO‡ๅm๕(้ีP”–Zd“5[์ท >บP™๑sำ•ฅฅd#] !1E9Q<ๆไˆ›ขภภกฒไ๐ูีZฤŸœ"”_Zโkข๏ด5ะ€G@ยfศล สฮสJF\lŒ ‘ฦŽ ;“)yี6ัษn|v๔ฃฆ]~f่’ปŒS!Rk+*๊่ฌ๛Aฐอฏ์ฝ๏9j+i!ช‘9ˆDฎ!k‡I(๗ณUR}:;ๅMU+Yv๏จแฐS<๛Z๑หฒT]] `ฒึว๛๔๑ฅฝ^—Ÿdmm=s” HทถถžฎNFnrฦ{sQ'•=}Tง=วฺฺz8)€Š„„b Œ]iฏEณ‰ห|ฤ(_Yykำsฏ~l”ฦV๗ช—๔9(้ถํ‚ญฎฑไ๙…r˜ง๎lผตcฺ ฿ ~f{O๎‡UW"๏๎พ๙|ธกนไ๙i฿pถ๋แ#ฑ้ภmG2ฎ•๒โโžB*|Œ บ >fฐu๏mk>h๙๘๎ี๙ฝ7Šู…Wyg—๏73‹ฤpr"๗์๛๊.!'fฑN][yว็ุ_)ฅWใV0ฉอ฿ง‡๙ฮ” qtM;๛ํ1mฝ๑–l ถ ต–g?t๏e+t=pฬJษaคัฐะฅมขSšNr๖ชbฦn~ฦพ๒z\ฤก]1รœ—ุŸq}็lณ;[ฯธอิ: nธfkื8rลฉWโ+%(ฝQ~ษeตž ๆv'0j„๙z๙g”kศณgฯžลฦล={๖์ูณำ %บ‹b๔ƒ‹๛u„-Š(!ฦ‡Š),J๒ำž\:Uชซ๚ฑๅ ื?Ÿy๒_y"YฅP(ท–ˆJD(ƒˆฐ๎ส€ฐฤฬ‚ขWฮo1–EJž๒๛กใ•B๙‚ศ5าžษJบฯธ้ ฉฮ๘P1…๋ฎ0ูฟ ๛๛_€ธใ= …นF`ไฆD ๅ}ภ๔~๘๏ฎฌสJ๒Rcฮฎีc{ั๑ฏf ๖.d์•^Tœ—x~ฉ*ป๛->+nพผ๗?ข˜]๕# ์ำ6}*กงsMMญ=ใฤืฎŸ&โVžk…ฃ7อ7›:o ™ๅ๖S๘Abโ,ูGฮๆ๛ ฆฮิลp๐๑ก—ˆข "i3 ึ๙Xdm```ฉ †Xy:Kฤnตža๎pเํ๘ํ๋ ธัขˆ๒—๒!.ศ๛เญbก)+vอ"ณ„็lวcขoy๘อŽeะเ3๓9ปี\ฉั้€[EFซ}็ู-๘_หปจƒ—SฉUฯฝฝฝฝƒใููŽ๒1าศP@ษะP๖ปผWE๛9ปy‡ื(šlฺ็จ2ศif๏ฃgฺ(=wŸ{ฎีhฮqŒ€๎B๋ั์{J#—ํuา•›่พgฑroํขA้?ˆ ๒คDEไ7ttิๅลฆTJIIGjฉd-j์่จห \๚ฯ†๛๕ภ&‡วแฐภ`Nt‚ำ!›แฟฅฅ7ˆ๊Zร3"nๅืทตVฅ‰ฉะาŠE”ฟ”บW7m๒น]$55E^IกPๅ$<ˆ:ฝTฑหFฺิ๋FBvaQ๖“Mบ=ฝ]r-ฝจ ุ้LแFs)”Xซ#^ๅวฮ’า[๙2ทจ +๑ฎ฿|UยฐyกฯsKส(JYi)…rูšู;Qm๑‰จ”ผทos_F9h๑€š{,ฅเฐ’๋้ฏ‚fwธ™•}ำ^กฟ‰ฉ? ฅ—7ฏ฿ณ฿ำ%(8'Lึร#้Q!lด„ O่ƒ7ึsฝ™R๐&๕–ณ& J ๙ญจˆฟžKจ}q= เVjc็Ÿไ ›nงไฟธบj$ุ–ไฑซOFพฬ-*ศŒฟนR‰€ฌO6ช๏t.&5ฟ(/ๅ้ํร๋&It5อขOฤ0‘า‰œฃฦa05 '๓14Tev]ฏu6{ฉณฃฎ]9u,๔ €ฌŒ4h~%ˆ๖i›&>แ้…yIU๑;zLpe<Šฌ3๔ฝฒL"ํAbาทvฉ 4ฑ‰Jh๒ฆ]‹ @ๆฐgใ8๖ƒ?ƒาศ ฒsฉภ๐+*ีีื๐๓๓ำ๐J v_ }y;ศรD@yx5sŒ๗ๅUbwbZ๚๙ฮฌ:โt<ญ}0R€‚ย~~๖ฆF๋GcS#™LF‹"ส฿ •J ‰๐๑ษA77ทเไŽžrOvิaBพฒำ'@ร}Ÿ5พวv_Jภ ‘ฅ„)ด%ฐ_ตuร้‚ˆˆ@ง๔๋’ฬตฑทnฦ>:šx5ัศๅQux2ž›ฬูœฒ฿! ฏ๓่1Lฤt"ๆh€ฑTสใใJ'npาIK`๕ศุeนf…Uกo๒R,แษถuง ]>๚Hทฝ@m„ฏม }W“Hโ์<1:hRsC†]ณ๋ŸฬniFLดQ๐‘#มห 8ๆ๘‘#gbiCุ,•”๓6ธuœƒฝ๔สยnูq2!๏€ษd2^†สฏงC}๒่w็ี†B่sœ˜ฏ%wN†i;žธนพ2าoSะซฦo…‚2˜Sš@‹"ส฿ˆœ•W๖ญEW^-FvD เh4๚ืT=cืท+‚พŠH s:(g็จ\มด7ƒสt"•J*$ 0uo)ญ+vฟศjญjฉ๔๎@ฟ๐ฮ5฿ueA'/@ห—#฿๘? n19ฮถ๏‰$}๖™>iTFW‘ภ`0ƒRBฺjjšHyg๑UI&ฬ;z ˆ<ภอล }"ชŽ้ท๑ชฤฆYฎ' \™m%๗ฏr Hm่ฃ>qLไ0‰D„t"ๆ๚๛ฏ‡”ธeน‡qu–Žฝd‰ฒฮซฏ”หYํ8ฐ๋ึก๊ฑ+B๓/]๖]ŸNgรfJ7ไŸ็dyธ&O=๋"Tฝkลฦาฏ1K“n]Oเ๏0pœ,IIพu=ข!ธNcCถEี1‡ วn>ํ์<@}C=เSกฆำ้ภgฐiฏEอก๕^ฏ‡Yxตอๆd••zb สฅกกžฤอ9วรอS__‡E”ฟ”๒{[l[[™ำžไ๚เG ฃklŽ€ฬ,„ \ƒฏ^>โ ษ9ˆ˜อ Mํt่่ vE„วใ€ี๖ปฺo%ใˆ–œŒ์ะ‘๚sถ…ฝ๛ฒ•ฺๅdๆ๎ฟPฝ่๐ฃ…ง๒ฟ๗พ' ถฎ@@@@สๆ\BยS๏)D}๖™~่s0JศฯKrmศ####=mmํeืj๕‰ฌ:Z5—iš*š† ถ ;e‹ำ๔ฮ๖nŸ๔๙๑ใGAA —ฐ0'@Mอไ0‘า‰œฃพว๋!3O;นฎ฿zฃ”ศ๊/3›ŸำFษJNzvvb๐kk–kตํฝว]๖ม๊Oเ๑8ŒˆH็พๅตi[9%ไ‡๚c‰Œ‹o กอU\k+d1X:ตฃฃƒ l๏#F((ฅ=3=oู,ฅ—!ฅ$U C๑ิ o †E”ฟ‘–โ็ั1ฏ?ๆV51ืฆˆ ซ›Y[kฝ‹ฟW^Zส€qSvืO2yT฿Xล.ำ 00ผ๘าฉิ็Š‘โ๔๔ฐ0Yใ™ฏส?K€’žQ ะฺ rญgืฟฃ2้ํu๏าRJ|cqx,ศ2C๕ฦh๓7ต๓ู๊ญžtžmdH@VbBƒญ้/ฟึGอฃญีก=๎Y2ญธAŸฦ} ƒคฯ7qHNฃ„ฏ(JMiK-รIj-ญZK6Zpvณ>ŽจฯkHชใณ ›Ws^า›Z ัซชXEพo๚ฬKJฌ[9หrG@วs>ฃIfQโ๓*ไ0‘า้—ภ.?ๅi‰ุโ'WŠF™ฒvZ!e๓>{ผjฆึ‹tdLL_๒๕จoขฝรเoณึNUJ 43ซชซซคMึ๚t,aานA<๔ขษ'++[Aƒ…ๆชwZ‡ํำAฎฝ2๓ †ำิ?๎;'@๙ํGช&๏บzสIน๗˜z€๖ึVภ๛'w(F‡C<†EGผ ~#t”พฃน!<..๎ฤ,AฅWใโโฮ-’สMŸฃ5S๖\ =ํ64ู๋๐“fด(ข €เ$g???G"€˜ฑ›ŸŸŸํ(ิ=p,นŠkคัฐม/{ธfไ$%ิดทผMœM†ญv8์ฌRฒ๑tŸ.”wsณรม€๋'Ÿro8p๔่ัc'‚.†ล?๐ะD์ทFฺ๓^eู‰ถ็f›mนOืšฉอ>—มNฏฅ>dณƒoX‰ˆ้ส5๓†5=9นzร•rd}๖™6$} !:i%ไOก=fปญwhรุmมงุ)ึ$^ป๗ฒฑ| !ชŽžR3|Žหพภcฎฺu!>K|žฒf๚ฆฯๆh๏e‘%ไI ็ชCฦ5'^3‘รDJ'๛p”งษัตLุyRCฒ ขF.~พ;์Gu$]qrน๒ว'ธ ฺ;`ตm7o#Sแฝ๊H@๙อƒงา?๒ชO”N๒:œ้ฝฑฒฒ ๋v๐๙ญแNยแAw œ( G๗รSง€ลn('***นนน??^’ Œ”ญบ˜าฦ/--@ฏ.ฆ4ะQ!*†ฐkZ3ณฝ?ฐ!(ฎŽuพพbถjpจฎ๛๗œu‘‹๒ขซ่ ((((Ÿะ๐Lพฟštvถ†')ค๏„ ฉ=QU ๚๕ฃ๔๒žว4}๑’B๏EA๙8n2'๐\‚–ผฉ IDATฌ/จ~Sˆ๒}ผ‹มกlนูFGŽŸQ[˜tมo๏ฝPw 9aA๎:ฦ 1ฬyฺพ)ณ]๛Wjrึ<๐u:”X}้C้ Ÿบ๕Fงูฃexฺ+าร๏=๕โ€{ฤ‚-hKqถ—gFœุPQK<]-4Dheฯ/๏๕ฝ™฿ย.Lœ๘„UV#6ล๕๕ -์ผ!DrNภ้%5๓ทF7€ๆ†๐ฃ3xLFGSe๎ƒใ‡Ÿภฤ1ผ#ฮ)ูn์“ภ^ˆŸโผm๙%Q.FcYึƒ;ฮผj Hญwwœฌ"‚o,Nบดo๗อvันAทื ๏รญ๚#๊9L”ฌํนCไ–‡31LD;ฌœํ™๓Ž’QYr“Aฎ็^รC๋๔ŠO๛xg€าดื1d“๕ocยy“Ko%ขJS#6Œคฅ๘K&‹ปรศ›9^2ผ|ฏwˆ. ™+ูร็๋อหoWอv:5กะล94ฃ็>pไ9น๙ฬฅ?7 }ร+k~hนa๑ลตู, ทฦ$— ชฒๅEqo„$70ู๙%+N฿bi Iฆ—ๆ>ุ}ใQ^๛ภำƒ๖PP ก้๋V =]=we1V~žใ๋งลญพ๓žถฑ๙ทไ“;ษ‰ณd9›ฟž:S๗Xโp๐๑1AxmQฮžjำซ:I2OOaGำœฌ0oOa{อ ฟ$™๐นหาj๛#„eต}พัoไRฏ๙ฬเ๕sข)ลู^ปึ้lm‘ดrฑ#sœyฏœsฤ๒ร๛–ฅš๎JbpLp๒Wดs้ฮ<ฮฑN‡ผ—d.8ž‡|Fจ…งปbโปอE ๙๙{Žธ™?_yณ *ž๚Vตฆ6๔p\dmwฑ/ ๋tr›อำg~i}MyฟšถูรZ—˜—Y๙-กLว)A6๋ีแ$g๏ปh;๙ๆซq+ฯตย๗็ป”โ†ู<`?%zรšะณžฐ๎\Ž1ฮVyo€>ร!๙DA๙‘ š ำ5๓น*ชบ~"™L=ปz~ ˆhmตฏK dึ~.ง<^เดูJ”ง vฦ"h‰Wc1ฑผKฅ5qWgฆt6y9Uงžœ\ž@`ไu กซ9\ฯMป <~๋\]|ษg%Dn†ฯDfเษM>เ•๔—ํžฉa}1 y@Œ0สy‘zั%Ÿํeคqฮป ็„•๔~8k@๛(ธิๆoธpŒ GใคS—ส:ฐโ๋ฉ,ฬฆุ้)L63DŒŒผึŽ‘ญๅฏŸ7ดwเ…X/šช๘ำ/(-o ฿2Mล„ ซบ5#ถxฎฎ><“Co˜PB์ิ๚ =3๙U[ุ๋ึย็ฯ?ดตY ง’ˆณแo[ Rณ;็šโใฒึ๊h"žr้่ IผžมNษŠv.”่!ศ8:ื๕ต9‚0คžBiRภb0€มโ๘ีTฅ!„ยฆR•:ด:แDV];@ใT’P!HCN<ขwถูoK‹Œ,iศอศiใ @}B|ฮ๊1ฃ แOธtu$โoค3ธ$ฆ็ยศ๖Zถ๛องฎžqั1ฆฌบDlMๆ๋zGPhษึx,`Iฒใฬ๗ZN›@At‰๘8 8๔ไF€ฦ”ื:‚l‹อŸK๑ำ%žIXภeวฯุปP;qOธMญt:"OG7มœ/='๊/‹ (์๚๙P˜ฤ9a๚hŽฦ์‡m ?5๑ƒ‘พฟd๕๎mG้-ต้/ ส€ˆaใ’D าtฟดถฝ’Š'ฐ{๑๕ด€๒‚ษโ'ส๏์?.ณฺ5h‘ญ4ํั…ฃ'bJจ@ เ%f๙^6ขžฃ๒šx<žNG€h,Š,๚V์:ฮม^zea7๎์8™๗ีถข6T•wฎ/ฟfPy€rœ˜ฏ%wN†i;žธนพ2าoSบ๕๛aผน๐มN"ฝต๒ศ"ฎrะ๊ชFเ•1ูผ{'fํๆ˜๖Žืใiภk‰งvฐ›+`v–ฅๆ๗ษ0ส้žฝ—Yย`ป‹ฅขจGภA7›m‚kฌฉAQุถิ@๙ีG‹ฯOU?‘๕Žษdผ ป•_O‡๚ไั๏ฮซ …ะ็,8ํqz๏cOvM#้1ฬWJV—Nษdเpx€†ุืๅสŠ˜\~]ษ์(ด๛0pบ๋@“วใ>ฦว/ีIาQNŽf?ฤŠฺุ๎@l‚sP2Š†mผt}ySsešŸKไJ•@๘Tฉาh4žm{ั๛7)ฟแผœ๕ญ*>ฝฮHlข ฮฐคจ—t 6T–๖mIหมA๎6O €`ท‰h2ˆ๕€ึZ๙กsJขqfพัไ้qภ็…‹๙.7้ฉฅGY๙ฦb †MZ&žพ%ฐ€็K๗Xy}ตšงwz๖#+“r„ตœีJ4๘Iฉ˜•—ถE^#ํm“ŽOสn๗tŠรb›ำำ8'โiดมุ๒฿[โŸ`qq๐อ:ฦ๚‚ Qแ/๖™ฦฦ...ึw..ฎ†ฦ€–ผป{ึ-œ6uึบ๙รgF{wีฺฺฺฺฺz๎ฌ้Nwช€Nงcq6ล๖4ูq&ฦZโฝ._โะŸmQuฬaรฑ›O?ฝT†˜lูฟPนห “  ๐lฺkQshฝื๋aV#^mณ9Yceฅ‡vๅ€€ช‰ู(Žึ6:€€ `}}ฯะษฆฃ„€Im,‰{U;VO กบ/,ฬอ๒%",RUUอ&ศ††zog[‡$*ฦWYUลฦi7ฬŽชฤ—…๒*สƒ1ถ3"“N๋|—ะt"‘P฿Pฯ๘๔‚ู้UVัาl|๙ฒ๛จ2$}"†๙เpx:e"Uู้ีร†ซ* ื(ฮxใšb!x<žฺฅไธ๘•Q:๊Y ษ์WืQ*K?ฃบ™,ฑ^7ฮมฬ|ฮ‚…vN๛cณJbฅJฃับ+UGฃฑํ†#z่{ใ—_ซฃฃ2Jgdj *€โา‹?ใ … ฒ_yQ‰๙ใโโBœGqš๎‹ปฐTัd๋๙ม]หˆwbฒkฐyC๔ฬ˜ ้๚ลdิล„๕‚oM:้์ชL˜ถz๋ๅยNไไดZŠ_๔จฬ1ศLษสหหŒฏ ป฿๙ฉc”iํm ^>มๆฆ๎๙:qM๓1ร%ปš๕๕u8>r็‹_@คพ๖›oณ>ะ›Md๕คฦi๒€ ญห๚‚ Qแ/๖™า์l๎๑Œโ'ฤŒต*ฒณ0ฒVฆkสโฉ๕ีี tผ/,ัิ“&ฌถ์YจF€๒า2๑1ส‚‚r“mฦr Wึj็พญปs๕9/Gu๕ณu4nm3ำั"’ ฺŒ) 9ูo แนช—rš‹มาฉTภ`ูิ[L*ƒA๛์รd2™Tใ๓“ษdtะ้ŸL&“๑tๆ#์วs็ะดrwš?ŠLโืŸg,œ’๒€.kโถR• XN)ั๒eฅeฬ”ุ8%s๋Q‚\R“็ƒ{๚ฌMํi/ฒิg.!ฬม!8r,Œง๑฿œ ยrˆOะQXQซ7ณิึiL6'aฑŠLP*,z ะ‘‘’ซ9}ถ2?‡˜ฮc‰Œ๔๎ใข#ิ„rr บ#้1ฬม)ฆศOภโ๘วTn-}ืนๅ๔Cz,u๘’qรdgฑ=Jฅ๏๐Jห‹ฑกฑ“Fตๅๅu*™ืฎckฉU—4(J&เ‰ยยD‡ร~ชบ+ีาย"1=CU~"‡ุ่Iฃ่……5์E๔PSQษซ>NC”,,#%ˆ๋%Y%๑qt;+อœุ$ึB๑w7]m>cw4›Qนณ๕;™y0ญ๕F}›3%ˆ&ƒXฯ๊้คัcG!žใี‹หOzvใ๏ žF=NฃSK๚รYZสน}Doนทroฝๅ๓ฉแวฝญC;ห˜‚”P1ๅ Mา฿ฟฤ"๏๘๛+ๅšยš๓0ฉอ฿ง‡฿ผ–] ๐uM ff{#"zฯฆฎGค๔OSrMaฎS๗>G Ž^๊ฑฮ\]‚‹^_โ’฿ymDYg{%FuVไq฿€๘ ึz!ฤั๖๏lŸyื›>1L๔็šฝvKํœปๆ5๖วาŒืธ ๓<Ž_แ ัฦ%Jj/-xธ๏zdz—ๆUฬvŸ›\{`ื๋่](}fœgดI‚๑๖๒57ื—/[kpT๐๐ผ@ขKˆ฿๘ๆf^Qฎถา”k{/etฉtุŠงVžต๚ปท~!0a้=ฐถลำ[(ฉผ6]ศjEฌTqาFn›—OV&ำ+3๏ฺ”‘Mโsฝ-ทow+MlN9บฬ5ค‚uาๅ/ฎnฬศuwฌ ๖ฬp ๏mูขษt์8‚ษฐน2e€(m>`3๓ำtm!ว๖์ฮ›i=รN]L˜@ญ*~}๒า่*6 วP——ชUท!ญ)uฐฟ"ฌ๙ฆW‚นpšKKู'/FEW๖ิฯื5*ั{ฝ;/มNr๐pฌ8น0ฌณg=bถ“}๙q็xึD’จร๖้ญว~ฯ๛ิ6๏Z?๓Ssฝ5ไิ๚นๅqKทฉษ‘ฺ)oใ]ฟ—ิyฯไ9๎jmท๔–ฅ Œฒลs} ~ฺ๛HŸ๓‘นโโโพ๊๋๋ณพ|๑’๊ญภkฒSืจ!gปถฑฦอ9หZP!*B}้?  |wแOF~A„eํฒ‘฿yŸ#J_P๏ัd&๏Œ˜–lแ ‚ผ]ภAพฃ‡ำlฌ฿O 0‰bwฦฏ๔|ญ“.O–ใˆเ$3๓ m ~*uฆZt$๘=สk!ย_Hฟ๚ฝญ_"˜ฉbe,@ีฌ/จ! สo๕๕“ฅืB๏นs็๖ญ๋~“ช.ี#;†ป"c๎ž]๒เ_ีy€฿๓qแV9vฺฐ!$เ:‚๕ๅ z›ภ๑Ip๓ั[)•tq>F+ฅ’ส@…จ๐Y ๓(ส๙”?Ÿฮ=m}w]ภ`ฑLรฆํK๘9%น๐Ž˜๋ฒฺRK†ปฝ"๓ sฏ>2๛!ฤ ™ธึร~’’'ฃ‰๒:๔˜ฯ๙ิ&ฎแs=œg’เ์จ|ไœ๔้าŒ์ยภเ%’1[ฆ๏Kิ|(อ‰ฒจฑ๓{\>จก š:ฉt~ mฤฺkซื/ฟJ๙ัa๖ งห)ซV]ฏ๘%ฑฏ‚ฟ“๖ปSwu^V@Pžh๊a*/วรฌ-+บp1๒๎๛_ฃค฿ขš‘™ซ‘Œ$‰VQ”xแYbะq๓5ิษŒฒ์~—R๒0“็™9j‹Š˜Mีe๗ฎ‡Ÿหk>kล bทศ$ph[„ฺsŸฺzฺ้๏x`xๅฬญ6(>็๎š%4œฝh•ฆค‰ัTS|๛ึ๙S๙lNUฐŠX?žี4jL 4นฦ๎6ยพ๓๛ตณ>๓็]ิ๗—#5mณ‡ต.1/ณ/-›ทงml-๙Z.`บf>WE๏๗ž‹Zxบ+&nฐ\ฤŸฟ็ˆ›๙๓•7Y>*ž๚Vตฆ๖ผึง ศฺ๎b)^@ื้ไ6›งฯา๚ž!ถบ๒Yบqึ"๋;ว็ซผNRŸ’gษ>r6=/tฆ๎ฑฤ4เเใc44 5ƒนx4xˆ=%-ME…ฤa8{ k32๑Sลธ{ ๋+“žtgK๒๔~,{”0y‰<฿g)A0];”SX๙ๆฺu0s*ะSX๑ๆาU˜แ2T๐sแ๙+`๎๚ฅ๐์ัnI๒gˆwิ•VƒX…eตT๘ก้๋V =]=we1V~žใ๋งลญพƒ\‹[yฎพ๏<฿ฅ7ฬเ๛)ั๎ณ}F_าพม ิI%นจูnอ8ปqแฃr‚‚ๅึmซฦ9์Šo้ปP~ฺา‰Ug6<ญล‰ฯฺufแฤ;ฉแ๋แรVฯ +็n๏็ณ4ย7นณ L6Y>›ซrP๎ C† yฬbห฿:ขŸ–๘฿ั‘ž‹ut •™=oๅนŠ็‰฿ษซๅXy#ห๓Fฦ๚ฅฆ-_ˆˆฆ“.ิ7 ไAmๆ=ๆ๏g๛–Aบึ^แํู ๏zs็์0+[xป’)กnฏี์}I#Vbฒๅฟฆสท๓2€A’-I…X U)ณ๗ซ?ยบ[ญง่โ฿g๖L ๘ุš๖žxุˆ•œ่p๕ŸQื๓ู^œXน`๏„v๗38๛งญŽ]SyเC5w1–jŒ๓wู๙ +nฐฮc•ฑ ™V‘rีoฯ•ฬF`#Iม๔[BถุŸLฃ๗สwQ[~าณ]ฟ Cฟ3mน่#ท6+ฐwDะะQฯ sฮ๙Hศนˆๅฤ|บตท pำบ/ะj“_ๅ๓™‰‘ฏD(?ฉ|2Z๋ชXŒย’9j‰งvฒนล‰ Lรaมœ่„ต^‹ฉkŽง!ไžศ9DY€ซงคŽžย)ซ9ไณ@55ทCyผฬgm๒๖ิื#‡ ๗พoKLๅc1Bฌง๐mหรx}km‰žย7อaภ`กถdOa~๓ฝ(˜lฃ-ีS˜ื|๛>ฺjK.ผะ* &๖Y?ง•ZQ B}"๗ฤyRข"๒:๒bS*ญค$฿ฉฤ‘Z*แซŠ™Ka2™ะืgฤ†_\’เWPศบUฤศŠซšญฉ๑%}f4ืืS๙›[จL&ญน™ฺ\_Ox—t&+๚}ฺ2“ณKฅ!น€คig'๛่ฤ=๙rฝคIม*bvรฮGb๋fmฮ8s๎v9+9jึ–™šช<ŒŠยธ—ข^5F\าsฆ–?TืัธฺŸ|ช๒ะห฿<๑ฝ๒8“ํแ(’FF‚dvOบb„'ธyนLช{qfงwh1+nฐvƒใคadzeFศ‘}็ำ๊Aocุ?”ใ๚ ๏๛Eส:ุxน{ีน\fˆjWวษรศ๔Šิ›‡ฎฟnbฟ–ํๆ5f dn>Rs๙\๑e‘๒koฌ่{CfลสฑB)gvx‡ำูDฤ.๑_ย9ล๛ถล์uTT[ภ๗&‡้ฅEฤTP1yb ข` vก >ฑฬง"b‹ุ-ข (‚ า%ร0๑Aˆ8C|๗ทX‹™=๛๎}ฮนg๎œ}2z๑บG dํ๎ˆตgpk‰ IDATฬsdญ'Mฌหโš๗๐Bfศ๘ต›—ซ‰`k2‚/=๙6Ÿษ6๏ญูิAสKi[สญซผ[๏}ฃฎ์c่;Ÿ˜Rƒต*฿~ …yySrฉ4€ิุ’‰‚œžuv;J*รžผ*if@s\bหRPฒสUUฦลฮMญox˜ผl…Šาร’๔ฦฦ:7…ส`ฑ˜*ƒR฿ุrาr(๚ยAฉP๖K‡Ž{C}ah๘“q…ฃWj}ซ!TJ5ทžJgฑz*ฃžBa๗“9p๔๚’ถ>้Žำฌ9‡3ว,š, ผ“7ธh&์ว|บีฦ๖ุj'!€€ผฦฒ€ฒš,‰ฃ”พ@I z๙1ง‡ว๊ศู^๔๗๗๗{์๋้:[ต๕Ž`ไ8MH๔ผ๕“R@@ ฉพฎตืE?ธZqว-ŒŒVฒฝ+ ฏซ˜“š>Mฎ_Z?๑ฃฬ#<๑ กถพ๏\ž…onวwหQQ`ร"๗#–ฅง7ฐ Pุเตt๛ำr„ฌค(\]ำน฿™Lฆใ”ผ๙์ตC/็)r฿u–tพG=ไ๗ืไฮิ•–าT๕๕ษNl”ถœ™!”<๘๗Hฝฯำ‡ž7ดร#„ …!Wว5 8ฒบŽ2%๕kK!#ฒฌ2N๖พžะ}sIาภ’ดสuทSŒศ๚)šxเาh-}ะืใีŒgฎ„—ๆ…ฒq7Mv>ฐ-ธธตรฅฟy‘\f.ว/ำฦ๏›,;Pe7(P03%ผ LioKO'บo…รั…ี6cpภkโธY9๖ะา9Vk.V˜น,Ž`4ฤŠOžT^>w๓ศ+ึ8^ำ54’-™9ื๑&uฮฮลjIN[1ซ๚ฒีœ™ทฒ‹oฏืฟๅวE~ช9ืฝ Vl{/ตชล;[Gœaฑส๚๚ผzz<แaษ 6}อ"ๆฃ ๆู:_Iืีเเ5[ณY5ูcลูถnŸไืฏšศร)๏ผฆkถจ%Y6kๆ’Oฒ[k]—yถ๛HcqPXFvงน'™มถgcห€,%"\฿ภ้Yื_ทใฏค์๋ๅw๙ ŽKCMŒ’SZ ภ/ศวชฎง)g;LฆบฎL€W*ฃv_ฃฺ๎_๗๔ุบ :Y[o~my๚W%eำ4ไE%ไG”e๙cปฏฉyo#’ฒ;^Uพ฿qณq๙ฟ‡^:|uDา฿ธฎฮฎ–0ฝr๘Pภก๏m\4Wšะ…b๙‰๑™ฅ—‚l ้ต๋ิCก-RjŒฟN#@J\2•D•๒0ฯd (AQ.‹ี นšญ ็มลส qมgG${ฯ๗ล†[vบ๓ญณยnะิ5๓h7k`n—W#<Gžoฆ่ึŠ…^ฉด•n-,2๏m’ี?้๕“x๚„‚็6-๏ุ–็›ƒห฿ฆ๏eS๊ตm{xบ„จ7$tงฬ˜j2iฌbีใ}O๒8h!Bาฺผnี>ฎแGn4ุ๐ฌญ=๊;Q“{3โๆฉ$ท]wž3๊ส^% ้&ฎ]ง๊ถๆ})Aaึฆm‹ำVy%ัx-?คOหzuิ๙d<@p๒สูดk‚j`Vทษ*๗ )จHšMS(“RฉN:“]฿๒%h!% ๅbRชีIgฒ)อูEญa‰˜”JMาน*จo#ำv›ษ@.ว–ำ;๊f&M.&lฝพx3, ็C\๓r !€Rieๅฒpฏคš&จ {KดU‚8fbไjใจฦฬศศJ๊ฤFผ @ZYนำฅ (มoฟlทV%Cj [GตEEyƒ‚ม’ีีฅภฏeูJŽ฿ๅg้๕_c’i๚B์qJิ‡}LZฅง{ยฃฏ/๑0 ว+,ฬ‹eG@เ๙u F˜๋ซ•ข<พห้YืOทใ๏…8อiํึก๔ฬ0ญพ๙t"ว`0q‚โฺส~zU3G>ตuึ"!7฿Ub'Lูa^ผโQ! Yค1ๆzฤ๚ค`๊8น฿—ภซณูJ2๘๒‰7U8%ใ๙ป&็-}šอ~"๗ฅ[0Dนัึ‡็†yผ๋๓*ฉฮ๑ƒฝฝIห‹‚ตSR ๏๊๒.ๆ—ธ๐x9Gn™าGข&8  .๓ƒ7ฃ๊๊๊?™!v๔ๆุตๆฺาขึtE๗พZซ(Tฺ๊หฟํRะ>วํ=Jฉ`ตt%QถO๔ํ Oถ0บอธhณ๔f>B3v>ยf‹อ'b฿๏๛ฏจŸ]‚ี3๗แBzVร€šˆ{นื5Uเูง–ฯ:ฃพำน&_๛u1+?เเฒ@w.ฃฑ‰าZ‹ี!ทมไฑู~๛b๓˜ล๗฿/ผhฆๅ•๔ ฯู๔%ŽWฺl๋^d๓ฟA ฺK—สพฺทงจรC ‹Tต>€ษbถt*`ฑx&ฃตwม cฑxภbqํยvฐXผฐั1]:` 9ฤ)ฉA2ฬlR]เ†"ฦทBf  เpธv!Nวแ9ถq8œคๅพ+[€ลษํภฮŽXE Yช›.฿X^O)‹;}๊Kปผพ3Y-{•x6T……ๅ,ัืD> ๋ซDพi้.~zาKzลบ3ึโŒ‚ุwท=ฝๆา‡รั้ญฟ6 ™แr๔c; ปฬ{ืo;6’h5ตี์ผ\๒›vฬ]w๗3ฯ๘โŠ.œ๔วํ๘›iz๑ŸปŽ$3j๊eฐ+…ึLวb0 ‘OfDpkใ่ ทๆฐq…q{ำ*™Eฉ‹wij=*ค”Eค6ก<ิˆ๗ปณาธ5GŽ/ wI/eล,uฉ4๛3[UzCIe๋4ะขเ่ด‰RŠ?twดf-ำ้๔ป›mฏ็u+^9รฑชิธัET่]{ฅo๐(7Qoˆ ๘\@˜โบYไ๎VŸ4`ฑAF"แdzvˆ๚ๅE6—ู,ล!สีy๙๐อ@็/ษ่zฝ5ฐhฅa‘ฦฉฏฝ๊๊พ๗kTูง๚ู%๊บ:u‘๗ฆีณ+O~ใ‡-ณŽฎ?U?็ฒmิn›ไ๙็Žพ๐wฯB5Œๆอ*o๚ึ็?F[jrMm เฬˆŽ-†๏๏Qฟ๑ญ&Cึ/›ร$ nj@ˆ~W ‚‚‚555ฝโ๐xƒัZJ “@ ๐*7ไIxWมขื็}Rฝ~”:U่๋‹JŠŸ๖ทj๕;~lา[dฉัา@Fdgmr2!#ˆงื–—ื2[บ ฒฒฤF›j q2ำ\ฏ์6ๅ็”๗โยB ฝฑ*BBrใ์๐t๗`๏}เใๅขUื๕dXบnว_ CBcใ?ฺ xฉแฒ eี…ฌด๔P้แ ”yธนฦ›h`cพfิ”U+ซMฦ!ขาHeฅย๒์v#้!๋=ฟds๖๒gRSXTฅ4ยTม”๕ตTŠŠฺ&IˆccทcแสอบญE คo0r$™€ว๓ 3ิVสษํ๛๎ญต;๊Oถใ๘Clcแ็›‡2š9 ชsS‹๊Dพๆ๗y๖8๛{Loูษ๓hˆ9ิ?฿<๕๐'จฮNสฏjHอk-yjฐ๗qƒญฏ>!6•$นzาํ๘มw”<ฺDb‹๓ๅลโุŠdCŸWB‡]kn‡ฌ‚ิณVห}‹@yีํUฌfJe^์๓งโ๚/ท3P๕งกก’“ั~!‡๒llYๆ”๗๎Qแ‘SO-+Žg?งฆ“O๙bcl๚ฮooaำ"๖ดIQxภ4๒Gแึa!? 7จณ:*ณฎg#ฬ‹`3 2พวB6 ยe๎b.h?ภกsM†ข‡Oห9๏ฟๅ ศ,K๐฿w$ฐm&w็{ิ ภš\ไไYต-.7fqS‹๗ป‡6๔J˜่s๘ลวำwทp3jr"ฝO=+€เซžcทป๙ร‡4Vๅ~๑๑xุป5|>qWuฉห^fqfุŸtิ}๖|ฃๅถฮีบ่K`โ์)mš๗ๅ]VํYษ‹mจHนแ[๔k7๙k 63H <ําบ€s'‡nqฝf-ภ(Mxq่h ว๖n}ภน3Cท๖]JฦR‹"oปg6spT่=๗?[`4ล๚ฺใ›ิ‰ฏษI)จ๊๔คอ ใท™_z๖t[[บ*5kป๚ฝดฎ6#ิ๋ไหส–lžP฿ดี๛กŽ’๗๙š‡%งผWฝพ|วศลใฦ์{๛n‡อXUูภึ{_Qp>i5ฃe บ5ฬกู้้S—แc:ฆ]'ลuๅSv‡ี๔รํ๘{izn„ล#๙VY’{ร'*šาN_s^h{ŸฬศOŒุ๓ฒ„™แCฆ:mYฝฤฌ)ฮ๖๒-๘.เ๚sฃ/๕‡WZถิ'ฆ๕ฉ็Žƒษ{รฌ7lts!1ช‹SฯุvxN}VNy55ฅฌuฌฑ1๎ฅปฦ?;ถ๏มำJsc๘~์ฆ้[œoooา%”฿†บบ::ฑ eภ๖I๋laqุฯ๏ทคๅo„ืิํบแ…n๏zน‡X?8ยป>š9ง?ผโSG๘ฯฯ?฿›(?M฿oJOœ0ร|\c„{`z#aูจiำŒ›:} \*&[FƒŸ๛ฝฏaซูอๅ~ค๏‚”ม ฟฑฉๆง€ฐoณqิœ–ผไฺ;ทo฿๖ฝuใ qฉ๏ซด>ฺD๙i๚|;Pzท๚๐‘ำ4ฤˆ์…*Z?~ D1iฃดTธ9ivs๙Ÿ :€๒ื€Ž?  ะ๑”ฟ ,™ฬหข”ิ61ู้ ‘OœS_SSว`ซูอๅ~คn ส_ฃฎฆ๒‡ๅ์฿„์>fS]vl5ปนฯฟ„‚‚‚‚‚‚‚‚‚‚าSะ๘ฅง ๑ สw`ฤ๕็ฏX8V‡ยด†     Ÿำo๑ย7l…W@€‹แ7 Y{ูัO_๙?ผผwž*7 า|Ÿ๙=พฒa นฟข ด#้๐คฐฐะ฿I@kGXaa๙้^Eœ{ฅฐฐ๐Xห[ฑฎ'u?0_a@ำŠ๒sL?_๘=ัnฃ8้Š|ํMtJVFRไซ‹๋ …ฺไไฑ?~tัไ์g”[t'G…N2-f;ีณ“ู- 9ฉ_ฏฌอ฿Oyํˆฌ๕™งฯ๏o 2ำใ๙wlหA€[}Ž๋7๎=ผw๓>ปQ"-Bพกswœบz็มฝ๋็]ฌ#„prิ-ฑrR’ษฃค~ aจษL๏ƒk~ใฎ๕ึ*๕๔nไพ:ฑฏˆ”ฆ;/ิฉ ๖ผ๐พ Jร[ปb[CJ๙ื,sฑqิ!ภุใW๏F6]6‹ซดฌ๕]ๅ+ทฅกญ็็ตW›‘žษA$งฏถฦฝhใ_BTท=ธgIผ๕๑HฆฦB็Yฌ๋.หƒ‹q๒–w88 od{๙ˆˆฮzs์ณcžฯห๑C-ญฮศ›y#๋าไ๏„mต้ๆ๑ “ฤCฎฤv๗ี๋;แ่—%พ"ฺNSฐ~ว/๚Uเ5ฆฯu›–?ฯ'ญษ=BDsฃตžพ4นชƒPhฤฆYผžWv•a”อ็์›ช๚๎bฐˆฒบ๒๐9ฃฅ&…cu{ใFัวๅยsปU#จฌฑSฬบz๓@ภjn๓ย%J๚|nzฟฤU้a/ฮ๚งธSi๊Ž7ฮ|23ชœ่๛z๙Acฅณ/€…ลโฐX 0™€ทึmIณงำู˜ฆH 0Y:&ษฯL4Xm_แ1k๎ฑฏ*ะ\๓ฬyฯฃ๔f@dฬ๗฿5OWJO•YํiืpH๕˜4ฑต Hะ\r๒๘UAVEjฐ็ฮMั๕ฟ`ข๒ๆ…:UŸ๏ž?Ÿภฉ†ิ%ฝบใ›๘Y๔kM5Y€_?G,^,๛ฮ๋นF9`Rkส[๖ึGไฬTผ้^ฤA ๓ค *จ‰‘),›!‚tมคgor๋YiaeณG(Ax๛หูกdrŸ๚รยซๆ*‰ิgzz๙๙—ฒx ๆ<4ส^ไ]’cฏ:]ƒ(ๆvB7ฯ€‚KตDŽˆhOูป@Mค>๛’๗๓gELDRวd๋L5u>fIzฬฉa1๕฿;jศน|๑๙ำ"& •aฯ JšะŸTฤœ.(Ylฮpบ๊ๆ๊*‡2๖ฃ„j"/ํ?Xภโ™๔ฏE๔๒-O+@ฮฦsืi[/สฯณ ฅŽ>ท€ฌkk๏ติแฑ๋]Œ…kขฎ:๒2‡€‘ปjฝ8U2ฃ4ั๏‰[q5ืล\?xุ/‡มถฺTtเ!' พ;๘ญัา๏ฃ67)๒ข™/๘๚T€์าลšั๎nฆา๑1+ึ-ฏยO/{|๖ิรไzNŽ๘ตm]9EA€›ุP\ษนณ๒` ›qpิmโ?_ไu~Ÿ[b์ฉไW๐ฆด™อ ษEL AAศๆPศ”อAC}ู็O๎ว—้ญPRl“dT2ท5ฑ’ž๛ฬc `ภื<Šถšd’tๅjพ–ฮT *สFEฑคี7ฝIถsPVzT’Wฃ2‰’๔๒cๅ;YTŒU^Fn{ะušlYi™จจ(พน?r฿-G๑G ‹X–ž€(LRRฺำู3L†งคด|=ˆฆ^q™ฮ๗มีv…g–๚าS็W(๐L}ฦ~,Wฬ…}วŸm;๏ฑ๒‰-[ถ\Œ๘nDL|ัมƒณโฝ๚ืhLw;ผLg…ฤI๋ึhใK๎œพ[ยA#๗ฺCCำก€—œ4V€YSSู็gฺ^J๘ูsซุึ@๐$> -5 `~๚‹‡ฎ™9หRฎJ๚1Yx9–๘—?Q9j}ผ๙,กม๑ซPขคgิิ••5)๋่๒#8Q2d2น;G‘ะ4ร~Zทใๆ/ยŽSไ1”„Œ8y}.1 yพ„๔Dd๙]1qบrฅ แ '“ึเ@lุ\‰๔}‡ฎ๙*๊hก„.5 ลโฎ]žฝรวซZำušt๋œ*I- Rไฦž[ฟฎ2Wย@ูืซ๏๓,—†ช%ทไo๋Q์12&“ฐwท,ฒู*ใ0_@๙)QYW‡@TG—/"<™9ทVMŸพ๊fVลำmำงOŸ>ฝ-xฉษณdยŽฌu:ฏเฐภ<VฌSLp_ตภfำ•ŠI k-dYณ)\ถ/ถq ‘ดท…๖ีฆkไ'Mฤฟ Jkoi๗ิ;FMดไฌwดาาYธ;ว฿ฐ ๕ฅx&ฎจž|ฬaขพิ™[ญU8:’˜j7ฃๆ๚ชล ๆ;อ)นฟๅ` …CŽุ:โ˜xำมืฌ๑ˆUt๘Gห๛ึSสำฏดิduฑ†ผRŽ…Oูgๅ}œ็ใ!1pขs—-นux๕๕ f“ฤZ›ฟีษ9อjr"โrZๅูq?1eแ๗"ap๖˜ำ“#+ฏo6Ÿ)ƒ็คล/ศี๕4ฅั{m†ษTี—‘๙z6ๅฐkl4‘Hคำ้x1Uฒอ๔f‘Pๆเrซ…;ฅll๘๎l~+‰าฝ!”^Q’?~๋†Q_B>ถฤŠ:บP๕แมoฏ>‹œฆ>ศ ีไ†ชื็^๑vฟืz)%๙ีญ[ทe|ืS๕d๓ฬนK6z\นxโI*€ฌ์ |m๐M_Jำิีฦ๐้๊‰G„'vUศลoฎŽศ-/Šo)E…Šศ๗)54jiDH" I ัKŠj[~eqš=6‚P๙๐๐nฏซฯ“k9ดฅุอžt^poใ฿"๙น฿เdู˜“_ู<ศŒ๚ฐ(˜„แ‹ษ9P ุ๙3์ˆQบaืJปำคผฺ=5ŽWjาzืmˆ๓เjVม[๗UAงIต‰{ฺA+อnฑีŸ…ลเ๊ยโซk Ay๔eฒSปœศอdถ~5™,‚`‡ลท L:ำึ์้เจE ษ๏ฌวK,Ifิ”ฝvศฆ‹)gAXm™g2Y8 <โSกตฮPไณ€ฎRTPl—ีูๆ์ IDAT8ฃญ<Lƒ฿.คำ8GG-šlช gWศะ‰ใ๋nห๛)๏?‚รแลงํ๖4ฆŽD-Imื์์ˆY’”ฃ์t{ICCyนsฑmr๖9๚ฉฤท–ัไ๏y๒–(=r๒๎%ศถหฉ์krdsะรbฑ˜ฉ ฯ๒ฉ  Fงไm—T„ @Ydš „†๎๘ฑY๙ฃ Sห*ZYŠ฿%$&PฬN‘ึฬภb‘†จงณขธGเ่๔Xw<`ฟถฌ '"ย@Qัาา2เ7qุ2๋่๚S๕s.FํถIžp๎่หQƒถ{ฅฟ้บU'9„๘K6ว5ๅ›Xึ P๕tซูแฯ-jดšrPb2ก%ˆ|—ขลvEรƒœg,เYrใ๙Z้๎“2ะ z††จ ˜๐Mฦ5้hศตล’๔คcฆ'’`ไB๛8j?y8n๓Iฎ ‚a4ำhดf@0ืpส€ษ~็{/ข˜Hhกห] บ&45 l<8gงM„ข|&LpะๅศiํึKy4ฆ,\ธp‚@`ธลย… ไ ‡ขภY•ัS๕ศ๕M|ฃ—ฎ™ภiๅื จฏ/ฑ{U\KG @ชญr฿…„„่ย#—ฌnลfฌ€ผูสีซWOSรตญVฏถ/ำ ว์jHห'|šๆ 9;NfvNw๊~ไ๋ีeำ[ฑ๑Œงพq›ฆQW์ฐƒญ&CfโšำTy1€$ ดๅ ‹€ค5cํสYรศ’ธมฬ ยqq™]:bท ผม๒hK7ๆ–ดnQPœฦ”_<^:5.ซรบท๚’*ขึ0)Q^^QŽSษKหณ„&ศq|:2๔ย2NซuC7ฬกฮ‚—า’“/ฏ*ไ ๙ืร;DN„€เ„๔ ‡Qำำ[{ฆ๓"":ึ3ดพ~Š๊PศฅฅผCGjŠ…ค$9ravถจžฑ*?(ข?V‹‘]ษA‘}ตแ^oโ˜ฌท๏9๋ตw(ศฮึา“"ไฆorงŽ็เ# ฐX,ำ}Œฺ๓ฤs‹I เœะH#-ZFฦn1ล5œๆŒPใFม&+WVอฉ&๗C6 eๆ}Uf)E"๘tี%3 ฺ'š22ยถ_Šอ๙ฉ๛j่1Cup8<ฦXU…œขถ%ัBsl-7-ž๋คื6‚˜–๑Qj๘|en.c lLzLฒํŸ๑g้ผp4ฤ๊Ÿožz๘ำปn*.[ฎ=iฮ๗ูu5• ะิุ2#=๏ฃย#งžZV;?@ก;ส+$"ฑๅก5~h cปทn๗ลYฤฦข„—'ŸD6ํ๑๑ๆ*k™ช=[vQl๊‰)B6บท๎ฎ#nถล ^ฌพโwr ฺฦ็Žล;ฯโัฎห[,๕„ฯพ๋๊็e`!ŒกP‘’าqั‚P่Je ๊‡ภ/-#ณ€ค‰ำฎถพb๏จกBs\wอli? Ž]ฑklญoส•๗g&t า fบษค™RY๎ปล๕V7ญฟœชŠB~vVืรปิะฃ7ป^™ร‡Pซ๓c๎œ~š %ฯฮzฉฌๆ=‹Z’pไTXฏ;6นdWnYํBj.L‹v๓i_๊Pฯm=พฬzวว~๓๛็๏–ฮผ6GI{็t.Ž}แ5$ฝ=d๋ฒๅ ๘˜ฅqoไqšู฿๘%ิsธนพ‘ญช8ืว'๚ฏk๔^ํe>ธจ…ฑOŸNj+๔ˆมyำ3O๏ธz”โsiฬV/K<%๎าๆ=์ท™ฉ{{๑ฌ๚๚ํญศŒาdcวใ82๛jราจI#ำ^่v…uฝC‹ž๊๋ฎู๐cKพ?•ีฬมQQภญผ“žฃฑ8ฎ๛{ฝnd“๘wพ1K์O๛์ ัŠโŸ>ีๅ"“>ะ๛๑ขึ”={๔๘ๆช’ทฟp*ไพgsะ!ฟะฌ)-งุo0…ฆWฮŸJ‰=๑Xhฝา%ผฬ๒์d๗;ฉตCพซข/jl่้กf›w8 ใ›KsาN๘ฤต$6f็Tื๐7ฅ•ต=›าป&บอzษ2ฃ ้๓^พo ‰๔ํ {{o๏7`ePWWG'ก ุ>i-,๛๙–๔๔7J&๗ฉ[฿พ™R X,Ž…ื6ูซ›ฑฮ; iัW†ฎบนบbk๛fJ-เp8Aิp•๋ธˆญCŒBๆ™่๊=๚ฝก?ปู๋ฯ;ย๎km๛oผฌ๕ั|Kผ๛b๓ค๏ูD้ |ใ,วROฟฎาadิ”x๚u^ใ€X:HŸ/จAAAAAxธ๕f<=พา}|ใฅ{h๐0Pp๏ผ{ฺมตื<เ€ฯhาะฯo? |๛›ฃๆิ๗ไ…^7ฏ_ปvํ๊๏ฝcห๏พ๙ฺG› }ฮ&JเRก9YCˆ$ๅแ-/H๘ท€Ž? 5 ใ(ƒƒม>€‚‚‚2ุภ๒ ๐๐2ฉ%ตt2//‹ZRKc ˆ๐ฅำิ@n<†‚‚‚‚‚‚‚‚‚๒—รจฏฎm9Cจพฆถ~… ่%”ž‚ฦ(((((((((((=PPPPPPPPPPPz บe0กฝ๙้้™€`0,&เ๋…ห} /cบ~ปรD5AFI์ณำG.F”#า๛ญึแ*}dรษฐn7&GA๙#เRต\ปrฦ0 ญ4๕อ๓7ฃZQCxTญ]vO+8ฑ๘์w็^#าszXK๎(^ˆˆ._ปะPAˆฤl(I}}๙ไx {aWŽุฅUVw<]m%๏“๙/-‡0HŒ็aFนp๔e๐Omฤึ&Šเิ}ว๎ญ<ว่^ท๗6UlฯํทSpgรฆ๗ไทุwิช๊โฺใ!-ที—{/ฏp๚˜ำแ8าษฅb้ดสr„$ฑ!ฮฯsฺู์%lm๖–O'ย'c}าnZ๖ล๛Rฟ“+L8๊c*๙๒F‹PฐraฆรOฯ๚๔เใ—ฉM์#b<สฬŽ'บฆ2Taย งแฬV%โัย{yl5หg,wปwW@$ˆฺำ}mxnธ๓จปฃ(xๅฦ์rQเใy:น+5~Eƒตณ‡ %3‹Sฃฯอ์‡บ„ฦ(ƒ‰Kcพ้้ฆRวฅ7[Oว•˜๋ฒqHะฦ…[๒ˆCํŽ๎[—๚ฯ๎Œ๑sไnœ™8™ฅมaฏ้@โ็gึึา~o๊QPบD~.ภู! ”คบp๗Ž‰K๛ย”˜ดfตๅBfjู๚ไ‰Kfp••w)”5ต6,ฟตษ-ฌ#nแ|rฮฟ๘ภzถย.ฑ7jข!฿Ÿej"ฎงช,๑ใูšๆ„Ÿ[”ฝอ{ฤฦ‹…Œ๏วเแ;›_ฏ9ฮฟ๊หฝWtV*tหณข)ฑง ่N้$Žœฝˆ๏รฦ/สกn๖าf'ุ์%œNแIปf[เ2ใ์ทโ™ธn,WQป?rใ|ฬป๖’ ง๏>81ีส?“๙รE็T~zjzข:Qmโัฑฅ™-oŠรื‹ศ๏N“€E”ั‘ƒศ,ฬ05ik€„‡ฎตาีม—ฆTwง‰WZพH>ื๗๖‰ผ๎ฬY[M‹_”๖yฃ'4~@์†๋๓sJซกD? ,พจซ้ภยbqX,˜LภŠ[๋ถคูำ้l ฺ&A๙ƒA ข|S61 )๙หWฆตค|ฉฌอŽ บ8"G{ว(๙๏ด‰Z๓็Kธโ/๋$ำ…ฐกถฎ™ฟกฑ™ลB้ uuอœ„uFxœ•๗ อล>ๆ๙ก+OG—สฟโ8\Š>:&”ีถ๊r[ฌZข% ู`‚ฑHSฤฃ''พิ bรฦ9MSUโa–ฆว\ธาศม& โZใืNSQๆa•eลy‰ˆง๐ uฌ•|๎ฮƒRŒโ”ฎBื๚fQ๚^๘,’ฦฦ<“Y฿hฎธผคx๛๖งeภฅ:}ํสYร%‰”ผ˜€ป7ŸD•4L๛Ÿา‡่f๖F’๕‘๗Ÿ๚Pฮ&[ิ—{๏›J€lŸตŸ2kฟ}€^ฝuๅXแš่๋วNผ-่`กƒMแi=—ชŒOGR๚šฮCษบ~#9gดอ(•๏> Ž4ฏwๅž˜“b‹@ั`BIภ๔ฬ* @@ศ‡ G)๛gฆฑ7ส7|;927/ฑกค “๗`{์r๏ๅUgžI/Yช/\ห๘๋<†š›J.ำFอx{.Hz‘ตzฬฉํwพ๖k่๙‹a65–ทn#ยึใ$ข‹zฃษžGัV‚,’Ž\u:๛ƒูT(ๅQŸC%–๋,ST่ZSYitIยฒtJ@ศ๛ิ…Kๅ_”f๕ี=บeฐC&“›๊๋Zqฏซฏ€ย7ทใG๎ปๅ((ฐa‘๛หาำะเๅOง๘ำ—IŽOe˜BCfV 4d†ฟ‹.๘กG‘šฑdtšฯZืยฒ๎Qฌฮ_ฟ|ๅฦ‘ัั๛ฯjโ$ไเ่G*>›ฝํขg:+ไฦ™ูฮฬ>] ู๏ํถ™}.๎‡ž2ผฆ2™็e‡๛zิ$€Kอ‰”[ื๏ฝs6b“‰8G›\jหญD|o.ูw็z๚ฆษCจKบฤšeฉ!$8~T๕ีgƒ:x5‡๐!ฝ‹พD3ปนฬ—{Vฏ;Ytธ*wM-โ๓=ซฮ็้ฬ'ู+›)—์ญฌฌv๙w๎C2ม\ฃ๛ฆองไ—ฮัมrฐY๑bง•ีฒ‹๑ฬVVVVVŸ–ua๓วt๒/sRI=ๅdปฬ๙>uฺ๚yสm๒Œ[บZ>้๔๚e๖;|*วo˜?€๊ ซX–vEง.3)ผq-’า?้์ิฬท_ขณ8’#:cญfฺู7฿พ›d~aVme“รs'สีT”๒ ‹rฒ)nถุผฦwฝ2อ๓Jปธต|Oe&™žํถwp “ฐง‡ภจˆ”y]‹QX8๗เฟ ึh]ฉŸหฦ^Mฯ0ฑน๕ฝ๘ศใVgaํ i|šี)94U9qYญ๒œธฟk|‡Z๚1*;ฟว๒‘yY5๕4๙‘็kHีิ—“y…๚ม=?  v้,(~spนียR66|wถmฟ•4ธ(ƒ—{w}/ฌzrเz2็~C๒๘%ดว7C๋บ’ว.ณ—๐ุแ์์rฉะxอ\U'แ@ัœ’Ocี็ฆ7DDjณ?ไัX สว˜|~i1~N—Šˆ*ิdศiคั๊>ว†ˆ @aHp  ก›ฝ=08๘oSฝ—จŒG ๎r%‚Ap<‚H]ฟ๓W>ดท{i‰ม๏ จ,JzrFt8๘ถ69Q|๛IlQUItD2KB‚/6Lงคผ|ethz‹Qฯฏจศฑ†HสหWD‡คีาšส"ร ๒๒ฌขWŠ.ืี’~ฟCy๔5}l>ี‚|3 C|Nฤ่Lžฌ '/ลฯ 7ใDNWื•”4  €ม๐ฉ(ทว‚๙o|_gQ˜M™ iอbbฬิ˜๘&*•šSEฅR๑8<'ฃ„ัสE‰ู-๏๒ย7ผแไqkษว^‚หๆi‰sา@ชrขIฒฆฺฒ๕ฉน๘Iใ? e0˜xัa Bผt&‡ใX—z: eฐรbฑ: +nไไfG~tแนžรน๛๋KwxEีฑ5€‚๒็@ysภ๊-Žgˆฑใึ ศžcกl;A รฌ็Kฝ;qฌ@ k!—ฮ๘QนoN$0JŸ…อ๑ฏq3-0~ sV๛๏€ลเ„†ปlUฅ฿TYLเt ƒc2[{ ™L๚ƒฦ(๖๛T7kJออฯƒ+จี๏*่Rฉ์•ื I๛CณE่EIaฏ) ฏเทฯฅ—69ม`0ฺ_เpํใ}ฒูN{:q8ผุิํงŒ€%6•~ๅุฦแ๐’DวแฺjHฺห€rK๋โ[oฟ[ิ?้์=DE๋ข๏\o}๗คั›ฑ %ฮ,€k2ŽNใธ@Uš’ฃธ๒ฤู ”Š$๏‹ํ฿ี๖?‹‰ม œ.`คGชU…ฟh๛พำฉๅ•ญฑ@้‡ิฬ๑ขฒ%l5สขำ๗Œoผ๋ัˆ๓+๋hnf`ฐ˜†?›.-‹=ั๘eฐS[[Cไแม0€—‡ทฆฆ๘wถฬ:บTœหถQปm’็?œ;๚rTฝ[k((ฟ ๙1#นS%Uฑ่”‚ศ„dง)3b„ˆธ่฿ญ๏‡Sบทแ,žpOžลdถ62˜L&€ภแูL&ฃ<ฦํxdaO4L๋ :ƒeถต๑RณวเาJdg‘?ฝซ้๓2ม?ฌึ๘1%ม[ฟอูfฑ˜˜oา6ฝ 1๓๕๙ฝฏฯใxฅ†อpผส4q—?็Uข?ุษคaqtz๓ดŸlถร`ะ‹^ุำL๗๏4ห‹ลา้ญ5„ 9s !-ฤL ‰ˆ'ลm5คฟำูc•Gˆ ‰^๖Tธง๑vรขยJ,Ÿ๘…Dk+8%Lุdฉvคณ‘ฦ_”?ญฦผ็mม ˜ไี1{ƒZ ŒลBแ  @J\j†PCD2vฐฤXJcฅi๑1yลt€บZ –Ÿ‡ ศO๔ืํฯ"/ภ๓ล็‰3 &3ke๋ฒxˆ ถ.;โฦ…7]l๖ศฦฆช…-ซ-Oณ†lŸต[ท๏Apๆขึ‰๒>]`{์าfญ$๑ๅ๑sญ๛7ฑฑษถ6ูjR_นค๊่๊iอฅ–ฤ>>Ÿรฑ†ิฟฟโฅ๊ธ้ฬl~fyJภฉXˆธ…ร”’;›jาฎ™lYฌ๓้ฟ/‘N๖h๏tuฑ$€อฝiะ๐๔šํมฏ์iaว๏ษปฮtฮGฯK{ผใวอ[K‚๎>yk>0K>๖ˆรNMƒŒชฌh~ay๛j|ธง๚$งอ+„๐๔๒ผฏ็๎ฤ—sะhYู๖๒ืคท฿[ใfiฺR—์ึNZเฅ gS !/ฏฆ––ัžQZ๚E_‘us^โgฅD ์๛ๆญ€Hค๖7๖๖&oฺ฿ŠL™ดภด)hOhกัฤEfด =ก จa ๊๊๊)))P๋{ QHVZ^–]H%หศ2สฒ kจv#์‚NOฺœ-,๛๙ `=F\๐o;32dตวว~8๎oฑ9-้่W&ลฎ8๘ถผฬ}ป๘ฎญธาๅib(ฝ‡oดนม(jŠWPีˆ)c h)^A๙ิฑt๚‘๊j฿0๕ s•คˆภซกึ๒ขย฿"ฝ`yEEธภq ตผ@…จฐ[! ส@ย7ฦXห๛ศ~m์-6‚ฟ%lhยguฦ๋ย… ž็9ฆโแปŒ฿จAIi˜ฦD5Z_ ๐oกซ๑?Ÿ?ซฎฐžฦห'ฬฯช+ฌodขBT๘„-ฎ๑K เX๔ฆff *D… ป@AAA๙ปภ๒yx˜ิฒ::7?/‹ZVGc ˆ๐ฅำTW๑ สล๏ŠPP๚4~@AAAA๙ป่ล%”Ž ๑ JOAใ”ž‚ž€2˜ะู๚b}ัสฅ7๓;ฝ9SN๙๖ห}ป?โดแ›žž›%ะถป๎๙ฦiGฃx†-pบ@Ošซฉ(๏แ๓Ki‹วV๋p•ฟ>ฒแdXทฃ|วๅษA#9iใ๎•“”ลธ™u O{9ชฎว—๓L;๖rป  ‹ษ€บ็[ฆฒ:ษฎรzW@-ดœ:2ƒษbา๊KR^Ÿw*ธd๒? <สs7o›\tnลลึฃpฃูอฅ(ˆฅฦฝธโEเR6_ag>TŒH+Op็า˜JเQตXถศl่nZYj๐ญหชูฎ๔Cค'Xํ•|5ฅฐKึOๆ~แ๋™Šžฏ2P˜บธษ>x9ฑ๋e๛?iSi‡๋d!@0Ew>ํ๘<3s;ป๊๚ึณaPต9mSu`ืsNี าูฅฃ$ K7Wีื;?TNeแม5>ฮฑ๐™฿“5ัXFŠ‹U[’๛๔ูปทEWr’–๛ถ๓ุเ3(Ž3็ดนXAฦ้@T3o3Zz‘^–“|ใษ็„:Pžb๓ฏ~ž๛กw1L ›rแž๛วพ่โ„”? œผมคใeคนYต%นŸrจ!rใ.ฌะไkkœPขž9<.่ป๗>[@AAi'๋’อตœŽฉน›–โŸ8X>)โถ๒ิั_ฬ๗็Ÿ#๗vใฬฤ๙ฯ, {M??ณถ–ฦฦŽWOŒ—ซฃคน>ช7RJ€ทฃVพk,'๒YปMๅ/Kp“•ฤศ฿ K`gชK uR ฎๅเฌตdE: rฯฅีqI |wด+ญ:ฟ ฤฐ Š]‹“My†ณ?VIมาaRฑ—อบทีXฉyGoฺNผ๕ดถง—S^l5~ร7=T๊๘}Z๓Hiใ—ฺขtฏ…Koๆใ 6\ุm๓>ุฝ็วชBฤํ—[hแณำ+:EL†ๆ^‚‘Ÿฝmห์QแวC๊ฤL—ฬฤํ]TFTžท}ใผGฏ8ฆส์5S™๗l /รส˜ญqZจณ๓\4ป†+?$4tค้ตŒ๓ฉ๔!cŒJรถ มร":ฦP๔๓ค~mZvฐ™แปูฮTmN/ํฌTu๏JUS2ๅ7ฆณkGฌ‚—ทยฦฏš7โณwl“ไ”ล†…ทw5มŸบอd๎ฯ—|ส0า†SvYจG_JkZถฟ•๊จ—๋[gื•ฦํ6(หY}'Cึฝซ>aUูัf๋ฬถ฿อAZKbr0สCpฌฟช?Oรv*wฤล›{J12FS๗Lำˆผ˜ภฑ†”~r*ชฐ?ฃ๑สเ‡[ำzืถE#eIuYแOฝ=}>ะ0’ฦ๋œอิ่ลัท๙ฦืAซpตูPQ(/ฅq7mณ@žเ|qซQรSืๅbz๙๓‡ไ|ผ๗*—สjlX"ท์:๑๊฿ำ๊๛ีˆŽ%‡]Ne|? พ๔์‚’={^–Ii๊สeำ†I(๙๑๏}Sฺ @6qL!ฬ‹>qษh๑†/ืŽy†UฐทษU›ำ.ฆdศฝท-2ปฎร'‚๚หื--Xs๛ินเข:ฺ$o:4)m็…นน๛7‰แ๙ฅ0ข#m์1Pไg”งพน~๑qrpH'Ÿๆ์U‹'ศ๐s๑หช1๙Oท๙ะศฮQs๒รปGฬฯ/gN}ผ7ผ๚หั@#ภอ•๖กจฉ +ฅ €, ภกuศ6๑lณษF(=๛๐Y’.ื&@๎ฝmœ‘ ˜ดฦสึ8กูcฤc฿–๐Iˆไฤ(mbd|ษ*7"Yt€ฌ‚M%Aศ!jษิd•wm๘C›;3ํ}aS3@fRAลh~1Ž5d @ื?  zฤgญ_ย|เ4w๚อ^q#5yx'opัLุ๛๙t๛ซ์ฑีh๎ิˆ?ฐะย|พ๓ƒฌG ศk ! (ซษ’ุปhGฮ๖ขฟฟฟ฿c_Oืูช$€๗๗c(ž%ญ ฿Žน๏–ฃ๘ฃภ†E๎G,KOo`< ฐMyr ๘ฎหzปฏ^๘ฝบ41lำแ๗ิ^]ฮ–ธใ–FFFŽ+ู~ŠะืUฬIMC๏ec๖็ุย๏[?ผ|| œŒ๙บƒg.œ?ฑgนก$ $๒a@j#‚ใS*ื•S @ฉจ )h ใCpย#†J๑๑๑ฑ๕๕๑R†mY1Š! ฅˆIชถณE’๏๙:zpซVm‰d){๘กJx?๏๋kVjซJ€ะะEcoŸผๆฐ๏๎ใาบงะเก+ควโร>fvฑiผ๐คล–ฬ€ƒถน?HึTjิ ๊šฤW‡ึoบœ?bฺ๑^ูLปฑฮึึ๖@`็Z‰qfbŸฮ์y!InัŒแXN6k>z‹ŒDL/บ}๋KpYดL.ๅย๖5๋๖ญปzŽZ[ ๙!ขๆ›ีw^ทfต๋ณฒn฿ต้;%พำํ'๕&๋]็’ฏฟm้*่'GN^ฤNŸไ–oฏธ@ตฎ+ํฯ6›์„๙œmmไVฝ>`kkkk๛—มฉŒ˜‚Kz‘BJuMJZ‹ภซHI๑pต<มjำ๓š•d„Deิ+๒~ม่X’๛i๛คึ"!$@้ฒ†ˆุ๊ต’๋’“+M&มwกุcะ๑”Aมเ๙„…y‘‚ฬ๐{‡ย[„2**ๅažษ&P‚ข\ซ @rตฌชJูวs 5อ9™Eๆๅ<ุปฃXน!.ธหก๚do๛๙พXภpหNw>ฐuVธรํ" h~6‹ฅฟ9ธ Ia๚ฮ]6ฅ^ถ‡—ฑŸ€ƒยฮๅษมI7+~p]๑ถฏ4oป‹mส๒s อ=ฟผW(9ZXdถ%ซ_L๊JŒ#7{‘T็l\ฟฤ(แศ๛๎๑[ฮ/ำjฮpัj*โž\๛บม้”ฃพ2ํCZ)ป ฅ„†R2ำ2i„฿๖ภ&'สB๏๛%Gฅ0็Š๓ดล็lฒŠ_฿žฐy ณ๚ษพฐ–ฉ€rrU1wา๋hP๗ๅsสสูฒdHญf›ฮ๚ฒฒFiA Ÿ’ขผ๛6†๘cโK?†ๆ,XŠ๘ฝ+hญŠใ่—€ใ:Bรh˜’Žxร›Iล]ฉxถูไ˜๗A ^_Wฑ$๚nKm`~บ’kพn๋rFc}๊—โ2ภท>มช๒โIบฦร ้ŸšFสta๎Oวงฉญa<\YWฌ!๐~วๅš;=b0€†่Oุ4shฬ๙XN+{๎ปำ{{{“–!!}_\‚๒‹aฑ:ฝe@ัฃcgeืl๖Z,Nฯy{ใฬนภœfภใqCๆนeJ‰Z˜Hว`ฐํ€จหเ?๖ฮ:,สฌ เ็„˜กป)•Q[Q1ภ\]ลต–ตป[ืNlEEฑ[E้๎Žaˆaz๏BะB0๐{ฯใx็sฮฝ๓ฦs๏อlอบ ชดจ>(พ่๚“4SC€"€šเ%}๎ๅ๕ฏุฒ๙sลS&^ฝฯfะoป๋0๛p _ษร]lqp ฃ _ิง$!Š๓ะพ™wืDๅˆŠฎ<Ÿ0ควแ๘ศ6go'ฆv!!ฉ๕๕?ฒw๊าฉ็บJEAœ๘๊ivjโŸผ-lฌฏโj_ํšB jธ๎ทูr ผ -;๊ๆ” Qฬๅหx๘0k้œTข๖ธพ””\า๐พฯ๎ 'ˆฤ๕ 8‘Xˆว๒ฉˆrดฮง๊”ีู‹ฆ๘p๙ๅYกง2:ฟิฟ ˆ™‹๛อๆ–ƒšหžฝชแ3}อpeQIrฤหWร ›๗šห๏ะNาh๒‹๑๘ฦ๙ :EO^0‡z—†4ฤM๐๘ฦ์B‘ˆ@๘ i๔eคๆฬบk<ง–™|๎\b‹ฮ“,ว WHK“2ย๔ล…4a'๚ศ่NŸ3ฐ3๙ั๛งืRฌ6u4:/ฑ˜ญ–WงmgZ๙ดแอŠVพผD$Š|ฒี 7อ†'XYL†ย2Nะ.ฑื๒๕ซั1฿ำถ<๙มป'—SZผB„ผ๒Š๚yqฦ›ดlW€N๏?`็OcดXXXด&R]]EกP๊>S(”ช๊*€ฺ” ญ‘ฆo๏ณbำ?#ฃ, …นื–Lh6ศ&‰p๘๚˜>ฎipŸœพ‹ซ76๔c‘๔P มซ–จ\[VฟŠ‚ศ™๖wฃฦ=ˆ.Cี9ฏ#+–8YB฿mฃฒv๘ํฏ{zzไšฉIoz;Ž|า9Cแฟ6’๊๓iP=,j#Ÿผ/เ‰$T$ฌCˆฤ"‰b๖Nๅ—พฑูอŒ Y?i ำ็ิิิ Ÿz"ฑ€ขื^6๕u ฒ‹ข’ชฆ๗0†๐(š‘‹ )14™tญบฆFชVœป[ฏœ7‹R^ไ:์ ฑXิxOแผX,-R@นงซMาY็%ํ'€ั ผ•kฏาฐ5ŸฦฤQTษธ† "n๖๓Sžชi9t๖3๚%o~*}ศ๙ _ žh’t’,† ftๆฉyฟ…บวoƒ๓xNสP(นOถŽZท`฿—ฑD_ย๋œ๊vษชโ['yถnฺ†พ$๓๎*฿.ธึ๊Ÿ!ฑ˜RหŽข(‚ด8ฅุ๕ะึถไไ?n\ืCUs5#$Dฒ@ŽBoˆCHOLหRเD3‘]ชศึ+฿ฮ ฐ…EศY‡“_"Pฑ๐;-n{H"ะลึ?`Jไ'&R]ูา‰dอž๖ล‰‰ีˆพ๗๒E#์๔”‚JฃJ €ผŒLU;']2ูศ{ีึษVD(ส/ะ์ีืLIษ ฿์ฉฮิOz๕ฝื๏XฝvROJ ฦYBชรฐก=Ueˆd%ซ‘Œ’ำD๚ƒ—๚ฑ”วNVงOOร‚จzท{ม๒‹I5€Cp"Ÿฯ‚“r;ฃฑXุ์EQT 7CQTฬ‰š‰QTฬ‰š‰QTฬ ›‰ฤ(*โ…อDb†Eฟ[ขฤ๚TŸ๕ฟั๘5›—ป{‘g•สฬ –MM2G5ไf’‘™ีR๖ฮ'ฃ้ึŒY\ิE: HMส6w๗ิ—#‘•ป{:ซฅฆไˆต\ฆO๑0ขโ‘Qทณา.))’…็ŒษCฬๅI2ชvƒ“’rค่D”{๎TsQง:)เ5~ิP3:”•็*่9๋ศ‰rvตDลๅาVž๐xBฤแ๐ธ_ญ=ำษzธ8ไฝyืค/Pฦ`จYู๋ำt|Fึ-t@ดฮ˜าืB“FีTTิˆ›vขณ]P”ีi„ `ำห‚Ÿ“[)U'^oฤ4ฤ๓>ภ ŸไZทCDq~พrG#y"Iษฆง…(/OšQ^Qˆวใ?ปDพ0„จž๎มผy-†รzu้~˜ฏ ญS }จa5๛+; ฅ˜Rหฮ*+ฃšูš+ษ+hชำ๑-้ํ2(๋ชำ ŸSDญA^ฎC dI$y{gลฌ‚ฦฏDู๏7_ŠสญTŠŒฐRโข8dยเูcGfSฟฮกZD๊nonM#ˆำ^ฦz๙ฅู`Wžปย๘ƒ๗๚ุ๛U^บฏ(*ŠผถๅR:@EraๆŸป็๋*ใซาC๏ธห€๊‡๛๗twฯอู xNแ๛ [3ภ|x’๛บCื&d^Ys1l๔ozYน)Eีชตi๙-‰rCN๎q\๖ฯู`2ฏ$้ลฎญทKเๅ‰C}Woป9‰ตฬศ€mืณ€S7 •๗๒Vแ๖wF1Ÿ์<"yƒK^ูญ$ ;Bœ”ด ฮ0 บ•OำฟLœœ๐eขฯ5I›ŽFHh_ว}ฏD p$ึ'+;1ฟRฉ6%ฏแ7Š ุxวฏฃท)ขส์๗Gv”Ÿฃํ4๎ฟpๅ๕บ๐1›๘ฒญซMfุ…ฆ๛W„\ฟo?oลฮA/N?๚่6 *ณr๑c&-™ ก€ฏษx๕์ซถจ” ำx๒พ5ƒ`9๏๚อy๗_ุqnด๏_{|8หe‡]ฅV2๗อห=็น}‘“tyรฎ—]k#"IเŒด•‹Jส?M๋ณโO฿W=~า ฒ€‘“|((ซ๎ ึฅ)ศ๖รฏุ7/}๏ส'๏8๙•ีrฌฒ๚า๓฿Ÿ6sŸ็oŠDay~ฦษ›‰ๅีตDFๆำŽ2ณfy`๑K?-ษษษ?ฺ ŒŽ"๑I๋?lุถ๛๗ˆ??xGŸำถE๒!(3B๎~ภน์ํืOลลoง}๘โC๏:qถซK่$๔Zpธoผ฿๎ mฏUหๅ.๛]H๙n†:I=FCฎ๗ ผ”3ฏXึžŽ=๙)g^pฟIโOหg/)lใgA”Ÿ>j่คcล"@ &ใal3/‘๋ํj๓๔Hง†สu ยŒ๗แร}w๔ŠPด63๘xึw4„๑ŠŒก•น{uษ…Wnๆ๎์’ ฏ ธ฿$ฑซ€อ?`tฐ๙Œ_lฃkฃะจT1ทฌF$[A€~“ฤŸlฃญˆkซชk ๑รทI์*`๛/at๚๔ัั.````````ฟƒ๕00000000000ฺ ึภภภภภภภภภภภh+Xฃห€PŒF๛8๐[ฦ’ฎ๛์๖:ดgหฟ3๛๊ฅKถ=QขNชษ น+ทํ;ธวบ?ฝ,้-o›ฎ0|ถฏnGJ๚ิำ›aฺ‰ Kง—จำtา๛-9อฒsฯ๚คำp–#GŽ9zlํ0ๆ2ช–๏3งwใA›&พ;WQ๋T7ฺแ'€ฦฐี'˜tขzEๅŸ,฿ชn๏ต+Ÿcึ˜€ื่๎ถยo๚ษี3๖ฯ่ฉ…-Wm/ˆfŸฑวV5{nPtzฎ๘็SŠั@฿ห๚ZใH<ฌ5Xแ8๚ีศ้9w๒eพซวZ้‘:Gฒอ`$F—@อu๚ดAVฤœ f“Dบ๋Dozิฎ•;‹pZ็/่ณ๋eฅDษถ'Jิi,•\LZ๗ฑณ|Œ่(3#ไ๒ฉ คjhอศXM[?ฐแl‚?;Fmy๔วท๗’หญ'๊7ค๕ด sS6–๒P€ด'sคr–#gM์ฃM“•#q,|แีG฿h๛๎๔ญ<๓XcvRะัใฏ ล=~;เฬธ*ฐN{}.Lsฌ—Iยฉ-wฒบ|๗K"Kwอ๘๐ช๎Zu ตฬุ่wS˜V>M็rŠ8–F Gถาฉส้Œc™ฟ๚๖Œคฅูต\€๗o3ผฦ่<-ห๋ d;hฟฤๅ ไๅe;ชC ๒๒ฒซฒrr>พ+โ4Oฬ ฺ๘_( กjkัkjjคIถ=Q’N6“ษื๏ึM (u7ื”—“—โfAศ๕ู›ƒJุฯฮœฝ้ไ์Oอb‚™แ้๙Kห๏VXปซ ๚๖ำง\Xr*บึถฯเบ๗ผŒ้ฤ*™๗n.uํhบาdOใฆ/%’^ฏษ†นgๅื€Œ‰๏(ตŒ k~ปo฿ๅwŸํฆ R IFb๖šิซa่เAf |m+ฏ?ษญ6%’ฎณ}h;9#eท0–จิwโ0๑‹]KWํฟฎdaิX$3 าณห ปrlZKญ๋Lฟผl๎น;_V}–ฎ๎_๕รั ๋O'๋Nj…Šฃฯo†™งV-Zฒๅ฿ใ๗แUoฎ=D='8+(๗๗้Sr#0ถVš$ลiย4ฬ๓—ฝ๚xœ๖คqฝš^ M, ^3w๎ฺ๙ฌg;็ฮ;wn]'JR1ณ‘SปežYณdู–๛ตฎS@ซ†Hฆc&Yฦ\M๊gแ2G็6Ÿฮ“ฃศˆ๐สร|&Z1c฿œ~ฎ*ารอUผT^ปl๑ข ๗‹สm;๚ฆ๎Žึrํ#๓d็ฒๅ{#ีฦท!เ •ส/^Kะ3pฬฐ๏ฎ!Uk—QฑoYz#คXะ˜ฤ+‹Œอ+๚โ€มชŒ|‘ŽขŠŽ3?Y๙ท?3r4*Z]+ะต[0สLฃš]!OQ์ฐd{h6šZไ์l]Zฺฅๆp0000บ ิพ}ปฅฅuชVขฒนcงž={hW…œ-๙F:ใ๏]สX0gว1ป"MzฏT˜—Vฤ(*ฮHhฮี—'ศO+๋cTื#QRาฉฮ ฬฉๅdฟ}ฒ๙ดาฏ6j˜Nย[‰u%e๊ผ›…|๘‘๑…3]UไQ-ษถุ]hM<)พv่a]r๖’ˆทฏํ<—๘ŠYฏƒ฿ตœำแuC'GA๘ก–D!P่t ย(Œ้ ~๊ป๐"@vzŸิ$"บ :ฅมฟ(ฑ $: ฅNƒx–šฎ.+๎V6ฮวˆไC๔ๅ!ปะ’gWร๚ฬ_์'fฎฎ"QRM[ง"๖F*‹โi๓ฆUืF??/&šzuํ.เr…P˜V<ีฐ.ฝCxฃ‘“ญ6&rค๛๙5•ี ‚ ิ„g๏,พI00tัpณธsษ’›f์2Gม!€ 89Cu-€ยืAฏ๒jrS2”iโŒ„dฏ;ท 1ก’ื‹G šA(ฒฮป ย‚ืย€ึDV~ูึตฉ6๓=฿พ+mO$เEb1žฆlฎGคŠ*Eฑร’ํกูฅ™แเ`์ู้CVถsVW``t.ณfyh00พ.W‘Q‘y*eป๙;ป;#์ูซ“Aq9•ยoฆ- ?ต๖]™(โ๑e๛-าeชฌ„ฝg€คฺ฿ซ›N$B(tHช๛#ˆฤ๕!)6"|xผ!พ้๐ญจบ@IJvq้๓5ƒ๛UŠ–๘ิY%๊(ˆ‰Sov๘ฮ–ปฃๅฏ.ช{O๒ข$*I๐0๐ๆ๛ขๆWI๙ณ}ฉSbqฎH$ฦใ๑@ เU๚-ะ[xฏ,ซพั!ส|ยไลธึ7%Q’@ภ‹D๕Uวอ้€Ÿล”ั๏?sJmผH„ศ*5FR ‘{พWpkeRรภตดu6(ŠŠ3“ŸqE๑๏า จ๋Crฌdัฒ๔ฝ)๋6ๆp*R/]J๚๔EฟbEpืkู!8x)งฟ^ ะ–ˆš๒๘,…ฟœ8๗Np‰๖฿ทND แp7แฉ_€Œ%^$tXฒ=4ป๐E"qDDZD„ฤ˜V ŒŸ R๎ฬภ%ร:๑์Rษ:ๅ ญIษoR+€&Oซ ”’ ŠขHซร์ŠถŽžซหฉEeL๕1ชK‹E8คพฑๅฉง†/พ บ_ีฯcŒyสษ~ฝdyใัญNน95ฅœ/Rฅe'hq d–้ ้E‹z[ีะ๛%j“N้เ-œ์แ›สPล54?7'$`Oจๆžำ็N้“ถ๓%ซํ:ฟา5<^$€H$*yv`รƒฯ+™h6ุ”Yิm๐ต่Gฅจ4I‘H๔ฉD2๒rงŠ#”๊'ฺ–fฒข๋8nะšี1ตbZ%[ [1ฤ‹8ตทสkž—ํ›ำัตะB‰:›mบๆA,–ถNAฑฯซ˜-‹รถ3จGHGIQฮ_๋๚๋ฯ2 \"๙ชGศHJฯฅsb+‡.ีวbWีโอ)2\ง*Tฑ+พ’U3่ฉ)HN(`[‘์ุญ]ŠUภbub็AชN’ู€ฉšสษ*6ฝ้))น-้จ-ฏ$›˜j(Q(Šฒา38ŽL&"@ ๋˜[า„tE…€“Y@ำsาฃ๑D ๛›ผM7Q้{ูFCœฌe œY ฏู]‰@ะ๎ๅพะEญ}#ม’ณใt]]ฌณ฿์น‹ธ89ห}ำตIงTl๓฿ฝoาR^VฆjiซKฃ๋๔๒ัฃฎ’อS|\อิix!ป‚U+h)ฦ๛KํBVYF@ ึๆผJ()(P0๏ฎN j๕Ÿฑ`ฐQ}%๕ตNพผ๏ิcd๐xงบศ2‰’ฅJึNฆt"AFฝฯ์ sฉ-๙ษb–SLz˜*ส+จซัคFx[—9Uๅ&\}ํ:๋Oฺž~ๅพฺด‘๛ไqœ๒wS›6yRฝg ิ^{ท€หMฟ๒PทIพฃ)U๐ ˜ูพ่-IูEซษีwŽ๑ุฅ—cฬ็ะx'๛ญJิ&า ๗pฒฮฟฺ4๔žv๋‘อ๏K7y†<‹vU9๙๘ซFวณ๓ฃo\๛|ัsห:&lวฃnภ๚c^๕๛5๎ฟฐ๑ุศนฑbหใ๒ยw๗G_นkฎŒ€‘๒D@ ตoฏ]6š๖ื๖Q๒8#๑Q@พQ๕˜ไ^vg}*ฏ*๓j˜๋\๏๎Qgโน’$๖ฺƒ)ำื๎QภsŠ๎œซ”ๆ'/๒N ํฌy9)ืท•ฝนb;uห •iฯ/บ่<฿!lู๙Xฒก:ท.ฤฌ>ฮr}@’d?;Š๎๏sฏ๋๐Mž๘ฏฮŸ9•žp๒กโฬ‰วQQf^๊ฑ;้าfo๎ญ\h$ˆนe)Oyู ^b่L_6คOบญ‰ณ\€๚r@hs‰.ึ๙โg]นญฐฑ;ๅลฅ้1GCทdๅTีP๙9LQk’‘‘‘้5ภุฐm๗๏h/0บ ว›l#=๖แ‹ e~.฿‚ฎโ็๗`?{kโ?ร8€ด†/๗ฃ^็*ˆษ•๔t…Œ์B.]WWQฤศ.ฌ}“ฤŸ–ฯ^RุFื‚๊เd๗๒Dง6 ฟ…ฮoAW๑๓;!ฬŠ|?xฦ]ฃD"@Q@kณžษัN‚เฉŠชช‚šœB!Eฉ๎CีทI์*`๓?lใงม“HTศˆ>ˆพMโO 6€ัVPŸWืบo๐mป ุKm๋?```````````ดฌ€ัV:g^Vm‘ฉฎƒ žวซ สHฝ]ำา๙4’0X๔๔อr๓3u็?*่ฎ[\๛อ ็?O—อ “ั๋7=ฬVWž_’๔๔่ส5็bซิ–์\7ูัˆ..O Xฯ7ฬv่U—ฟถฌาวTฉฬ|waขก@ตŸณkำ๏๎ๆQe~ฝKWศ’พ๔—:%ู๖์—t๔>๚น ๊ตึ"'žฺŽ6+#,$Ÿgณ๒MซZษ†^kw.ัCM˜quใฒ]/ŠปVะ)B1>oก{ษูeค'"สvใฆŒฐำQ ‹9eYa7คึิ์วNnซGวsJŸ^ฝ’+"‰PM†L็bฌ *Kz~๙JH>ค$ถ„–๓จล=หฯ ‹๋Œ๒1$ขๅนฯ=๏๚ห๑‚๏hีdย–?]dลb!›™๛่zะ๛b~ปuจธ๛-Ru}ใ™ศฮ=ฐฮฝัeปv=oแOึ๗˜โำ฿B•ฤษ}p๔ภ‹vœฆ?zํ"w@p%ถl{ิIงPใตl๛.bbBวี”ไ |z๏ำฉˆ๎@Ÿƒ้/O=ิ9ฦ~-๐jง๔5ิ—วี–็?~๒ขH@ะตw›โขญ)‹V—ๆ?|๘:ดค9Oัv๘รืช$(เ\:€แŸๅถํ ษาc๗hสรมOพ๖๘ฤ๏œฎํ”Aๆ&๒bFfฅ‡IyาnCงญ“อฉ ‡>pb๓จจรฦ;ง@#ส˜9ลlGs›ษZŠwSหฟ฿+Yญ฿฿ซ|L)5M฿Pบ3๖˜a[๘x๏ฆื”!ฮ฿zข"uCŒ๓?‡—x"on~,๋๕๗tใฅฌWพ‘tŠ†D๒C6œ๔Vx๗ฆw๚“–_rxyธฟ๑^๋ผlKClญ8สฯgฺถ?\๒ขอ:^ขถgวภ่าเe]ด5ie™฿ค „X๘><rxฯe…๙>๏4แb;Z4o๙๔ผข^{‡H:งI“X๒ฒ*ZKิtnWqwัี8e๗9+ูพJ}Sซไ6y =โ๐ฆฃe8ก ๆ ต‹<ม–(Iฒ๖žญ่ฎ€[Lฐ๒ปk้๚ๅRŸษeั›OลtRwทŽฮ้?Tฐ ฯฑo.กhœ>—9๗๐|$ๆ๐ฬษ{ฃธ ์ผpหฺ๎f ‚ข่เ]koฅ ถ'_J๐:]่Pu~ขล?ก-ฺk ลฒฏCี๑9วญƒNY6&ZZ[ =p๛๎ำIn6ฅฯ”>ฎzภ0RญฮNผฟgรษ0–๓t‡AVิแMq[uvwsS€ดำ๗œNฆ<~ušสฮหฎ’Uh~DPP–แTŸHKสฏ'Qg%žฃณ‘ณŸ{p็ยพฦฒ•)/.์ฺ๒฿“l^ueOต่จ„{| ๘ฺXศf~<]{sฬ–าฟŽ˜ฎ]?H“บmึsษBผมศMปiซA`&o๕๓ฟ•ูž5ฮPhถข.*9•wฒ2๎ีˆšท“ฝฯdvฅญw๚‰๗‘ฒำยญ๋f๔5S–ฤ?๏ช+IRN ฦด่5_กแbฦฆˆŒ(œ๎ะ ปWถQไ…๗_|ไC%จอธ๑ฦๆ–ส–1†•๕]xณฏ?bำž•^ถ*ย๐s+ํkืQบ๕>ช๊ฬิีฐฤU)i|8์๔ญPง๐*๓ถค็ทิ`U์ฟ&x๏43Nุถ้ฟŸIบํNพ๊ห80cŸึ?F่ฐ๛๛ฬป)?jด9๒q’-ว !Bูใ๎ัCU.ž-“ ฌ~๖#eทP๓o-*ิ๎H.H y$U6j‘…9g ™ล฿ปQS~๛Ylๅฺ-'rูlก—+DQ„หrูl!ัศT7๓พขZ 3x็?(ŠJ‘S›ลoVงVr>>0์๗Zท๓ $&J๔“dถ๐o—๚็Tiไ๚๔ŠZูn๎๎์TihMfิปs!…ีไnํ ื^Hช5‡ตใp‡฿gI’ฤ๘ฒ๓>uŸ ‚7ฦีะ,GN็j@C+ฒย๎ฆิfo้›บa๏ซJะนj.ยš lI’ํิไ† ๏;฿F็fV6 ๚O่aฎFโ'ฝน,กŒฺฯ๏/Zะ†;9u๒8้mข—Ÿซ๖ไ็&_็yL~ฝiฃq›ฦU]xฎ>zฌ5r๏๔™ืEbช๙ะ้ฮZrฒTงฌW๔xำ้w’ŸaˆRฑพฃ ่ภb ex/›&๊ษ‰˜i/ฎ]~žU ฏฃ`ฝr๛H€ผ๋w=gJฌฃq›ฦฑ๖ํxZmšำ๘jH†ฺ&ูIล< ้_t„ƒuฃB๏i ิkIคZา’PŸV“w๖.ป!์1X>า;‘รŒ’vฯ้ZSฐอ!๊h๊็ง๎b๐P€ŒA @—•อN[ฬไฆ1hส•ตฬ๘˜ˆวฉฬn๔u›hศ-โX)@>น›vu๎ท๘uฟz๚6eฉ+rjน‘๏2†ีื~Qžฬwฺ๚u‹S=ๆสU_/b5^ŒJ^หฆ^>Hฉ;=ื“ไ๋ฮฌ!บj๚œฃYฟํ?2ว 5pีาญ ฤัg–.]บtU`j{ gใ2T|๓ ‹ละ์ัห€ฎิฝง%@YYrฯMsqธ) ˆš\-ฤ••R™u*))เMฆœ OO ปy`ฉปชP ์{{uGiษฃ๏ฮŒež˜:f[T{lปdณct2ฺS7๚‰Nํiํ:i{„Ž›= Dชไl้x2–ภŠจoโ˜๙L’;:ฦฦvBฐมฺEžD ฐหๆใkK—9ฯ,ถฎ๕’oq’ฺ,C9vัน<&›ข4ำPCCšคฤ๛ˆ์ฑ๖๔สš็ท๎~\ี}า๎Su—–_๔49;<;ร๖2~YYy2อ{ำ>๛ -ปW;๛๐"iY็>”v=—&{,kดฑvu๛‡›•อฐMลใ/uBฺSLšœฺผ๎ถ;”Qfๆาจไg ก1rJZธš.ขฎจ7š’R…ม |ฉf๔=Wฮ๏‡ฏOี๑šnŸ~5(g8j#ะึึด ฒว๎ะ๛~ส:::-yฅข3aฝcฃJ4QŠ@ํฤ่%™LŠš้~[ห)สฒฒํ+eแๆEG$”pศ|y๊gศบํ[ถ๎Xj“xไr €BฅŠ๐Z~wำŽm๋๛๖TวK“ค*( •,กัเ฿ง8ชฑX,:]AJขd๘ฉm?๛ว๖ณ\Na7ค!บถ“JŽ_^q6–ำรลC€—‘—ฆฎmIP6ิ’อศห–"‰๑9ผทG†}ชd“!พ–ู7ญXฝ๋1วiโ}^b|บถน…,€’……l||Žษฏ„ลbั้tP์3v8ไเบ•›ŽอT47`—ศ()"2ถ“V=X่ŠJe%%(dฎ๒๓๓๚yฯPำษYๆลUซ‹V=ธ;”]F๕ญพปeีŠถ=)f>+ญ๓ ำ{’^ึ…อO†‰'d฿เฟrื#~ฟiƒ๔€๕rŸ฿Škฉโgv=gvn…ดyŠฌฏ2z๚ไs›ๆž๚s`?ต๚–ขf?ฃGqภใยVfHคีา—๕ ˆ"๓๊ญ$‘๑.F 6ิฟeมพ=T Y„S๖๔ปcษ”-ฟน9*ใ "7ฆิE!Qี้n ๐ส>ฦๅuYY 4ะVTึ6ญศO้R])ช<ญf ulf7UฏฎeษQ่-H+๗XถhาNฟ kฆธนฉwสิA็๔Œ5LfSY;โโNUS&jจ6คW=ุว๖C[.FT”ภศฮžก7CŸŸ +วžT(yx)8–€ๆ„^บt้Rเ๛Žฯฐ|ธp0Œ)7p›ค7[๑\Ad๔.~rข.๓Ž=มํrA -ศw–ฯูŠo:|ฝ({/;ฑ{„๐๚?ณ็m{ญ>๛ฟCSูnย๘ูมแpDบบ:a&??นxอM€๐CEM7:@žฎ ฦb6ฤฅฆ^ฺv.พRT๗๚#OOO Œ,ป=นถ„รcFŸZ็ฅ”vsยฒร๑‰[2๒ๅ‡ีษชา$%GFv๖ ภz๔฿ๆGึœ~ ˆAO{ฅ– า” ็สณๅฐ8ฦVV%ฯnGU‹…ลwo…*ุ(ื‹qธžฦWFGDs@ฆNฒ่YPd9ท6I๐[™๎Vjํ)&(ฬ่fh+b์‰Y“อศn๒ ฏeๅํฮส9RT€S%ท๔ะซ~พ}?๋—x@ััQlจ–{[W8v๘n*€œผ<ID‹ฤdบŠ’<dฉlf๎พผย ฅ5Pg]”[–ณ&:vํclแMmW1ฟr๖ใฦkฦžณ{ืพภา^“เ!™ˆุฐzวๅLฝ ใzำคH‰D‘HŒWะ61RงˆD""‘(%ฑํ y๏6^Šษฌr+ ำ™ฒt9เๅลช[่ใd, ไาKPi’mMฟฑๅภรฬ>ท<%ฝ„Nง'>.ฤ @ต4WJLศDฅIJBk๐?;›1ฯEา/‚‚ x &‹ฐ‹’^]พ๙กŠ‹ห””่๊๚z๒๊&zrŠŠดา†๔ฟฝ๛:ฟVฬฯOห(+ำ€]^ฮEAจ๚๚RŸj::ฌฤศlถHฤ))*4$jW&|ฬแขขส่ฉrzzาฎฆถWศ7ฒฑ†๐้9/ฬV›7ฺR€า„ yX(ปต์าj้ห๚439•ฯ็๓ ’’ซx<ะลC!้ซ ร๎ญ:t>_ลwIOG3ณq˜ๆ;n@™ะg)ฅ-จจฬO$k;wำชอ,ไwฉ๖‘€‰Qผผ’ฉ."‹xฉoณขจวnm=sgน'น๔1ƒอ•ฅIถƒf—Oด๎6X_ฯŽHlP๊ภ •Ÿsซช…jฺkl๕!7ฒฐฒ1Wศˆ„BิตเI$"€โฤS #…@’*… ะาฝ1n๔ๆVญK@œzrb๏`#%~Aš๎?ฑnถ(Šมjัญ ๅ6ค’7ทญ9~๖nRีงXฒ’ถ’ฐคจช…N -๘ไอd„b๙ภ๑ๆๆภ็kDL}๘ฝ`๗ำsาดัๆgv'ทUgญทˆดZย๘jš\`y็ูhผz๋?ด™oƒญ฿”&(ฏจ(าQฐ–‚5šQีุโE๋/*T,ฦแp@$…‚๚—Yuา“GMญด~yฃ5oYyBฦˆก}7™ @ ™L–hฝ"Qyžกดุธ๚๒‰Dฝ฿ฮ†ŽR›E†ๆไ๔ู )ึ_ภBุดY–ปภ#8"@ำ%ฑE„( H‹… „โ†bโ†^š@ €ย3ใ-.#<6ธ €รs๎ฬฒผ j3n๐๙-Ž‹ฤ( ช๛Q›XG„ˆC๐H3Wr๒๙ต… ัq๗DขoฐNถ๊m]๔๖lz‰ Eิ ฦwฒKPTœ๚6$Ÿ-vrHdฉฟ6ผๅI’,๐8๗ใ้?P๚เ„B€@Rb; ฉ๔แ์ขŠ‰€Bƒไ๚TN\k˜ก’)kกQ๘!•.‰ัศ๚nS'8kโE"DVR๊Sซใใ‹‡˜"‰tsไศTฑtI ”„฿‰o’ จ‘ดbf่ตช^ใT1าฃžŽ,ฑJJ(V๊ŠU?’ตt•ไลแ- ๑ข ฯOฑญ๔Cห3 u}Vฌมแฐาฏ_o!8ว‹EŸ๋ฦใ สnsV:ˆOโ—gKm-ทนBพ (ˆำ๎pEภ~šฟDรุฦŽ“ิ’vžซ ด–]J-}YŸฟ( โ์”—ล<1๐’>dฯRำ…ิฒ๖ฤ้ญXฉ/>พผ^Vูสฌ3!›พฐ7็มi.ั๛x9E"<แ&ฝXž coแญ"โUTึฯผ”Gfๆ๗Vา๘Šใๆ4ป™ฌ,=ไๅUžพ8ฤฎญ–กŽฯ”‚ฺ’ฑm˜5เ๓w–yn{_ŸPYy,‰pD"เ‹๚หฎB๋๏iลฟอ๗ฒซy๔ฯD่กHศ++ƒ^ณfูPืฆ๗Y๔คy—EvภŽื็ฆh wธW๊ฬ <8<เ๑๘@$x< <๊บHmึู>ษ–hฅC…ั>ปภjbข‚‰๋ผฝ'vN~;๚l ฏโƒภยVŽฆ W‘B ผP(ฤแ๋_ฟx9eคฒดบษM๒ๅMTา]จF˜ฒ?ุข๛ุบๆ;ŠขQUUi’๕‹๛ˆฯศ P/_฿—b่nd _žถSoH(fœ˜์q Sz๙$“€š?ศZป‹Yงโ3} t๖PR’w*ฏ$ฝy_ kซZคก˜อ็๛Q>ปŠPXXˆฆ†:@1hikไHแoม‚ฑšฮ๏บ๊†โสiIทš?JZฝ ฉล^ใฌ,=bใฟๅYDขฦฆƒ˜@ ิฒ›;+‰ฅIVVโ่t.ะ้ ,KJbQ่ัk/jฑ\*๋>iœAC:+=ฏฒง–ž.ลธ ๏‚ฐ%IŒVQp๒๊วฝทiSGLs๛sญAC:+.พjก…ฎ1อ(+แข %ษ/ีV”ตผฤ™NงWVV๐๒ย. ปŒงจ›˜4ำว%}heI ง…ถlad„โ0+#ซฅ‘เ/Kไ<ึ"~๗ฟ'$-ษhูุ้rำ>ฆ”ี=kฤ C6€รีท•E"Q้หฃŸดjTr… (๚ฅฮo@u-m:p"‹๔ฬ๕U”ๅทoณซO4๚ำไษ…ฟKhœตPKฟๅ9๏+P[ +63ชฅuด™IIฺว9ชหๅ' =๎JQ3p‚NŽ$ฃCS2ว‹xฺ-%ƒ 8๘ฯอO7ำจ‰๘๗QvLL( cๅฌนkง;ฦฤJ PV5š)[v ทชษใ8#)Iำe€‘ €ŒลŒgฺKอLJาเeงD–ี๒๎,LJjg"ป–q*1fqZ)GA›mทA Tšฺhuฉ๊๒ผ vK3t4'฿ำ_9ล 7&VJ6้๎ p˜ปหฮญ&i๓รo?lWs†โีvป>ฝผ8ๅฯ˜ไ+Lnk;˜~ปถโ}d žC;๓ตืLaaฑญมษh๕ดึ***dฆๅš8๗ีก’HŠ}”33๓ฅHขiq๑Z.Œidธ˜ุB)‰mร‘ศ๐4mSsy!]‘&K@Xyqํ!๖้–%1Z‡ว“dศJค:š+๒hช*ฒD@y|œภbฐ›ia|"ฏeษ๖ๅ๕๛Œp"ฤฤ ๊n>N&j๒ป’U+ฎ{TV—ะ-ฬธ๙๙๙`e…ทkš@ สำ้D‡ร5o๒จปO้3iพwใ3ฉœมP6๏กCฃiุ ๗์VBม(*T0ตT#5ฆฬh mAr…0หหUฬ{่ะhZ^CฌZห๘Z๘Y๙้FVรตeศ$y>fšY…™้๗ฯŽ^vp๔ฒƒฃ—:ž)x~๚ ฤฮดTKฟ>‚ผข]๓~๊d‘jูำX5ฏ$€"KTืถ}g/qว=I฿ะ๔;ƒๆๆฦฉ™ ิ••!ำ์zแSrFร่๎#๛๛๓oYฝืˆ‰fึ&ๆ๒๖วI๕uใ&๘ฏเไžxไI^•ZŒ]ตฺซnเSัuฮjืชหษg^ฝุ2oส๚)^,ๅ%\Yพro”ด4=XํQŸณ๘dไ๙ฐb€‚ฐ‡™&–ะงQt[={7q๏ฬฮ"F๒ญ๕kทฝๆ\X๊gบu๑๐ฉหลฬŒ‡{6o|XwอถQg^›%ษRฒc|k1 „ฅ๋.ฎ4R'T$<ดrร-’YQAืาศฮLoqิ‡ธfนฮฝฯ4‰U้/v.ฝาž†5YภขLะ4™ฯfœMŒี7› ,G {r์ษ=u๗๘ํG‚wn๒>zผnึN™ตSงฎ์).M\ฑz๏Giฆ๐vสŠr2ฐฅท&@ใK•kV๔s)rน2ž๓๊ฟ%IR—๑ฑืำs๏ั7( _X่ึ๚Tม—ˆ๒หs7T”๖ึา ใธe ษร”่ใ๔•๖หฌ์@iกŽ7ถา›9mับaโ„kซ๖วJณฟgฆŸยŽES–๕ไฟ?๘๛๒‹ํ{gฺ‚5ฉล‰ฏ)^์ฺ ฉตx)X๚n›็Tทf{ฮภ ?๊9Ibโใ o}วฝัWFฬ.Nพฦๆ๋Kทิ}fฎ.'feฟฟp%’ Y’$yั7ฮkOšธ|#MฤHzzๆQ*-ฑeืAQ๕ฺิeรขUyI—฿:Ž>‚๗FิTฤฅ“‡:ฑ7LฏK•ฤืXษฬw๗รฌ}ึn[•๑๊๊ฑkฝg-žป๗?/(Œง ๑จธyญพM%]ฒอh\ฝ„ ฆ,'&๘xpฆฉฮหว3o” ว.Œปs5ผ ะ’ะ4(*ไ•ื”ษ*ส—–ซ฿ `๕‘ ; I ,A๑าป†€˜Wž๖$เิ“lิ็0ุ๒ผฦVท=‘ฌคงฃ(ddr้บบŠ"Fva•จถ๎vึผ๔kแUๆ}ํm๘้ืยฟ ๊็แณ—T_z๑Cภ+/s0ฒฐŸfง}u็ใE^ฯทง)Qศ,ฬ8{๋<|zŒc” IภฬŽธ‹Vฒ0;&าc๔๊MรDb@Q@ksž\ฬัNt`ต๔ฝ!*k;v—)hึUh-OUTUิไ )Juชศบf&ŽlฦญpžŽฉ‰#‡q๋ง๎?|ึภภh?ขฒญฑฦภ๘Ea%:๐ี[A`ด๒ร+B~ด฿V๔•ัW~ด?;X-}gุ ฏึf"ตีํJไ&E•ขB!ˆ‹’ขhv…ฌงW฿ˆylฝธ๘ๅตบU๏ฯึภภภภภภภภภภh(ŸSลZภึQŸW7Oุ๘@ฬฉฎฉ[ฬฉฉะu๘ส๕_วฏพใWใณ—T็œ?๑ึ่2(ู-œ๕odPด_๗กd‡แฟญkซึj๖ถ’L ต–ฝำ užKm7„๑หำา๚ผข‰cฏnšt2สe%}ˆHฏ)zyฟบ๙ฎผ^oูุเ'ษ]jลG—…f4l`ฒœgู†C๖ฏศนq6น้:}’‰C ดส‹7ฃ%Ÿเั˜=นตีญHvะPkู;อP็นิvC_ู๛LึมมoWฺzŸุ้ั+ิ‰—า๖๖ซ๛|oพึ์?%Œฮ†ฌืwโX7ceฒ "'๒~เƒไสบtDVoะฬYฎฅ—ึ\On*จ ๘kั ๅจณkฎ'xญš็Di8ฤ›๛แิ†O[<6—”lˆจๅ4ปฟ™E\Sœ๒๒ึw’7ำื๔žo]t๎๑›†ำ›Tz˜Ž ู^%AVป๗šต‡/ฤทa3ผชEOog=9งผเี๓wฏ‹ญgj}เ””7๎ด๗ฤ๑ฮษ ‘wž็ง๕t๋๔N…้“Nแฬwฅ‚c<ูฝ๗yำ๓'•]็้Qด๋btomเตสซ๒ศ—าN‘๘ฬOฒn฿ }อTHœผ'ง…KิูN$๊l/฿มฯ/ ฺ่ปMqัึ”EซK๓>|Z"R์5rห@ี&2u‡`|Aป‡ห8G-uqMYแ๓goรKE@ีฑ™8ภิPN\žxir๐ชๆ=วน่๋สแj™/žพ +้๕๕ำบ่ิ‘7ษb š๗0L๖แฉฏ$=ซ~Zd5mgy[–ฟ|5ณ%1IาAZ่?ศสๆ? ~V…ะอ<์ žฅJPืT"ขฆก† ํ:ไฃ#<žป๘ˆลำ‹รEฌฯzm์๛‡฿ใjคž(ื˜ฝํ†$ำACญe๏4C็R Hx๏Ž๗mฅ~‹W{a'“ข(ปŒ๖ภฟ;ด๙“ค?d๖oƒ3ื_K+๗?ฮŒŸ๓ๅ‘rรศฌฆ้%O๖6oJ–”hHพืศa๒๑วv„– ๊nS็์™x,\า €]Q%Kฃ4ดซhTูŠ’฿=tsŸดธ[มงหPe+ืyรบgŸŽ๊Œ#T”์์•bdt๊ฎMtๆพโxญ๓นPEฃ•ฬถ6 ?๓“ุญJ๔อฏ+€Lh์ ถS็gHึูNพƒŸ_ g6~%๊ย๕]eˆfo%žfฑ’*cžฌHฎ;3H†ฮKสฐc%@5ีW6๎ฺญ˜ˆ†ฝ๛‚~&‰ืRชz^รด‹ปTJด่?pชc{H9J3Ÿ่N๙p#่D%Nวูc–ณAtP D 3MH.@Œ๕ี๑h—๊:(˜Lิอ ฯฬiต%.ฑB:jพ…U†X’Uม0 JุฆrT ‚ษQื ƒคก\SuพBNS1ˆ>4C\[UQ Bฉ๏กฤ\_!ูACญe๏4C็R ตDw่๚=ซวูk@i“SW•n]7ฃฏ™‚ฐ$แW]It<๓hท#}ถีํ†9่@ฦY็€aณ„ว,$Ÿ™>—9๗๐|$ๆ๐ฬษ{ฃธู!WณAWiF๓ร:“ธ@ฒšถoฯ"3Eด<%ไ่Šล'?ึHs ใง‚‘๔(๛#ƒ/~VJฎxŠคTฑ‹’?{•Pd๖›•f3aข‰็ ต่เท๊ใี[Q๛ฅค$CŠ๒2Q‘ตB€‚ฤL–‹Š€ฤซZึ„ xE๗อนงฟงPัŠjขhาs‚›กŽฌธ"/๑ๆ“ฤ์†siฆฮำะk ๎‡F0%ฟิš๊บi‡‹น"€ข˜ิDท๎F๒_(›๖žเฆฏKA+๒Sn>ŠอเิอipฎDาGบ๋ะนE‚C–ฃฮ^Kœhฆบ#j๛…๘2‰.ต#๛ฯŠ\๔อ, ๙ €ั˜5รห ฉฒžฤฑ๎ฆ*$NIสป'_%— ไ]ๆ,ำŽพ&rmซยI :u%Š%YงD ผVอs–€ข‡;ใ š๔z๗qำฦฺะุษ๗.ฝg4ัะD'ฝฯยG่t[ฒn@มํC*$๋”่'ขh5r0ช˜™’ร‘ขpJึฃฦ ํก+'ฎศ ฟ}ํi@พ็Œฟฒ๗ขัดh†โƒW“ธ๕ณcะeeณำ฿๓นฉELš2@%Ÿ[Q?Hฌ8ผ—jBศK =zจ&ž>ฃziสษPˆ\fฎ๘ลฎ 4ผVyU_ Q1ข“่ล๐ฑล๘ ฬ`กี๙๗๏ี† 2Hฝr่I^—>=„&#“—๙ก”'ศฯ(ฉฐ•Wจาีํ^žบ1รN๔‡ฌม#u5CสKติu 2+็ฃูก๗V ส๙%3}:อ4ช๓;ใXๆ๏ง")>๒EF…๙h]ญ–%%UHaGอทฐก,๖ahF~Rd:]–วซ เ‰44)4 ตšข’ฮlRaดŒพืณวŽ ‘ื๊>4C~œฑ[Fทšฝํ†$ำACญe๏4C็R ต๊๐5gนสFธ็nZรžmdตงWŽะฬ8ฟu๗ใช๎“vŸ๚ซป(;ป455)ืŸำฆก! ู9ู ไตlแๅƒD‘บ๓฿s=‰’ Iะ  >yห–ั qว7lyXi9bรถ™า\ย๘น(๒&‹€เฉบฦZB6p โ"“KนŸห"j}‡Y็>|š,ฦHmภ๋ึญ]ณb้‚ Nฺ$ฉ’ ๅ>ฺ.ข กhจหณูRZNขŠ*‘<• ก*วC•ด้ฒtjmEูp๔`ี์ทึฝT`9ฉทrฝธขqzv@@๐ๅ<ลQฝตคฝ‘จฒ2ฟกSp๓ุใะjฒแ(OฅŒwึปฏฦxฒณ:R๗ฝฒ‰#1๑๐ฑภcฉด‘Nบx€โทท—ํฝ๓ˆQzํฒฝ็—ีตฅนิฦ์?vvฤ่y-Œ%*8Ž์/~sl๋ฆงg+š๊5nนH42!ฝ>ถyk`ฑy_;•v้ฬพฝษ฿฿่šฯาU\”cฮ๏{5]sDณฆฟfS•ฏ๓๗฿x+]{ั฿฿฿฿`HE :ฟ๔Sฦnิฝœ+;ืm<๘œ฿วg€ŽT2ถ#ฝตฒฎ์ฐ้ฟ•๖พž†TGฟท‘4E—Qฝ๗๏%q;วฯPน90ฅ.‘ชฆH็p›*'u๏Oy’&1\”zsฉyด{ำ†u๛^”0_พ๐กฎH๊={“Cn|2Vyธ‡%งงPq๋nชึ>„็ื"มฺBUชึฎAQ๔iuณ‡ห ศSก†#ะถž>ุXตฆถRŽB สสˆ๑Š๎#Gญ]่ณสืล^ฉ๒ฌษ.่iั•4X…]ซMห+M,(mC\ตฤ ้0-Ÿ€งช้๊๋jัน้แีสภ..&X๊ล1BcN๐ฃMิEDลT1„ภ)~Sร๘์Y",L‹y%[,๕‘ึ˜ฝํ†$ำACญe๏4C็R ตnVจธqdว™Pr•๋BwM#;{`]๘o๓‰น*Ÿฝ=ํ•ŽdgƒฌฆฆณซWo'ป7P‘อmจzฐ๙ํฏd'๖žัs Šฒ€คฑ)I:แสํ%^ษ๘ฌท)L}๙๑,๕๔tฒ%บ„๑๓!ำkๆ:o3aqไตำทฒคสูsพ<ร—ฦด'w„เGVํ9n๊วิCกL‰’า ํzู๔ฐPฏ ฟ&๕ลŠ*6MŽฎฃฦ๙(ซญFaQj๒ซิ”ดj๒๏ Pฤ&๛๔VฆB9*3~(b0าKQyy€J‰J‘ฆA@QIซ&^W˜VLtV”‡’*`ฆ=ˆer ๒B}9y€/cปณKpฉู tํํฯถ็ AVž& ฬ’”ฐภ”O_2?~,ๅไg็ HMฺmะ) ๆวGฏาสสฒะบiซŽ๋าOU-อชไ‡y\ธqั้๚้P!_roVUKณ2๙~.[์คธLขง–฿œW”–Zอทแแๅ~CภTc ำžๆ๚–สทาt^$ไ”Œต‰Q•€'DQเฃ- †.~๋o”z#ชย’u/s7'Š฿ใื|๓%VHGiแา!j8xบhึdฆฆฝ-dฝ๓k๊๚๘๗›อ{OAมธ๗nญVmk—vืjญญพํฏึึ[ญuตuตuT ( (Ndˆฒ7 ƒ›๗ น@Pฑ๙<>—›๏:็ฎณไAตŒวndลษ๎ฅศP#Z‘อ˜ฮี/พน Y๗MVทŸ%—๚ฒQ๊ฦ;"คŽ ฉ›ฬ‘้BาฃŽ ˆฃฃฃฅฅ%†aร(,์œJ&“”˜ฒ X(JP(•@กPZK+x6ฐ††เ!‰UNPQQ 0”riAบ”ฎ๔œนpีใmฉd @Œ บB๊$88ุ`๊ฬ<„JฅjmmmllTซ๛<ฮT ้อ=koa4๛ก๓—>‡ถ/—ฐฺK๖›<ษ๑๖ม}-ZfJฑ€ื1^›w5ง.ฮล •P’ะ5`ๆ‹‚Zn]น๖Wra]ซ๎๚ดฐตแ๎ๆJnพ^ล\เ๊ŒCภPฬ*่ล|p@IrASว Ww|[pGQ=โ]๓A@ญภPLฃฎยqลVซี่x8t‡dค๚โ=4Rœฝ]:ผkวN;Lฝrฌ5Tž—~๚L.ง๋sฮปฒ{[m๊ว\Mญ—bŸljะฤ‰a$›‘หV Vf!oฉึYม0’&$•Jฅ IU}๕บ ~rSสญ.uCำฤู (nฯ.ฦ/NหN?^ฺ$ะพ>จห _An†&7uKeƒ๛UkฅR~yRR้ƒิซu~%8—ูฯล๓K/็fžญhช”JŠ"าขŒO‹จ˜Jฅ5เีฅW82dล9œ%ฎP*เU[-*ฝฐ_JŠxฌi้7ˆ3คฏ่ฎ?`n’œc—สšฅ ะTSลcH๋Eˆวำy?>™8ล}๕ส(ม™-›j†nx-Vtfหฆlํa&ดฑK^Jห\ฟใ q3…F=ะเ’}tdHdŽL’u ‹สสJ…ยภใุฅŽใxG‰ศคฮgP.W0ษ$ ‘0h/๗WVU‚หฤ‰Vท๖้ถ์๙x–๒ZUO&ูคLp๓โˆดต3ž;ฯXบ๏ิ[๎บCาโAๅวŒqษdวDลชkxฅ๊v…Pญ’p๏•‰fy@๎}"Iง€k[›•_ลuํปั=u๓-ใfณฎžQ Vทื: %ฝ็Qiศ่‚3๗๛MƒฃpกHๅไๆ,ฬoh”สF๘ุ‹+๙ ยq๛๎๊รก(Ž๋๊QKedŠ pfEXพ”LŽkJE(ŠjJŠฤจq5าฅ~b0$๊ฬhx๓ŸLXRซีš:Šv~Ÿeuื์ผม/nม๓sc*ถg้ž%ฺอf/Cร0•ช๓jšศฆ•Jี”น็ว4รฃศT*•V† šศพcFซวŒถ+ศะL$5uœFc฿zc๕กb‚๙ุ..า๚tฝ1YEฯผ๗๓†?๛aภ'ฒoศศึŸ'•jฟ—ฤ"1ส Sคภ [ตŠmาฎ๙ฃ๕บจ*ฉจณ” OM๕j๏9ุIQZฤnV่ศ>ฃ๛uhaAQ‰%„K<ฉน๙/—˜ยฝใก9F ณ#ต๓  $'ŸะŽtƒ๊ฦ;"ฆŽ ฉ›ฬ‘้Bาฃniiษแp V†][‹ƒuโป๛๘›-ฏDvœฌฬอ‚uย›ฟฺgหFิ็ๆq]Q)ฃปปssNdFœ ถฒBGป/ษg์ขE‹fFฺ€ว่E‹Mฐ&ด‰b$(ึฎž#ฃฌD2ึˆ๋L’™> P(ุlถ••)ฦ™ถƒ; ™=c„ ฤย.ิ฿ฉนYืB™ตษ฿ฌํเซๅ๒ฌ!•ฆค๘ ๊oIฦศ,ฯ˜p็ššz’„ŽhtบR 0jjLk›ภูihฦ%อต4{—VQ+๐๙lฆs €9GŽ~!ฺพใข0์้(‚ัBœœ]Kr(๊kโฉ$ŠsD`จŒ[ี ภ็ณ-]#)$#8ภIีฤืปxŠ˜฿jแํ๋hMฃ9XำP=!ฉุ! c฿ษีส3^K‹ญจ+‹ๅhi @YืPใ๎?ฺ‘B&3#}์๊8šCผ.็ืE:๖ร*vส˜๙“'ฬ๊x23คฯ่~_"|ฦ,๔ัœจพ๒w๛Šฑ๓Iก๒฿‹“W:i๖โ๐pC]๋ก/_:าํ,บ๑Žˆ้ฃ#C๊&sdบ๔จcึนฐ@OhJ๚—y/‡O :๙าNวฤ$็>๙[๊gK–|< ็Yท‡lจชฌpสอญศญหVผPUY@8l๓๊w฿m?Žxป๏ž/๛)๗TMIม_ฆฝ๗๊ถo๓}1๊ฑ๕{>˜eทuAHf๚†Bก0f`›ฑศ๏ž;๖์าโi qK/ษไฮ๛ฅ่๖9ฑ/lŒ้อ=Ÿ-&R/8Vย# ษxu}ย‹เ!ม5ู'ดถo%g„>๛ฺุ๊ฦ๋G2๏ ขฺzlโ๔ํ-11ปเฬฟ7๕ lzฮXทrด%ฌฺ8ุษ฿”ฌYƒ`๕ฦฤŽ…‰๏\(I˜๖zkŠขน์๊มฃ๋7ุ$„ะ&กค$๛ไqฏ๙/}4™‰ส›Kาฒu^8q๖ษฝๆ/๚`,็W๘๛P™ฑ={Dห๙สๅข๊ทขŸŸt๗P‘ฌ?โ4J๘ไ_ร5'4[= .ถ œณ๏šo_เผน๊หI€หZสำ›Vท X„N๘6T๓wๅพ.็)ช“’mŸ8}=oชผป๏zณ„E‡2,LŸ•HW ๊หJญlฏฐiืธZํหuมส 1ํํณ– ลcฎicCk]Qห๏,ถfH_AจTอb 0๖WG’>6U3€ฐ๗ ]ฺท“๚ฮณQโK๛vhฏA>kษ,๊ํŸษ&ฎDkิ บญิา3ษ>:2คn2Gฆ Izppฐ‘{Œ—|ะม?^ณŽ๐Mปv๊ิgฮ<ชธฬ xจC–ฎ อูx ฯA 4›ม@‰ณ;ค๐EŸ+฿๏ทค€œฦฟพœ~๚'+w\OŒ๐ุมกฒ๒ค›ย€Q‘aŠ๒ค› ฒ~9๙ฤ๒ะG๊‰่…5c Lฏ‰cbc]ษภ๐šะ~ะฒ๗เุูั^–ีwDLR7™#ำ…dผ#3fฬ˜y$ะ#†zนoาย๎@ฑู ”8 PV็็2&ฎdบu๋>ZปๆลpA๚m๓Šฆวยอ฿o˜ท% ,\;๚้ไ@ม0` ัl่*Qs“œๆhKวEอMํ(„amgˆybโžNบฤPฟ•ษ>:2คn2Gฆ IบนมŒ~ฬfฬ˜1๓€า˜tชZฦoSQt*ศ๘m uฟœ|by่#5 *;m”โFn๛p=1‡}ข•บ฿คo'ฬ๊ฦ;"คŽ ฉ›ฬ‘้B2‘3fฬ˜1cๆ้—ˆDํต%m"I?ž(˜ว/™1๓(ะํ๗:x3fฬ˜1cฦŒi1ืฬ˜1cฦŒ3fฬ˜1c,ๆ๚ร€ๅ๛|ย๘น๎d`๚,j?่yP๔๘ทG๙ุT71}tdHdŽL’๑Žฬ่กน8™n'„' ฒญณญ๙๖0cฦŒ3ฬ๕‡อilไ $ 9Ži?่ษ+`ะิGฑฒ–บ๑Žˆ้ฃ#C๊&sdบŒwิ#ึ Wwœ?๑(bŒAฯ}็‰sฮŸŠQŽบV‘/mฺw"%๙฿=_ฬิณ฿ีงxพ}‡ij่สฝ~1ฎณšไถเืไ37ษRK2๓าฅK้ฉง๙ๅxง‡-ูอvbํฐ^e๊0๊฿|ฟภOณB๗ดขN›หธ”ฉ7๗ŒO{ฤ๛':%{k่Š7/ฤ่ฝ ใกบ_ัGณ๕žDฌCงพ๘ึ๊ึญ๛pีŠEc|ฺWษภ์ยฆ-{k๕G๋>|๏ีy1ฎ$ฐพำ.ฬ ัฉฎำ{฿ฐŒfVข‹ึ —จž ฑํฝAฒGdŠe๓>~y๖ำ>’‹๒xaFฟฐj†ฏi?ๆlzNY๕ฺhยหa๓โ‡ซ็ข๕fฯฐ{ํฝOญบC2Š๛ศg_ํGkWญ\<1ะˆลมธ ้‡a‰Ÿญœ?ว๛ัน่XFL๚|ลBญฃBP;a/,ž๓๑ซ๓_0jธ๎ฃf}พ|x @๖dลคQFNž่ฎƒ=;๛ฃๅ3_›่ขทหxIฃ1ฯŸ04็|ฒซIA™๗ูฎb\๔ะ^า๔S๛๒ฉฮM5๊ฦ;"ฆŽ ฉ›ฬ‘้B2ฺ™aหข<๘S%$ฤปานO[ทvัp‹ข|ƒ;^บอ{๒๑Wfgำฝ๖ำฆW๏L๙๒N{wรจ๒/^๚ขˆ6๒๏ล็ถแ๚ํX^๕๙จ[^I๋ฒธ!c๛7ษํ {Kw,za-ษf๘ปฟ}บ$ใาw9ZฟนLNtI–mhั,Pฟ[๋‘ดr้ฑZ€Žด๗4E6S\Hoเ1i๏-ฉŸ-ฉๅ—Ÿ5ฝด&ฅษTVปc9kฦ(?ปF`่คใะ๑ก‚‹ฟ๎-hCmcž[zฃ"[b=+™ป็-จหุ็ ป๛Wn๋ฟ~ผ฿๑ ๛Ny1šจKะัˆeภิ(๔๖ัใท„$ใ ็lผศ~‚—4้;ึแ6๗R+ ผ๚มฆ ๐ยIกขาุYŸgฏฐ‰žต๙6฿ย}’็ฦWnJ*5t‡<พเi> ƒIƒปฺ™ัข๕ฅ๏ห:šซ,<ข^ิาฌ€ูฃiน'O๏ ฎัcŸ๖ฬ?Sjฒ“Ÿ”ฐoGLv๏=$๗)“\9ฉ)G›Hฑใ k๚9ซ…๘N6^ฒ'๎๛jภฬฃ—๓Z•jฅิ๒–V%(บ๖jฉXิคgeบ๑Žˆ้ฃ#C๊&sdบŒvd?kใ?+C;›ืฺ2ึฯ8xa'^iึ้ญ.•..@ฟMค๊๊ฮผ”jฉ คนY๊W=์เw่˜๘๒ใณn7ตคun๙โถ•่3โ2c*๗ใ๏ฟ•#ˆxฤถนถPบ}aF1!a%๏ฦํbหฉN€ูธ'$ฺž฿˜๕ค‡-\ฟfqด'ตตโฺ‰]\ญำณh:5v๑\ม๏KŽี*๔ฅฝg)ขFฝฒ๗๙-G}ื๙๊IuฯาŽุ่k&8๐ฒถฎ๛์T๏Ÿxฟ๙หฟผ|{ด=/k๋GNืเบำ.พท๛›3๛?›xnGqฟV‹sฮ_)l๔[์ฌ†‚ IDATคT,V1d2จqฉL)‹•$o—๊œ฿9R5@M๊Žํ’rฑฐใ๊9ฦw/MทE‡:ฑ#B\ข>ˆ“หฑJํส’ฐฯ%gแซฉAcV‡ฑ๚ทXถoฮ ๘3[=uๅ0K€ู G@s๎–C๗[K฿˜…cฝX๖…”+ทZิˆ_ิฌžn4œ__z&ํn…คซ#iใล”+7[ิ€‹ops๙J”UีM๊ ุ&ซ*>ุFD0๓OUฉ<งฌš"ท+-เ=m๕ค–;ณ๘`แ>bฮ๔ัพถd)ท๔vฦ…ซล<%3zู[ฎ๙Iชจฉƒl%ลg›/ ถ €ฐBf>3=ฬฒญไกฃwšิเ9eี ั hผ๐K!ปcy:ฯ)ซฆˆ’ฎฺOJฒ””_<|ไืgปd K\rŸc9อjJฤข†•nูsฃวฝ๑ผลษ๏Sคcx}Œภ Ÿowืž:MHโา ‡ๆเˆMศ”™ร\ธ ๊ึ™ใ•b!!Mลi5yอ ีฅu๊qvL(5Plิ•!ผ๗˜oLธCq๖ ปแŽ๚ฤ่พc็&qbPi$)O„r.r8ว‰ ํณ>Šเ%ซ‚ใwNไ8L็Q๖๏ฮ๔บว_ฅ31j…Lุ๑มฑaWr#ซ€ไ์ไส.฿ำ"WT_K๙ุิs%พ–ภถ๐sี?9|ฒqsn)\'‘อฉ—่๎”ีาะGษ`ฟ4`pˆู๚Š/ำภ~ุฯํ] %>ณโุฒa^ีwDLR7™#ำ…dด#vา šfขšc๛2tฎ V”v๖j•1ุ๋ึf์:’ำ€ญBฃE…ล<+GuWฑ์ŸL๓ไrธ๚L—฿ ŠmŸฌ์่=ศ๛~fll์ส[ล1๋aC}ซŠJตwม๔KLฐ8—rฟ๋้4๛ฅ๘ั7็MvีŽ<็่0ฆ^็ฃ'ลงฆiน"J{R„z=๗ๆุ‚ํปsุ๊ษ่ด{L๏vแใฅK/ํ%ร;ZฎผH๛^Ÿ1๋ํt๏ท–ล ๚ำŽฅฆก‰ ม†ƒ๊52๖’&™'ื%Iใ฿๙p๕๊ตฏ„–8Yจ ั้8ๆ<๒™ซึ~๘๎ห3#์ปผ1‘รIทฏ)tฉ;า…ฯ`๔๎?’,ทL๊ŒHซ๊ชœ(Vฮดสฺฮอ3ŸzๆbณไZา฿Ÿ๚๗็•+฿6u‡9›Tg8ฬ ŠWโX›ชิำ›<Ÿฺๆ=/บ๓ฑ๑J.๓ว๑ฝeฬษํ’‚ฺด|ฎ PŠป›”ร{บ›n#ยI๙๙uz$ฌ†%ฤแ7q๓/าjฌ}5}ค$/๒ต?ฟ๑$วTธ๖€œ‡mฺŽฑ)8ผ}๛ฑJ็„Xชฯnฐaร7~‡9Dกdฑy๓พ{ถ“โ1=6ํG`™{6ฟ๗žCBœ +)ชv๑๓ฃX๙๚ัŠ‹j8[7lุ–ึุz 6lุะQyฐแPx๔ทํI•N ๑Pรf:W๚ํๆ]ฉญ๓ฦz้ ฉฅ0F• 0บ›ณŒอ6๘&๎–!ผ๗ˆMp‚_ำ๙›\ฟ6C'ฦด]ถ๙oถgr๙W๖ฮiN .โnล?uฎฬeย์า๑ ฐ๏ท่Ÿ0ฯเแX้ีJ%ะiต•8e๕ห๓Ÿ7|ฐuว ฐญšญtwฑดq๖ฐ+TUŠฦ C›D้๖์x{‘Dศ ้‹gผdO0ื 2^nYๅ} dผ๖ƒ.จ8u•7j๘:๗)ะจ๏ˆ˜>:2คn2Gฆ ษxGโห๛Vชไท*4ีซˆ9csๆๅดcฺ\๕Kฎ€Bก(•Jฒcเมž– ฅย‚BัฃํฟหW(gvฅr 6‹๛ฝฒ/---ํไฆ๐k?%Uhš8Y–œRึ๑Š d––_;๕O็ˆซ!8ธนตUVjิ้IŠl฿˜/฿ฟ-ี˜Q4ฦงฝ>y็5M๕W3rq๗ŽฒTี™฿OWˆqi้{j;0๖ชŠJ{7ท'b"5#lสT‡ย#ปw๎ฺ“1+ฮ@!{ปฉ.ฑๅ๛ํ'k\งMฌU๛ฑŽ mนs‡ฃ[ฝg๐*2 2ตชกฎYmอb€ดพธััฯ  ๘{0Š+๔^aE๊ํ:n›จจœฃd1˜`eใ,ชฯo”)mEeฒฝMว(e^๙ลžTญdื5wHX พ๐๓ืfฮ ๎ฯโจ"AOqฎฬหำ;AŒฦdR1ง๔๚‰”|MiYY•Ÿื$WK๋k๊ u฿vณษฯKปZึส+)ฌRฺ๊›Qยฝs๑VƒTญ`Wึชlฌตnฐn6›r2rธrตขฑชNmkวIIq—ฏ@๓๓ณ..ชึw‡๐s/\*ๆ yล๗ซTึึLฐsv–ญ+‚โ{U$g'–พจC๚้ว๏ฮ`]=pฎฺะา=Cบy๏จ‘ฃ•ูนw Ž๓xRAA้nnšบ Aฺี5ฅ น\XV&’หๅ$์i„B ๖เฏะ\9ฒ›๊๖ลL>`;=ฮปย!ญ eฮCฅ5 k๛q2 Sแ8ฦฐ๑vฑคแ*ฆ๓b/ูžๆ[็)CP๘๓‘๖U๘‹ถ)๊๖ณfฦ‰›Fฉ๏ˆ>:2คn2Gฆ ษxG .;ด๊ณŸŒž›ขทX#D'Wลž"ณ<ึ๏ ไญuฉ2นรฐถิงคฐๆr}ยฅ;?Lนvี‚soฎั,นไ…ตˆ…cฺ_X๒ม’?๋hDโDa๒สชN1๖ฑoทzพฑjว๓Nสฺœ‹๛~–ZฅะiำึฦV(0Xิ7>E”ก/ฟ์}๖ำ๋Œ˜มh|ฺU*•ๆ€D๊x/ช; 0ธo?ฉ7ํ ก@jkk`ไผŒรยp'๛He“€ŸU๛๚`ฯิฺ&Pใๅู7ู$eื๏6ญpw†;ฅํ จO SัE๕ ๎ˆ่ฬ;ตZข(€ธจช5รฉฆ๚9ฐ๓๊๔V้ิxวๅยqผฝ\„ก˜ึIŠvViดตKศณOZุล,œฟ'Wทeๅภ๑Œ$ษ๛]œอำ็ํ&M]>ฺ oฉ*ธr.๕nSืฦ๕{๔ฺฤต.†๊ญLv^ึ.—ƒ0N-ษ›ยโโ–8?ค„แ็R–Wฎ๗‰ลป฿!๖เค ว0อB’๔ฮ w0ช}ฤฬgๆมŸ‡ ๔!2D+™ฆ…์>ฮฆโ๐Yี€จš_อq™พ๒ํ๑R™ฐ๊ฬ™ฯ*๑ๅ๘ฏ€:zถ^pm๑ฺ๒\ฒฒชฆg์ก\ ภ+ญe-,ป|H†…>ถ`{RฅBQTVš๙M)ลSฉt๕S/ูฬ๋๗ฮyีฯฌ‚฿m?่‚ล๐๑s6&w[6ง›บ๑Žˆ้ฃ#C๊&sdบŒw‚๓{Oึ}0[w‘Z/ ฟ13งEปu:cŒ›ijEkUๆmศ!B.—do฿ั ่`๏ภแp๕™TU๓ล๑า หjWห9Yทส|‚;บHQ‰c๋SฮkM/%}๖โi‰s฿V๚แ‡3๔u€ „&ำเ‚zR๔P†๘ฤฤ8บ.ž–™™yโฝHฺ”M™๛^า3ฎ‡i‰คP>|๑œิ—vŒษข๒ W– ผณ`Y๙‘ˆ%๐ @กUWo/iEE‹>๕^‚ข1ทˆWYืๆแโๆโโQ_W๖ ซVซมpษวqA;mขฺมw…j๏้BภๅM•œ6/ื>ฌฌ๕„ƒ๚D„๒๒๒t๏ฉีjํศLอศูทO์๖ฆ๗ฆ6ธMŸ>T๏๓ุอf—1TSำ๎Kœ:l๒Š‹\ฝ=ช หป!F~UธJ“dEU:gดQC{ฑTาฆขสถ€ท^฿Ÿ8x8[Yฟ๚ย/Vฮž๊JŠœบ๐hโQ'–CŠv}๛–ญ~w๚n๓SใึœผeๅodฑTฺ/@๕ƒwHMYปฎฒX8ภ๊Xโ6 ส u|จtV›D3ั‹j็์l‹–์ๆ๚ร€มย:ิหร฿ ซ๖ƒ.`๖ฮ‘nV:้kิwDLR7™#ำ…dผ#Uม๗>?aฤ๚R„x-๘๔ซ5m~wRGƒ“ส+แƒwๆ„ฐP@i๎ฑร|๊j๋ิู—3g-Šดฅ3ว=;หธTฆ฿ชš}๒ซ๏kฆ~๑V”แ…Qฅบฤลถ4ฐปศ#โKSR›5ฟ#^๓ึผ;}ˆง-I!เr…*}_+ปมสระšบS๔p†nŸมฬr$gืฤ.ูSฅำ.v†ณป-%7DVR‘Z–‡ฃJถ96RZTิl(ํฎ๎n‚ฦ#'๔+G์fMBŠSxง‘  ฌฉฌ๗ใL#“ญ†ฒญชึฅ–๎๎ฬบ๚ฝ๊=ƒยrd`J ๐s”sx“Sy๕Ej็๘pว๚ ถV M"hต๐๔vฐขั์ญจ:ฟH|A#ำ5ฬ‘B"ั|๑fพฎ๏nใ=-6ภ‚Bฒ๕vrดšฎ'๐  ˆnศ+ะš฿ม็๓l|‚™LงA“โ:*๖ัำ‡x10•ธU(QkกŒฑ k[†`ฌ€P/eCCWจ!ดIตsด$!3 ฤKม๎ดูT\Œ๛ลวxี•i!ญ>ี3ภำ’ฮฒณe๊ผCZ9Vantู2 ฤKลiิ'n>5a˜ฤย6ศวฑฅ…ืำเ ๕ืN~ถํ๏ฯถูถค3๕สœ3oฝI|ืc‰มb‘PEVธฑrฒcrš5ฏ5%›S๏๊;žB&ำยฝlุ\อ g็qถไฑ๗๗˜บบ";ฟั.TŠ3tฐZ^9Rหr๘„ุใฦL ’์ ๆ๑KฮตWฟฝ8pcลท7แแๆ7ษ™ฟ~Iตฮฆก๊ฦ;"คŽ ฉ›ฬ‘้B2Q;<ถแฺร๐ตษ›งทพ”9DงV%nผส{ต[qQMว8LI๚ฮ_โืow‘%ˆ[ชo๏xธ$้?l๘๘ƒ?“์ตืฌระโญภK๛ๆซ่?>Yา—<:ื ๘;๓u(ฺบ`๙_l๐๏ฬืีŠถ–šS_”ิั #๏ฅจๅ–^zk๓ ;LXzyฆS๚สgฒซi73šž|N3ฟ„0ํบR๔p†๔ƒiฏH๙ใๆkoํ9้D“ื9๒้ืน,ึฐ•ฟ๚œ.ญอgฦ<5ข/ํ๎cโYษ๏}œ†๑Ÿ๑แข!ํH ? ฒ;ฟ9YJx๒rR๖ฬษ/ญšIมลฒ งo๓€๓ฤ9๛ ฯภ…ตyวNํ\xuuujโ4>xjˆิ‰ฝ๋ˆ”โy]ฯB/็Rำ++ื\ฮซฬ๋ž:ฌฦ'Ddฅd๖พ๒๒œญk๖ฒฺฝmqhญs๘xฑ๕ฮ๏ฟฬฉด๐พอO'ัk_žน,\v!ำ\y0ดะ’"“–kซMส kึพท$F|1๙ ฉ<๔O†˜Uฝป๔1oญz๏ฝ๗{๗ท… 3s๊wPO5$k—ศ 7g P\||"=-ป4'-œŠ1lฌi่ถํบิ ๆ‡FฑcRpI+Oiaวขเ’Vž\ป ก1X–ˆฌY$#žWฏQ—๊ท2 ูGG†ิ{แˆ8CIŠž๚“Aq ๗‚โ7ยิจ๎!ขโ>มธdƒ3fฬ<ฝ dช‘ถIค8Jeะจj™@ฌฝรฌๆ$Ny๐+‚YXิJ™๏@@Fฝ๕ี#๒พ|—์๖|EXƒ^ูร‚ชฯ&}u"?ฑmถu็Nญง›ถ้6cะsŸฌ~.ส&c็Ÿูถ๑ืซ:ๆd‡ฝy์ท7VO:Kิ _Ÿยnว‚Wbธ-๘u๗‹M›ฎ?/์tิƒฅZปรบb็kฬฟ๘๔ภ]'ย5fZBด— Y)จฯO?›QึนEี5~มณQอ'~8ำe+Aฤnไฒ—โl Žpฆ ภ}โ‹†ะ;ง้I๓œREฌŽXOœ์ศฒภฅ๚œิ“WชคT๗˜ฤ Q^ถ…ฐ6B๒ๅJโ}œžๆอศ๎œSd3xา๔ฺž;Dy9 ys”ไภฑB}xu€ู๚ N๊ๆLGคฦ›Wณoq{บ*kิœxฺีำzนsRี๛ๆEหœฎš\eย}‡ุt๗๚๓รX€ อ—wํษา^qี:j๑ฒัข๓;Ž฿kมํ>๑‰ขƒ\ำu5Šำย%fZbŒท Iึpๅ๐ม›\B›=„ะfOyqvƒ์9tไฌ!NvdŸ]ž|!งP@w Ÿ76ภ‡‰7W;vฑธ~ ฌ๑๙ศ!ป…G'F8ฺT‚ฦสดห๙ฅ/aชใ gฆ๚7_L:e)[ฤ~ศฤๅQŒป็’NWƒ๋๐iKƒ๏ฟU†ูwิปใฉ—นxฝว[$>6hฮกำF๙บ3p~m๑ูฬาF/Eใ%ฦ\0ดี”ษมeJภู?gr๑‡ื Rฬฯ.B”MีwDLR๏…#โ 1]HFg™aหข<๘S%$DUŽถำซใOC฿‹ญิล๏ึz$ญ\zฌVเ>mฺEร-Š๒*œU์^ฒไฯ.๛Kปอ{๒๑Wfgำฝ๖ำฆW๏L๙๒šฎbNYyXdL$†ืhฮ7dl†#นฃkใำ’๚ู’๚W~ู๘YำKkRŒธต{‹๕ะI#ฑœ}[sdื๘…๓โjถœ)W„OMŒ๑&5ึwO}ะธh ๖ทฐ)swื" ชŽ \ฺ๓wกต‰šท|dะํช\ฉ[์ฬh๕ๅ~ปฯวขfฮฐ็D QyฆM(ข2้๕&*l๖–฿ด‘ฬโ”๓GZp๋ภ˜็ฦีบ`Xํฟ€U่ ซข๔jVบุdงm6 'พ1๙a!aqFrซขฦุ๔Cq’FŒก฿ฝํฆ,Hšทkm>ฑอ๒โ์๎3pF4z๓ะฑB’็ศ๑KGrพ<_“<ฆ'บ5ฆœ=ฤ%ล.บ้๛+&ู๖๋้ยาo๒๔ฮ๑S9ญ˜[ta3ิ–ำโƒ|0^]๗6šื๘A$VCš์่ใe ˆ‡ป=ช~ ๗’ฤ๑.๔ '›0฿‘๑ณ‡4๏ธม#พCŒ—์‰๛พ0๓จP+…R\ซ”)๘Cื^-•หU€๋l! nผ#โŸ๛ๆศzofˆ้B2:๋์gmgeh็˜ภถŒ๕s?N๋I{4๊:๎ฝu+&จrŽ}ีžl~{ฃ๙หฟผ|{ด=/k๋GNืดืฌฦฎน:V|โ“ๅฟๅ˜จ_ไัA]๑HKูๅบ‚Šฺ๒zˆณaˆฤฒ๔๋%Ÿ๙Ž]คษ^ฑฑ๖๗.f;Lตืc“P]&‘(้2น ิธLฆ’I$*บฃฃ๖๖&ฉ€}ทXํๅ%5%Bี“˜ฯศ๗ce‡๗ๅะhjกH€Xy žใแLU ูล)—‹๋:5cz›๋ม’ฐำRฏ็ t|\*rฅ*๎ฒฒ่`&4ˆkŸศฉัฮTตฐก์ฅ{ีาŽ>ำ๙–ใ†ปฒd—.\ปรS; Mxi `๚aะrwวฑBaH=P2ฐ cOฎQtํ๐œึXฝ7`แ=-aธท-IฺT‘›™qฃŒฏ` }๎U็{งUƒ'…ุHKฯ>uOHl“๗‰o,สฮฅลฺตCfเ”9‰มฬถ๒๔c'๒ด‹ปZ6Yร–ฌ๏๐๒;๑ ้ฟํฝ! ถI'b0!qlˆ3]%ฌบu.๙FT‡M@ฌƒ&NโLว…ตwฮŸนR-`„ฯ_>ค๖ภkอจS‹๓ฌ2vŸ*•๕5ฮ>",บฦฝรSโ ฌฌjV`1„๎๎กอ%k%2€ผ;•งz8_iaซำผbgLŒp Shd_„6eํLสw˜๘ฦฤถำ7ํฦ๗gJ*/'ธำ„๛M}o‚2`$3๏lž˜8๗Š“fฒMZ๕|ได–n*(qPึิดจ‡ฑ˜ะะ*”ๅ]ซโ๛&ธv}+b^Qaveนู6ร4oล†&ฉท›%4}ึ&ง.nผ๒_๊%2€๛๙ีq\n๐ˆ๛ใ—์ๆ๙ฆ็๚‰#u'รใ“๖ƒ.ใขF2ารี บ๑Žˆ้ฃ#C๊ฝpDœ!ฆ ษ่ฌc'ํฟ iฝจ9ถ/ฃgƒY˜“฿๙0๐ฮ†Eำfผ๒+7๑๓ๅ‘H๛y๏ฤาพืgฬz;๛ญe1ฌตwˆซ•ต'Uงม'๒่I๑ลฉiZํเmEigฏVuฯ/ฏe;“““ฯ$ต“9T€ฺŒ]GrฺฒUhT จฐXO1Žwบ<:ฦั+&ฒ๖Fว ฉผ๏gฦฦฦฎทๅ!Qฉ๓.|ผt้e๛ฟฝdxว\—๎9๏4๛ฅ๘ั7็MvีŽ<็่0ๆ xQjš˜› 1^qfv0š‹—ฃฌกQ ฒ†ขปeอF์ขวฑ3ฎิvi…ตน๔wy{ๅ+ฯOโD]๊ย[Igคฃ_็ญท฿]Tv๘lฑ@"*}ผif้ใeOงัˆฃT D8“Žู1ไjk'…I—Džวุีฅ'tเยEภŒH›qKฏ(หšคฯb[Oˆtา๕EขQ)Jนขณขr0ใ–ภยsBฌMuzส–ƒาล^3‡v ฌ}"ศลž๚ป‚9~ˆ+ภอN๙fwสๅษญSGพู}ไ›๖าฟฎŒT2p ล๎่(V€eไ„‘๊์ƒูy๘rญ•ทซฆ”์แEพ๕๗ถํษM~รCmด4 ฌMบiำฆƒู?ฒถƒขl๎'ํ๙tตใ๘‘>ฺWSf๋ญ}›6|ฎJ]x|ำฆM›6ํฝ!ะcณ{œ”ะ S]๊Oํุ๒๓ซŠจ#uฺค„ŽOtช9ต๋็ญ{3ZรfŒ๖hหฟxM3!œi5tBDKzZฉฬ4q๖AMj.GลรFสแตะ™th“(]-žไk/ ˜4K]๊ึƒว_ฺต๕็Ÿ~ฯj\฿Ÿ”฿ž$๛๐ม7ฒ๕Ÿ"›qฃ0ฤีRp.ญยqL4–u:_ไggยd<„u— šd€R\]ญeMผ‰๗p% IDAT6๓ KุอบG๋ภ๑>-ู้MฺoEqmƒาอ‰eํไ)h0ๅภ‡ฦ ฉ$*ง9๑ถm’VMื.ธฦK๖sร€A).โ๒ฤ”’b.O"y่>ว›ผ๛ษhแ้ฝ)ทp„L&ฉT-ฌJฅ’L๊๘Zจ;วเjœDา<ฒญๅ—“หa@bkc+๎(V9์Ž’๛๐๙’…>lัษUฑงศ,ฯ„u๛yk]ช๎ฌ.น~ำ๓…ผ?_ไ[ฬึ๋K“๓*•J“ษsž}์ญžoฌฺ๑ผ“ฒ6็โพŸทฅV=จ,(„ฉญญ @๎ฒ-ห;ผ)ฃฺ†M™3๙;้>a๕‘ไgw๗x€๑เฌJฺ*่ฏ-ธ}Ÿํh@x,|4ๅฏnQn|i{z}•บฅเิ๎{ษ$\ฎฐฒp„ปฎั-ญmbšณณ™—SGŸโไˆƒธ@QŒๅ7oพ(IัฺาQnQซqอŠู#Ž  V (ฆQวqE. ฉีjtีst†dค๚โ"-8ุฌWHp็\บํุIKFXชx5Eืาา๏7w๑(ธ}hm๊๏|fิ8Žbš์“M š81ต2๗ๅPฒBภึYฦPTฎz^Ÿ+Œ‰ๅ_ส๏R74MœฝD~๋๘ม[˜…Cะˆล ฐ๋L•BฉBDV|๙หbJฆR้l+Q๓kนN‰ห_‹—ษZkฮืฬำ<ขjตAžไ;นo(r“ไขvรๆŽƒƒฉ5ฤoE—ะ8๋สใ็๊ด็—ืฑ„หฎ“cูlr”*Š ฒ๒ฌŸส(~จ ื9ษำhษž`ฎ? ่Ž/„:ˆซ ‰์–†9Hซ qต?XDP๐D๗ฯ๑ปOฃฮ54X€dR๏…#โ yd)๊Šเ“/Xณf๗ผ ZฉTขXG๙ ร0ฅ๒แ'œD")”ปLฏQฃฅy—ณูn๛JPภd์?uN๘d•กีฺ๗ญVซA˜ใโ๙gsšิŠึชฬผU#B ๕Š ภŒ๓ล.-W๋qF~<ปfrท“โขคฏ฿Nฒฅืะ…๋พpFฮส5ฆ1&‹ส7ข^ิ[(ŽA”บป5"PI[Jซฤ“|\เ~)‘คฝหฺ๒๙U].kœฏ์:ย1™y๛ศ๕๖)๊j5่,c$Lใ ‚‰t—0_Rี0 ‰ฮ;ตจ ทwฑo-ไ6ษไCถ$’ะฉs†ป๊ผp<.—ๅ์B#‘YพA8—+@GL๔ซJ็ิMˆ?H๓"2yœFƒxฯŒtง €์|œญ-P[[่เ็JฅXฐ ๑Bหjt-8†a$:“IBQ}ยjธnํ™0าื…‚Bฒ๑rดŠt Œmธyfใฎ#wูธ๋ิyถ2‘]ู/ ผกเเ๙า~\:ฏŸ`ื—ุ๚ฦ8S-,˜Aƒ<ัช๚ฮฌจฑ#ใb'๚‘ I๖sร€กต๊ณsี VTqฎๆมะŠ—n]ฝ บ฿จ๏ˆ>:2คG„bบŒฯบvx์ิ„ษ?};h†žทV5ๆโห์ฌa+;๕9]Z›ฯ๚ya๐ซ‹ุญโ’ฺุๆ$ปšvใํ1ฃ้ษ็4ƒ–‡ฏM<ฝ}6๒ฆฬ) :ต*qใฅ]฿_แ'ํ)ฒฦ๛i฿}}œ้;‰_ฟ๑฿E– nฉพฝwใแJ~ดพฅอิš๕—ฮ|Šถ.Xป"ๅ›ฏฝต็คM^w็ศง_็๊สy„WXBz้ญอ+<์0a้ๅm›Niต€บ‰g]%฿4YD„ผ่rZภด9ฏวะy[sUึู[อ>‰๏,ˆh/*ฮ[3dy‡J&ช0)J2S}_|“IRูE็’s[uชgฮMœฐ๘D .iชฬ8Ÿ#A๖น .‰3^jกิๅŸ8[ฌ๓ฮ“Š…*™ดI c7ซ[Emฒช YvSฆลQykใ๕ห๐ซฎึ…Ÿ=ร’ฌโณK_ึ–žษbN;i•ฒา ูํ6ฏุMŸ8‚Š +Nf่&*‹n็Ž๙j(&c็ํM)†dผบ^gฒ_˜/ป U{เฟ(?ใบŒ็^jสIพUm t๔ธclจ„[’ž’ฏgสMื +žj๏-|yMp.ํใOณภ+kโ;&jบwต2~ฒ7g‘•š'ฮึ๊ดIกMBIiมล๓n‰ VฤัPน ๒๚Y=รา‚‹็ฆฬ|uึๅžl฿ภ:j๒~ๆžjE[…๐ูc|‹ฯ”ห๛#Nฃ‘—ๆ๕๙‹!4Pˆx้Š8 จ9™b3oิ™xsๅฝฟn๊\ผ•Ÿฅyูห๏ว.็ื\;u์Z}฿B(ศ+ .xลฬ[DC”m|ฮีKํี็)Kc[ภไ๙แ ศM>~VืB้ทฮฅจKอฐž:zาtœW[”tMณ$ซผ™+’ะ”šWšNษพ€Pตš]็ฯ๊Hาว&ฐjฆ ฺอ ฐ•ิ•Ÿ[อฐ“ี•Ÿm้2~)ุวw$ฉ๙X‰ŽMะ4๊-†แ์ฃ#C๊ฝpd0C๚/Eมมม………า'žา=","฿?๐ ๅ‡ๅ__}bืห๋Yฮฃ.376-kๅk‡บส!„oฺตSงnROD/ฌc 3‡ธ:b @๊<่๊d๏8ส‘ฉsL™Pซ’}tdHฝŽ fHฆศL/็l]ณ—๕ึ๎m‹CŸ‚ๅ?ฌGฝ๓๛/sช7ญ?ld›yDะ‚รห JMZุ(6๛ƒ'ช๚ข๛ดัฏผนrลŠ+Vผ:?Hxอผทb?`แ์ํ5ศี๕‹…1lฌi่ถํ]ถrเๆDั%i@ษฦ0`@IึLญ T$k*ฆVศ]งืR)จ๘2%qํUฃnpฺฝ!ษ>:2  G3คRิO5วp/ศ/๎ฯๅŠ T๗Qq Ÿเ1๗?˜1cฦฬSJกSฉjนPขิƒ`$ตRฆภ;บ|2ี’‚HลN(i@ ใก”yร€W๒%ํXอAค2™พuxpbญ^H๖ั‘๕82”!œ"3ฝEฦษ/~1˜iํ’วƒ3fฬ˜้?p™Xmy ตJ.k/๒kบฌ z$ จ?ู˜วd˜1cฦŒ3fฬ˜1cฦXฬ๕3fฬ˜1cฦŒ3fฬ‹น0`ฐ`Ž๗rอDฬื~  แIBuใาGGี{แศ`†๔kŠฬ˜1cฦŒ3fS˜็? Hด›V1๗ŠŠ๎`ำ&ๆ^u๙•เ$กบมอq๔K๖ั‘A๕^82˜!šข^ภ˜๖ํู‡‚ขj€ึSLtC—ผืฒ?~ด~ฮOyzญ†พyd๛3Ž€ Uป/๙ณสDฑ P—๑๏}๚ฺxG:Zw7้‡ฯ๗nฐŒXดๆ๙ร<™ฒ†S?muณYญC’ฬ%nๅ๊ื'…;Yด–gอ7'ห:ฦฑบ-๘u๗‹M›ฎ?฿พภีงžมยีธ\ิXxn๋tI็ฮj&€โ2rึ์H^๒ฏ็;6y 9„OšํeKล%อU7/ฆํ\ ฟ›$ะ†O๎ฦR๑+ณ/^ฬๅศuูดp:yPw+ฒRศพ%๕J…H—$Ž/วHŸ*๎ถ6/+z๚hฺไK~ฦ€19‡๋{.ิเฎc_+:|๐V๗ฅ’ญ/xnธ(m๏ู"ใๆคaำ&zัZ๚žK‘๚’KXิ„PkฒJศฉพ|ต ยเf๔เ๑r‚ญs๎ณฌ๔๊Žk\็จฤg8'ษฎTษ{๘kqิฌcูa ม^Bs žใํฦP๓๋J.^+็่^?ฬxIฃ1ื ’–?๏ p… ๐–}ํฺH‰Nช๏ˆ>:2จ G3ค_Sค™aหข<๘S%$DZmงWวŸS๏ํp๏—๙๑ฟ@ฤ๛'V›ฤ€ยgๆ+ใv,y๛"s›ฟiฒqGnŸ†ฟดaกz็; ฮื“ๆo๘๒ํุ%Ÿ]Jฺtœ๑‡~Yซ_XWŽ๛,zหณฎฏ8า^๎mศุ GrG[ญtวข๖ื’l†ฟ๛งK2.}—ำ/ษด 41ส“ฤakWya๑ฑŒฒฃnF์†NŸ?&ฌโH^ก$ษ/~ŠOs๒_)\ฒ๗˜9Sbุ{39jBIซมccะv฿’œGฮ9ฒ๖ท๓Uฤ’fžP,ƒ‚-Kฎิ๊฿จณต์ส‘ฒึศ-Œณiฦdฐ|วE ๙งฯๆ‹H.CGฯา๔๋•FSl๛๕†_ธdฏ๋95ษมำ*9ˆ›‹=ช8U นฤว97gฆงดผฃGO‰hู{›O|‡/ู๗}5`ๆQกฦEr5จต5จnผฃู้ฃz/ฬ~M‘๖ณ6ณ2ดsœS[ฦ๚นงู้๊ตจ๋ธ๗ึญ˜lฃjศ9๖W{ฒ๙เ๛ามฝ/ylห\ฅพฐฟlGผ๙{ณร์๐ฦค6์ธษำgึj์ฺซcล'>Y[ฮ@[เมHฺนตHฌPใ*Q›ขM X๛๛ๆ9[ัŠ?›ั๘\T \ฮ!’$„<8&"ิ{๗[๗นฅ‘@k๛๊าํ 3ŠoPษปqปุrช 2ฆ@าTq๏๒ํฒ&ฯYพš“–tJmแ=ŽTภ)ฏiฐฒh#”t๗๓kฮ฿]&(ฮ.1อฯ>“ร%”„–Šฌ๚BžE}Uƒzค ชDฤ’:az™>ย)mศฬธU P žธ8‚ 0;x๗“V„.)ขฉถฃGบVฅ}ญแฟ]#ไ4K=\Xภ!{9ˆ8}W๙แไ๊'จุ •฿ซ1ฦล6ŸGษ`ำ=` ฟ14hฉ=4๛ํฺž$T7!}tdPฝŽ fHฟฆH vา šื{อฑ}=ฉ<0'ฟ๓aเ ‹ฆอxๅWnโ็ห#€๒=‹bc๏,ๅ^๛ยZ4๒ฅตร พ|nฺฌๅ{Eำื<ข฿ฎตwˆซ•ต'Uฟฆแะว_Š^<šr๚Lส๎qY๏oฬeม1ัV(ูiD”ทตตตIBฌญญeขึŽ>ึ์ฃฟ_ฉ€ผ๏gฦฦฦฎท…Pณ6ิทชจด_* ็”ฏlyจฦรฮ:x๒n๛FตณcHฅ’T&D"ฅk๔ดIก6"‘ˆมd่ฒ)(ป–['Œๆ์๎ oไˆuI๊ยาs0ซ๎๔ษ‹) VqƒQ€ๆิ-๛.d๑ค9)I[๖%midแ?าช.๓ยŽรWฤ‰ƒํ:ิญ<‚‘โร‡ฯ[ลŠwP{*=ุ“ ‹ ฃณlU|๚ภ”‡ธh/๊ำwmูฒๅHร#blCรศูGvํ>Vbใƒ๕ฤf๓๕}[ถ์หjๅูฒeห–-ํฃ›(A๑๊ฮํฑ๋Ÿ+ขเฤnŽB‚ั[‡wํ๚ทิ6>ฺำ|‰ hญฯ*l–jแ์l%kๆ๋พd5(vฐ$k฿ฎฟผู,ธ}๘๔ฝ๖็”เj"ฮ,aฺๅj‡QCฐ›็๎ฟทอฃIฬ“Uเณ งฝ๖LโาฤจŽป[R฿จrudZ9บตrV็•AฑT้4mดงX"ขำtํ‚kผdO0๗? T๒rH*WƒJV!ษไ]›kOช๏ˆ๘ืพ92จ G3ค_Sค๘๒ฃ•—y# ฟuเPa_Eซ๎๒eWา๎P–ุAN‘ ž๓ำโ7กญMp#ง๚ร0{vซŽ~๑Qƒฟ8๏Rฯช3 ›๑๏ญ๒ฝษซษ~๓?xYแ๒mwืุ|wใ?งr๓ฮไีั%IdAฺ‹4Œฉ฿œZส>๘๊ขE:๐{e_ฺrภHP~xอzf๔ห=xPH`€ท8‡{E:!‘H8ŽcLGw7>UลW‘0ฝฏJุฌื&x)›๏ง&]ฌ๏๑Wตต&ซ€รเ?{็วu5๐;3 [X–;ˆ"„๊ฝทX.rwŠ—ุq‰วฑใวNพ;ถ;ŽK\$ู๊ Q!@‰–eุwๆ๛cฉา6šาŽฮัp๗น๏iฏฟŽ^Hๅฐœต›z๑E:YกdhiSPRxl่ี€ชฝดIcPศ๚‰อฎ$๑‹ตึ๑๒Pี_jW(›:!“ฯpฯพซลWไ&€žฉ-ฤ‹08Zmผ็ไ๛ˆ4-…Rƒ ฅฑ“2Oฤ†N๔]+ฝึkPHบ‰6ด‘—ุิY+ึฏฐ)šส”๔:} *•ษAA™~พ|จถOLนแj]msจฅททMg‰ฑ`4๓nzkฟ=ะˆBDอ^??ผ๕X#€ถง›F5u]ตฤˆoq"วรpวXผ 1…aำฺ0งฏtฯ5วไฮArS0ฉ5ุ฿ ๊ร 7tฒ™ ›{๎ศtไึ|<ŽdJs4 ข้๛ฏŠ๎๚B๕ั/N:nขv•JฑูYญV*…๊L“ทํ•็6FRญ„ใ e๎Nฌi.8ั<ึิฬ$X™kณ›พข ~{๖/ึ$X} ๏8๑ฺฝงfาl#{๋฿๏K!œi::'Aุ+Œบc/,=ฉOอล&‚M{v?๘•ก‰ณ_ื_wf๗o^‚ฒ๘ฎตaชซ•U'ŠZ{tฮGจูl6Eอ๕G?ฎ 'aC7›cLW*Fฤญุฐ๖ญิM‚(๋เŽ N๛นQฉ‰ขC…b๐?ย…9‰#€ธSํพ‘/ ก Žขฎใ9ิPB ึก'tN q‰qรฎฟฤ„ป$มXชsTฃTaDฺ†Eศพs'กบซWผ์พ˜อšฮŽแ^อ;›Yซ่?UืJไ๑ีเศ9ฃZG ๔ๆ0.ZมG‹h…"ฒ๕ซพj4ถ7 EPFXˆศ2lNrยิี๋—ญุผ8vDW%ฉจญ3—ฯยŒh•หวฯ1œSงVำย8Lถ€วB@ฉPpรข}™…hS(.1๏อ0ท๔Œ=Iw8/xูp?…$๖V๋œ MฤPŒษfc(Šขw|'ƒsŒ85(28˜…aร/:@คž@Œหj๖็6๗สิ‹niณ ,อ—Aฃฒฃ‚ัv้เ+›š•ฑlAๆโ0ฬๆD ว/อ๔๒ฟ_RAศ9p0ƒ#กcsฯ9b‚Žšว‘ป€LiŽnค_:žฺ€๚ฤ฿<๋ฅืฟปo“]9๘ฺๅƒ นG๖ซo}ณ“ฆ+วOŸ=$=๖๏ูฯ๏=๙T_ๅ?=๗“ฒห IDATบw>~}ผ๊'?~ผำพ0ฮื… ฎิส๖:ฉฦG฿ ๑p๊๋ ไส<๔โ“|‘eSต^ื{ค ลฟ๘‡๏ทณ]UG^};_็Lำ!ฒ฿๘“฿o^์>_ฌทๆฤo้ƒ๋/|[๘sจ๛`็#฿H ๊็฿œฐ่๚:.yำอF t๙ฯ7'ฺ‘6>ๆซ?บ@฿ไ๐๚๚c?ั่H๓L[c)Ÿ•K๏y˜ƒ+[/ปุC89็™ฦ’‚ศUNc€E฿฿q๑LeŸ3M‡๛Œ(%ฅา„์ kน›Jึ|ผh่ปlmฌฌŽ\4๏8ิ,ซ๎Lซฦิž_"\นhe:ƒะ๔ดž,จัฤYkืญกZUMว‹ggfa่“) ,srxh5<.LV›gกี[[ฺพ ๛๎วธTซJr๙๘™.^ เ'@Oแ็฿–;ฦ้้9,%…‘kึ฿ŸJ1K พ;Xญ1ึๆŸ๕_น๖t&ฎ‘VŸ<5ธZ5=8๋'ญกYU#ฬI†ฑด]หžณqG4ฌz•ผดธษู˜Xีต ปvr>เfUgูฉ#eใ๛ ฦXฺk๒R—oXวฦฌšฎณล-ZŒ์s˜i•/kW^!oๅผฅณpegรฑ+Cซ˜™๚:ำาฃมiN„มีฐcห›๛ผ<๔'ป*kTt็ู+‚ธfEwพ'…คๆ=”qqqตตต“๐ ’ฆ8ผCฎ{ำฺyqบwŽปY้šฮ8~Žฤ-๔ธ Dิ็X$์5…็tพฅษุมขึ4กำC๖E—0๏Œ[˜๙Ÿๆ‘•ฒI†9;>ยา~ฎZaq ิง&DZํฟNPsฺrGสี๘% #ม›อ@†H!)$…Œ™ึFABBrgภˆŽ๓oญmžิขศTœ“d2ฑu7ึ3็=๐่#?๐ร?ฐ)ZSvโ}๒ก‰CBโธวBšO๐ะฏิœ)ธ๊@0/Š[-ZใาPยjัฺH!)$…ํะd?ฒฤ5d ษmJg1่„Ycฐ„8ษ ƒื jN[ฎ๛Hนช๕6ตษ^PฒiL6RH Iแฐ„„„„„„ไ7้๕7ฌT1,4†~ ๆL\‰„„„„„„„„„„ฤSศ๚ ‰ง`ส๐ฆ„ธๅืjฯษฆฅฯcŠฬNK›ว๔1[dZRH IกE6ด๕ŠH$R(&c!e’‡wศuoZ;Yัั… 7+]$$$$$$cเบ”ซ๙ jdำะซฏ2Qขโ˜ฦ^}U7A I!)ฌ๊ž SHHFมžต๙žL๑Asฮž3-@๓M^’•เEตje๕๒KuN4nฤ‚ฅs#ผูTฌ–ีๅ^๊บูwyq‹๎N6ๆผX7c‡ Oผfmฺšฆ;™F2ศำD˜ฝ3‰,—\’ี t๏ธตKย•ลวฯuน ‚„E;’ุ วฯu8uล–๙‰/ท@ I “q๑HaีLูฮPœ่๊pๆะฆEŸ”ศ'ช9\ญฟ„ก\.B่mZ+ส๕BฝMk&…คฺดCฑ‘๋/‘ธfญฟ„P,ฺภvค”ภ…›ปXฅ๖Jถีฏ๖@Nญ†*žป~5๓ย็:ภกฆp๎Oึsส๖ๅ7ฏฤี;C›พ:Z{“K˜(;า&iW๋’Œ”ํๆcํjUouJH!kืE๓ญ๔๎2ฒเN๐’Œศ L%ฃ๘Y.V ํ0‚ืฎๆY้—๊›cˆซgฯ)เŒUkยtŽฮจ๚ร<ำรu“จ้Š1ฌฟdร5ฅLว :l๘;šฮBd0ฮ4‡ขD8า๔m]k:t4R8๓ฉˆร$น6w’a1๊๑คอw\:ซPถ•u7ชฌ8Xป;d0—ว‚CMณัhc˜-6 ณลf6ฏE†๐B“—ฯ๔e!ฦพฮขขหujย.\‘่ห ิฒ–sEต#„/ุฏญฒวฒหฏ๒3ล='ีt‹’อ0บฦY”๎ฯ6vžปtMM€8๙ัี,่ฟ๖฿ก๚%t๓ณCฝZšŠU$›’ุMGฏˆูs#|Xจฑท๙b^aฃŠ@ธแ ฯ‹๔aเฺ๎k็ฯ•w!d๑C1๊"[๘lfm~ #ฏ#๗วK=โ…๗-ะŸซโฯฯ a;JNๅึซ๐[x฿ฦ&๔–~7T ฦญ}pQะ Wk๑ไIœ$‰dามgล ฺชฏ๒f ]ฉ1็,['dะ่ณF๔W|บ^8t‰CYฆฮฒำgฎ๕ใŽoีฉง;&u{๓ตสNupถŸทk!ภ`<ฏV๓R‡โฉ่7๚q@A ๒ึ)47/แ3Ÿi1Zศ€h]์ดHห-ƒฯฺๆ:CQrจ้นน[\kบ๕>๓๑iz‡Irm๎P“„ไv JNคิTตYิญ—ฎv›eˆEfนยเLS[sฮœv๗ป๏pkxว๑‚Vซ3ดเล™๎โณ{พ;}ฌำk้œ ะ‚ฒ3y…g>ู›w^ผ&eเณ๎วา็–๕๘ฬŽยฎ”_ƒ€0/เว!๕{๗ก›$F ง๊฿_๘๛ษfHGึถƒ_๘๛—…:ƒกพตwฃ4กGg.๒‘ๅ๏๒‹๏r: ็Gา€•™-’ๆ~ๅW.่b–อ๑DฬัKผ3’ฐŠs๕Dx0ััhๅมฏพ>ฺฬฯœ„@๗๙ฏ๖์ูs๘ฺจ๎Kํ๑={๖์ูณ็‹ำzmSน3ูอ๑Šฬ ๎/ญ๎sณn87n^ขแโฏพ๏ส~อๅƒง๋ํ}ไ‚ุXZีแฏพ:ึ์5/-pz3ฬ\,ชๆึฅล!โ9?จยีQ๑4H{l~>l/‘ฟF5ใชRผ˜ปvญูOึฟfNฒ›MO™ป™m]fณ๖ฮSnฑuu˜-.‚0%‡šž›ปลตฆ[๏ใ0Ÿฆ็q˜$ืๆ5IHnจกqšฺฝ}รZฺู๚๊ฯ/์ฦi2#d ฺr6k1แฌEKf+~ธ sต๕โy๋ป eF+€ฌถ๒ค‚€_ค“สMV€–6%…ว†^่’ส-V_KO›มcA†MฉฺK›4f…ฌŸเฐaxษGะ#็ฅHสพ๎rZฃน ๑ umคz+€jan‚ฯ[ื^*3Zฺ›ปฐ9"t2I—ีlํ“t่-‘VŒeฒฒพผพ฿ะ+•A<tธตม[˜ๅื~vŸฤ์J‹d2กวค†[k M0หตขIฃ6 aˆ}xPkoGWึ–]๋5˜บzlA\€ำ›แŽ€fซ-l2AโHฑNAŽ กšปk,Q>ท*qใกท๖( Aิ์๕๓ร[5ช'จ9ฆEAc,8yวติš OบL<%Gšc0w‡kM‡ŽF วa>>Mฯโ0Iฎอk’ฬxะ€ะ e๋ล‘rsํ๑=ต(ฝrrไt“ม‘&58&ฌฏ๖ŒTIhชšSwD๛]9"N ด๐Yิ-ƒB‚จoเŽขฎห-ฤเ‚ธ๎๚c†ฆ.už8,ฟณ ถ†แ๘@<อ}ํm7qว\™ ˆกuไˆEYโๆณ๛ปnhา%™*(โุtฏŽœB=*ก้๎-ฺนkฎูฌ•žz,G^bAฆ0ฑ3Š86Krๆ๑Twtsึฦš*Nšัจ[“ถqb3kgcชk%๒xž7€ใZ็šc`ZิผKฒ่ฆjuq๛ฤหe,^D7ปยP”๚้4=7wdืšŽร!“ &‰ผ?In#Dฆฎjีภ_4๏ˆ0jw}ทp“ฒญห์MํŽ41 #FG0ฬ้ื'๐กB?Ba2ณมb)Dtจ.แAqีเ f๐๒ ฏ†2ษิ๗€ใ8Š”*“˜ f|คEักบ„kPตนr๔ข…ยฆœ\ฒ๖p3๘‹9ๆ–ŸD-่S๛}ตƒฎ8v\fP๛/NY5่ฑ"๐๓แp˜›wF -เs๕\ะ#้TฐMmZ$ยๅฆˆดฅฬๆCW•๖ฆ–แŸh€okGkสๆFsL‹1Tฬ7€ๆรพณ+วิM†ขไPำssทธึt๋}ๆใำ๔< Ly’>ฐ}}™ ๙ะD‚ตpA‚„๊(Pฉ4N4}}Fฟ๐H.AhยจPa_Ÿำฅ<4j7Nฬ  A๔๛ณƒBqดˆ†Q˜a!"[ฟสี$›…"(#,Dd้S9WรŒŸŸ$lนt^ๆf|๘mˆชฏํวข 4^๒+ขยเHFa‡๛ใ}}ฎ†$ัyB6† ฌเpซBกwชวŽษฮไ7žป(ฝำชhท๙ๅœฟ=๑ท‡?๖ิ๙[}a‡•ภPŒษba(Šขwz'ƒ ไUg>๙๎ศ'฿๙ไปำ็{l๕G๖ฦ—ื.lฺุDท#N Š faฦ๐‹)”ƒkฒrSณ2–-ศ\†นำœำขกW๗g:˜q๓V&—~ฯ๔ฎ‚0%Gšc0w‡kM‡ŽF วa>>Mฯ2ม$‘๗'ษm๊ใ#T๕๖อ––ฒ aKVLG,eWeมี~'š ซ8W›น้ln์๏,-ฌqบT‰ฉ=ฟDฐ|มฒŸฒP“JVRาฆ W.Z™ฮ 4=ญ'‹\nปHgญ]ท†jUu7/๎€แ๕—ุฝีŸkTSฤ1A4>d?pงญฟdj(.๔Yดx๛n6fVv\*จืล‹—฿•ยฤuตน็\ฎ๗Iฬุผ{)ีข๎ช>Sะ ร๋/๕X(.|๛c•†B็มฆ‡f๋/MKิ๕ๅส-;žธE#ญฬ=]yว< >ูๆลQ`ั†ฐึๆŸศ—::9มŒญrYฺk๒R—oXวฦฌšฎณล-ƒ๕KSŸBg`Zz4ธ;อ‰เj’i‡>oอTฏญTำๆฆำ,๕ฺJ้ˆแ4lบกCsg jNะ‘[๓q8rฉหน‰kฆั3q๒ฃฦฝG๊U๎UIฦ‹฿ย๛hpyยc In9X๘๒๛c%_Ÿจ3`‚ด๋่%_w฿๊tn0#gวGXฺฯUkƒS"ญํ็ช–)N[ฎ๛HM‹๑K$ž@ง„E3B๘ะฐp๛มH š{๎ศ!tไึ|ŽdJsDBBBBBrซฐ๕472า๎บ๏{๎น็ž{๎ZฎซฌwูฝG2.hโ๘.h>ม๖ƒ)ฮศ‡Šฐู(aด้m‹‚ัฆทŒ๚ีะกนสญkอ :rk>Gn2u9"๛H\C๖? tƒN˜5œฦdะมฌ1X‰)N[ฦฐ4ษด't๛$ABฏนaถ ๎Hุ่sGŽ#ทๆใqไ. Sš#’คื—z7๔ฆ)ฮศ๑K$$$$$$$$$$$žBึHHHHHHHHHHH<…ฌ?ฬ8^™ห็ขภๆฮทŒ L \‘มๅธ5๗‘c&่ศ๙8น ศิๆˆฤฆฟ/๏V'bช  „ิ[’›9aฦภdฦ% urู%#+6Ihห.uŽ’๕Ž&3ฌ•ฅว๋๚™wบศภๆน3‡#ท™ฺ ๖ฌป๗s‚˜&้•cพ๓ฏขžแไ„=๐ูž|~ๅ›E@ ^๑ิ -๓กhZKพ~๗ญ}ตNIฮ~๎่?6rq7keตง>๘ใ฿๒]-๚ภ็วหึฟUyšb๏m'ๆณm๏”})ิgมof~ี๗ณภˆู๚า ป3ยxxSษ—๏ฝsฐ๑ถฉโŸ|๒ร“ #g^ษz5^๊C/?ป%ลวฺyแ๏i_ฝณฏf?w๔)้ฯJภHx“7|๓ุซนฝ;๕้CŠ๗wฝrฺพze๒3‡ž้yมฏฦปฌ=7ํ{~ฦ๙แต฿]ํjฟฎษ&JYบ ๓าcฝจVผ้RษeฉaR3&J9K์\หิ‡๐vƒณjฐ๊ว’ng๎๖น๚Sวฎ:šcฒM๏sŽ฿Œišใวkฆร]G๗Ž]ฎ,ฉ@”xฯาPฦเtZsห…ฏ.๕:ทพS%ต8d8Jญฟ)๏„–’2'ุ‹E!ฬฺบห—+{,5}’—ฎSไพ"!€”v๗Gn2ต9บภ๘xmMหnๆA๊มว6”2g์o๏ดbํ%ŸOมฺ_ํbuU'ทฟ„่๘ฏw=#มb๙๋_Yv๚นใNO๘ษ=~%กๆ=๑๏w็ๅฟW้i’ใฟj๎‡ๅใx็ Qฝ๗b๐ว๏Qb๐๐ไใyฟษ/Zั๐]o๐ิ๚ย_่๐ซจ8ถs4๛1c๎ฏตฝฎ‹ž~}A๓kฟVวฬ|๚๘ะ•ป?จsS๒เ-|๖ ส^,wะMwG๊1TLฺา๗}9ฏ๎๎z์Ÿ๏ผชx๘๙“Sธp"72s~‚?ึ+Yุกงg(‹ŽŸ๏ฃค/หJ’.๏#<2#ำำ˜ํงิช^โ•้‘’ำ๕๕FDZ๔็_JŸฺi“ คญhOีษvฃ Œ—‹ฏ? ๖†9cฮฃ†๛ˆ—"€–”Wu๔๑f pๅฃ‡W„๛dX๛K/ี{ญ๓ฅPึผwtห…?฿+€ˆว๗Wึ;[ฆ}่_<๐aแNhhืƒ_I๕ฯ~๒ลวWฦ๑ญๅ฿พ๗๖7WFถaญ^#<ฮe{ŒX‰ป^yน! MKษก๔uQงใ{<ฒ๎ฆ๚ฯ๎%ƒEM!งไฑzต ฎ \ถ=(ภa7({์%Y$โก‰ล~Mi‹ณ›nพคะไ|s๊‘ทฒ#?จkp ฤใ+ฯ|ๆ‰J@๒3‡>&ด็:ฏ^9BOดไทo=ฟงฟ๘ƒ—^=า†C๒3‡ž้}ใ›ะ_=นPิ_มo_?ฺ;ฯปฺง:๖ีซbN}R?e๋๏๛;›สฏu๔๛/  }ƒƒU?t,`hปึš’ฬ/๏๋๗\ศfPป[š๛ฬ6€>‰Lหๅ(~ษษผึKuL>ะ๙†ผฎYe&z›;๔๑พ่่q˜N๏„ษฆ๓์9Ib–นทฒดฒ^M œ€๘ฬDo:ก๋m/-o”™a๛วe&๚‹˜ˆ`ฃZ์ื‚ํ—9ห฿›Fhญฅๅ-rฒšโnxณตคg๘ฎc†ฬฯžส2J+ ”ย ™›9;Tศภu=๕‹ฎศL˜yW„ถฬ”ฤl*nโอNwฏRเ;xฮูa \ื]SZR#7;sD๗K^˜%`P้‹Fจฎสoโฯ>ืPTใ•6'ˆe๊ถ{wโศiโฏƒถxGl๗ม“uคnZ‚Xฎช(~มผ?.ลฌ๊jฌชธึฉต น๓RCผYˆฉฟฝฒธดUํ8๏ู1AฏทQญ๖๕•]ๆ}ฝO “บฃตฆชS˜ๅ็=๛Iบท ‹ง™ญ8ˆูŠ›MfWจท฿ ๆ€‚(ิ๗Nฦถฬ7฿Mว~นษฆึiส<_~ตบ‚šc€ำ=c‰w?žธ-‘B๑ฝ๖ƒQPfmI|b—ุ้ปgศsGŽ™ #wๆใpไ6 S›ฃั๘mฝ’ถcw6ำ•–$๏฿๛*u•—0'F[[o’ัะปตไ๊GŸ^๚r๑x<+%๊๎ทพ:|๊ฤŸผธ:ิƒT`๔ดˆถบF€ฎธฐ26#ƒเ›‘แuพ š€ๆฯ๎ษสบwOฃ|๏ใYYYYY๖q;œUOฟœXฺOึnx๔sรO^} ~ไ)#ืฌฆ:Ycส๛ny๊~|ฏถoธู๋Oชๆ&บœหB]ธ2ป>'ทoXRษƒ/R ผศoฅJ้ฬv่w๏ ฆะ<1ก›“x๋w๋Cไ=r—ฆQ๗๑Aห‡ฟ_๋@ฯIี_6eee=C฿uŠม๋vžy๙๛X๕ไ๎y˜]ถf5ๅหŸoไนฐ'ศ@]็ฏหษEืฌŽs—› `้ko๎T.LำY,Bฏท๙ฬสฮŒ๔า๋๕,k,BP\>–ืhฏฆั๙<ฆษh‡๐โำBU๒กข…Yฏณy๛๛ำ”เหนuะxFQZOฯอ้dอ‰ฃ@๕OŸํีsฉ`๏๑โ Cภข8ีnO^^๘ัผfํ€/ช9|yY๗ว‹ฏXCณboy3“?< miฎ{Eฦ๓: -’๑็$ก@ Ÿ3_ ;h฿๚ˆฌ1 "–ฎดผKV5!^ด๐๔L‘โมฝ๛N\ฑฦ-œๅํิ'jvฌ๑๒แ๛พ?Zญิ];™฿dฟ-๙‘Q”šำ๛8ำฮ3+uๆศYโoภฺีู#๐๗งฐฉฝภŽNŸEิ>ฐP๎e9OD…l %G๗๏=TะษฯH ฅ:ห;-<}พทผ่๐ฝ‡๒๋Uwหผยก๗ bQตด๖(oฌ'sฃ7oYฝ{๓๒หRใ˜S๓Iบ3nิ†M+๏ูธl’ไ8> oอ-ณฆฌYy๗ฦ•ๅงหeVgšF™ยๆ+bqE~:๙-E7N่ a0ูผ#งzzƒ5aอฑ@๖?ฬLฆ๖Iƒƒู$ฑŒืH5อ4“ำ„‡ฬ=wไ˜ :rg>Gn2ต9 %๙ป“1๎ฒ[๖ไ}ำ้J—ณ๑/ฬ37{๓ู?_ถืr‡๙ซวrTฐ}P Aฦ์ห“ฟ๙Gf๒c๏พ๕๋ตฅOพพ์;Dไc_ๆ>š๗>›Uั๙š_ฮMง=วš—p~๏eงนŽŽVTฃรA—{๚าห๗ล๑กfฐdŸฐf•้ฤsMกJๅz{sฮๆ’ฝo—ธŽˆO` ฎu๏uUš_ฺ๊k–/[ัเ;\ŸXู–tูmwOงำญV+U3;…ๅe‘Xhtบ ำจGˆj๙ฯ9rท]]'๖|]ฺะ‘w,H €ถc9ฺขhฌธ6ะGไ2๏m-ญขTจน™อๅ†Žฒ„พb ืเ†E€ฑ}รฃ"BCyฦ†โF5#|vฌํ๊‰6ฤ:"บช/สgm๛ aึ๗4ษ5ฎ?Ie‹ฺ ะงPฺฤL&€Žใ%4ศห๛ฬ6IW็ล„~ร Pฉ m„/กA^ัo%ภฺ.้]รc€ส8U๑›้ˆ"ยm-็F<`ฺๆŠ+jU{žสa่ธกพณBaฒฉณ]†% ˜ะ@ศฅVk€U)•ฌกV”‰pBCgeฏ…K{kwfขฝ&‡ŽLZญ…  too.4ฺnU• f€>™ยๆฯa8vไ,๑7b–Hiพhs5ภŸำU;ุUา˜L*ขUvี–tู%\@฿Yัcฐ๔ึ]8ฏDp”wƒ—@h่ฌP˜p•rฐ๏ภQ™I๋W'Œl้นt0ทัก๗ฉ ฏเ๑f ?๑xเ฿าAศ/Ÿไ>_ซค๒์—๘0งอy6…กZ5jผ);ใื{^Ÿ฿yd๏๘ธจฎืmY›ณ`~Gมว๖ฟLf3†aบœ—ืๆpทR,fWUัฦ=/œศ|๑ูง~ตทรuฯfณ P(๏ลกมb8….๓nQซŒBกภ๑จžฉมfรตดๅ๏m E#6›m,B ๚งฏษ ะ6ีีVv๖pฬ7%…ื\ฏัFจ›ฯn)ก`ธีJY‘(v•,b๘€฿ั’0 IDAT@E‡F฿แŽข่uย!Pe‡,]แ‚Y๕*ฒ›ˆOxจฉๅ๔ศ Œ'ใ (:$ฤ๑ศ;EQvฬ’a8 ซถwจqƒ#ผ_8oร–‹Y/ปxฑ{P<| {โ`”HTI>ะล๔J[ป ]CiนWZฦšDฎ้iปZ^ัชยEQxส-สN‰๓ผ##„.๓ฎฎ;wฌudดlFแศ๛T€[tบื‹ถกซ7ฦ‹เdf$\Ž™ nั้ฃิุีํ%0๙…จ;ฮษu€ถ^šผ2ะ๗ŠR๊Hำ ๎์aฏˆ6Wๅ˜ัˆ[•๑`รqA,’Š๏%ิวN๒๔Xs,๕‡Oฐz9฿Xั–ืห[น‚oฎhหkตPฤขะ4š๒ิ™~วณB‡ฬ[ฝ๊hNะ‘;๓q8rฉอั0ก›ถฆุ ๛`ึโmห>พxาแว‘ฝt๛ส๑Jaัด^๊v~<ไ๔fdˆ>ส5 ”Z๗ูฝtชˆ_แbฎ sOqYำ›‹b่ะb‚ฎย๓๏gฤฅ “* ฿.๋โŽ"#ฟŒVซต๛g๘โ†สœ5KบN>$–่๋ผไ z…ฆํz้6V>ƒำIร*ตŠรแŽ0ฒvl้๙็†็Ž๘!dG.^งฟt๚โจ๙qiณ5e๛—FRหๅ‘ˆ  ‘OOU,lm฿ฝ๖I๚'ฏ?r๙ง{๊=๊ P(๋๕šรBWyว8\†Ru“';š๔z„ษคX€ลb้๕๚ฑ)Aฑ1๚๒}นM#Cฮ๐gqุซ๏ร&พื๛สแ#๕ิ๐ฌปนวLรd[ŸŽใ2P†Aว ˆ‘BdHSz๖l๓คอoฟmA"Bด-วŒู&FFQัyคฆฆ6๗่ี"ฝ#Vไฮ{๓&าำๆ8๑T~pจทตปU:4ง@/้4,๗๗3}ไ’โกฅฏก$งPš—o|f๖ผ(ูฉzรจlR 0,ธรผ8ฬปYงq0 ย‘๗ ยœะ”ŒึSuรogU€ษธ3NH๒|FkNฝ€๘VขJ 5Lข˜M@z:ปzูๆ„อจZ–ษ`Bฏt&e0Mฟงz๙†๒ญ2Iฏ}เ„ อ @6์ฬhด€`Ž/๊เม(PŽ/'ฤŸFsl<ยsGŽ™ #wๆใpไ6 S›ฃaฺ๛่สaึึqๅlกซ๓ิึx. (3(+=ผSา P๛ัŽฌ6ตาp๙ฌŸต™ซสkgoุรc0|3vฎ จบ์jฎ๐@~‹2b๚บฅ๖–๙ถ๓…ถŒทฯฎ)(QเStหธษ Rฤ|QH€ŽฆfŸู๓ƒ้๔ˆํฟ{๛ฤQฝิ๙ซณOๆ QFBท?๔†ู!BŠE%—ซmฎชU=าn^p{Xภ๕โ™ๅrGญhก;ๆ๓ฟ}้•ฃฦี‹g%zืิ4I”Fmพ'Uศb-ฝk–—฿tใ™FBHฟ๙—Žuฏ=1วๅ€Oถ_ŠRE –ฮ65ิไ–.ฆกT๏ฬ%ฉฦบบ^wy Tษบ=š7ฉศ$‚จ1“Jๅ†ฤ…!สฑitบMoธฎŒิ[qเ๋~(๋ฑ6Ÿ๛๚H•0฿ุ๙้๑b:Fแล…1eฒฑMฟำi•,Qจ€†aŒภ!ฎึ่@งำฐฝƒ๙t&ื75ฦgเ–ำj• ๏€๑#’G๓g๚‹ฉ ๊oisWvU+•์€Po:Fa„ˆqeฟำขƒZฉd๙xa?6sq‚uโE1“‰!2Tžœฤ๓โfฯ›ฟtnุˆฆMญDb๓Ÿใ/้( ๓b็ฅG๚z1Pd0˜‰แl†‹™J๕Šสฺธ(œ๎,๏Zญ–ใ,d2y!)‰Tืyฟ‡ง#N  `b(F‡๛ ๚”ฮ&ŠLยๅ˜ฑqŠX =J>แ~‚>U€Iฅ1y๛…ณ0กB|jญา‰ฆBัpขจอณQำ …Lย J๐ฆSฉฌจคK6˜N\๚์๙i้้A˜;อ‰@๖?ฬไฒฯั8 ๛bเ`$ึชีี.6๗‘C&่ศ๙xน ศิๆhฮํ๙g๖+๏p่๛ฺ/}๑ฮVgชา๚{่‹o๏1.ฏ>๑ว?ๅธjŽ๚๙ท…?',บพŽหGฺฺก๎yแ}฿~cไงฺ๛๏dฟ๚ึ7;iบ๒๔ูCš๛หฌ฿ๅ‡ว๘˜ก๋โWoLภc,\yํไ,*๖ื6P~โ_{c๊ฦ‚฿=โt>˜ŠrKŸ\ผuโิ@กAๆฺ๗ ืiุwue๋5‰Jจฏ๋YšฅฤวGท55 7ฌฮ๕๕่—๓฿"‹คไ๋W>wทx+๔็้อนŸ๎น์‡_ห\ เยŸC;๙Fฺr๒๓‹?{โณรพLsgลพ฿ฟ}yเZsำ๘ศXFI๙wฏผSE ฎ๒ด8›{๖ŸW&gฬษาH{ygษฝ`iสพคซฝฌH0?cVฎ้บVpฉซวBJฤา{‡{ํ พ.lw่\Wwกฬ{~ึๆTซถงฉฐdŒ‹ทš;ห*๙™sอขบ^Iay€ฉ๋rƒ_VVvผบต ก'ฺ>ูยาYVลŸฟ`I ฑ๊Wห5“ัี~B ่m)s dnพT*šฟhS"ะษฮ;฿ฦ|้ขhาญษ ิช•^+QโNi›ฏจึn• „E+ปz>๏๊˜V.v’xฃJก11,ฝ๊‘ื\)‘ะ’ue฿ †~49m้l/&j๊๏(/m2ุม{๕;XจE-ญบ0(ผ1๏ฦๆสkมY+6ลฉj ฎJข“\ๅฝOŸE[2b์vึ๚hฐึœ,่ฌ/๒KสZต’…ูt}า๓eํฮึ๘ๅ˜นXปJf-Xฑœ‰ูt}ล—ฺuะTะš4w้ฒ…ยค‘_ชhื€#อัญJ3ญ๒e••]๒สL]ธkdอuCKฒšUzฺงรiNdไ";ถผน๏ภห“pV’)€๋••้eพึUชไ,\เeนึU*5\'8= ‘ช.,V;๎ฬ2—ธ+oนัœ #wๆใpไ6 S—ฃธธธฺฺZ7น•PจT‚ๆป๘ืo-?‹—sวพด5g๕฿eๅlๅฬ๘็ฏาRŸ๙๚w๔ฟ>๒vัฬZฦ|l›สก›x}๑ใ?๛~ดพร;ฤแ›๖ลu๋9vl้%นร …/ิz  m6‚ฃ#4$kgค๔‡\{ฝๅ%ญZN/กl ๓~nZโ๏&~9H<. Xๅญ]F^pฐภ&oํRฆD8mน๎#EŽ_š10˜ั๑‚0 tf”`จ Lษtบคโน็Ž3AG๎ฬวแศm@ฆ6Gำ๖๒7Nไ๘ทช:Žสoู๊ไโ“…Zฦ\๙ม๓_pŸ๘๔ร{nืq(O็Ÿ[฿}e๏xwฐ&!#๔pŸฎษิ—ฟ8ยํญ๔คMทmบu๋ึอKC๔W›ฦด3๒MKม„/‰G`lŸ‰…%ดL‘pฆ@๖?ฬ0ŒรฦฃYgล8Œ0šuฃ-ำX4bำ๊lŽ๛†ฬ]l๕ๅ™ๆน1‡#ท™บM๛‡i]œ W๊oฯ&1FP|ฐถพA้ แˆ์ !!!น @0BXM|๐ภ65ยiหu)rรŒมfำtl Œยฌ7ปชุ[Cs‚Ž˜ว‘ป€LqŽH<ภิsฅVงaส0JjOk'!!!!™ฑ6ณi ศ1x05ย™ยL“ABBBBBBBBBBrk ๋$$$$$$$$$$$žBึf <ฟ•[Sฒร1๐๒[a?พ(er?/ทๆž;rฬน3‡#ท™ฺ‘xย๔๗ๅ๊DLTกŸzซABBBBBrณ ๋3ถ u^X‚&?ล~0 ฬ7>l~2฿้YCๆž;rฬน3‡#ท™ฺ๖๚?็็็็็็ฺŽ>Ÿ1igŸ~ > ž๚๘๋ฟ์Œ !ย๕ำONŸ~yKปไg ฤวฃ9เ•|ฯŸp"็ิมฏุ\oง๋U$๊วย“ฟอฤห฿ฮ-ไnŸw๋ฤฑ?ฎช1&?s่๓๛‚ฦŸAnฺ/๖๏{gฑซB˜QKทb^ ฦ˜ทlฆ-[6ฎ]:7ยพWยJ]ฒfใๆญ[7ญ_™• ถ๏ญˆr‚ggฏูธeหฆuห็E \?์๘E‹R„“œvX๚ๆUI!ใฌซMI’ฆŒศล๋็ˆ'๗c>|NQ๊๚ฑG:์จ%›6ฮ ๖`3ะ๋ฯ96ธq+ึฅˆFœ'ษ3จ1™+ึoฒyรชฌ$ฆG6Sdฯ@ผขๆm_ฟtฎ๘๘žฉbืฏ[พmํภฟณ์=ส๑ห^ฒxหš%๋ฒ’"y(ใm_•เg_ ษ?e๋บน1žำš rู๗ท;bav๖ๆีY+f๓'gๆ39zฦะำ๔้๛ธฦ–ๆผ/ม5ืmdน™fิ์tีถ!sฯ9f‚Ž™ร‘€LmŽn 0>^[Sใbณั็ฒยXw˜ฉ Qฝ๗b๐ว๏QbZา‹๗ฬฃี]qพี0-Ÿ๎฿ถ‘’ค‡_฿E์yj็้.jไŽื฿x2k๗ซฮ๖ำล™้‰P\…ฅfคbxวผ;๏ฃ?๕*ิใฮำu๔ๅผบป๋ฑพ๓ชโแ็ONm›ŒญEว:ส?฿ิล‘*`„ฅ$1บ๒Nไiฏ่ฬล)ก]yอFฏ๐ฤ }๕้|‰ ๅD.XุุำbfEฆ'3 Nžื!„ฌฌ„ ษ๙ถ›ผูถพป๑’ั&ฦuท=์v็น{rN๒9๕ีๅซร๕0ฆ$ใ‚™‡ถไmึaณฒ$ส—uปN๋ึ%žๆŸAัOฦuwšๆำ-š‘fPzฝฝด่ผแวฬฮŠ๑•\” }๙ะ๘๘๐ย้ๆ์ำv@zrจช้u{{`โ”ู"Uล…R5ๆ—˜6?Zuฒfโ[ศ‘๕‡ƒอชQแ`%€<aาm€;}ฝูZCs‚Ž™ร‘€LmŽฎƒ‘๙ะŸ)}j๗งMc~:ั€ฅฟ~้หใถ๎ส๒ๆgๅJ{ฃ๗oB๕ไBQ๑ฟ}h‡=กผ%/๎y.K่w|\9—m`dปM๕Ÿ?J }ลG?๘:ฟq{‹ขว~:~T”๐๒พใ- ๆxž์๎91PP้Dนฎถ7=# ชธ‰’:๛ฆสษƒ๛O7~ด+ฏ^9ฌ‹ˆ–๖ญ็—๛๔๐าซGฺp'‘g%๎zๅ๙{็†04-%‡ัืE๖า“ฺง:๖ีซbN}R?‰;•O&„ีdXp฿+>J(ปzQ lUช4๚ปไ๚Hภh1™pšลŠAXฌธลdฦ0‘@ั–ง6ฝWฮt๎ศ+fมชh@ๆŠhP7ž(hีย๒‹I๓ะqฝขฝผชญืดจ๙ ]Wm!q!lKWuEiงั?eiจพ๗ gด_kแF' zK ›๚ฑ2ƒ๖ณuk๊-ยุ ‰ๆ‹อ์ไฆฅ๗๊ฅ+M€ๆ—”ยc‚QัV[Zืgrž$ถlzœฏF่๚$—›ๅfวIšชK2)pBBๅ @”บ>ี—SงŸู“tgฮึ๋"Œž›๋หลฬjYหต+๕R €™ฝZะQ†‡งs,าสยาvฝใs#pNfZ0ร$ฝR\ฺช!@”บ~q$Tี';•—C”บ>ีXVฯMN`Xzฎ—4,ข\ŸNปฆ?ร}ฅ่bซ– †..;qฎั^‰ซQส^6'ฌZฯXผ=ส๎ฮžปแ$u_-นะฌ&v`๊œค !ะ+š*สjไ&'IB4าซŠv•ซขป9 70๗Až"0qlคWg]#7ัๅ๐Oบ8anjNฅcUีž,iๅ9ศป๚ๆPe[@<ฃตฌ•;+Q$+={ญ๏ึW้n˜@(่๋สำX€ฺ ๖7@ฉ2‹}ุะO๕ๅ”ใู&้ึaาvw4ิuk2|๘ฎ5ฝ}5GzM€Žฆ๎ฤt^Zฺ้ฤ=ไ๘ฅƒ์ำฏฏd. ฤ1OฺFAหxhฟŠ๑uk๎น#วLะ‘;๓q8rฉอัh6๎^ษฑ;{์ œUOฝS๑๚=๋7>๖/๙š?<’:04'lอjส—?฿ธ๙ษsaO<1๘ศ๒รโxจุถโป…Pฎฬฎฯษํ–่๊rตy๘š}`ฯ‰'Ž๘ๆฃ฿ma€Z&3ลeฬๅกT฿๙sย๘|๏อ ฬs3ฤกฉ’าr{%ซ๊/›ฒฒฒก๏:ีเu;ฯผ|,zr๗ผก97FwหS๗ใ๛ต}ร]ฯ~Rๅ77qฤ ผ.']ณ:ฮณŒJP฿˜(ดฅ^j่ฝšSิb/ ำx^ “ู๚ฦ’2KšM7nZ(=_i ั่ส‹ฮ\นa๓ฆuหๆ„r~<ิ๕E๛Ž_U›Šs๖อูWะชช฿์^oๅ๙CงJkl!๓ข†Fa"ึPRpฌJ็แว@ผ™ฦ๒kฝธPดแjˆ8}uGŽๆ์+๎ธพ,ฯ งดๅๅไ็KYษั>(โ1วGu๑\‘ยKp| ฿U’R“น๒สโC9ฅWŒ๓bฮ“4}แ…„`ํํื฿ฯ#aEคฤMyวŽœ,ผช`‰ฝ‡Z )>bJCฑใๅjฟ˜เ‘ูผœœฐ(ถค๘๔้‹=”8_•G๗๏฿Ÿืtๅ๐ ฃ4ไ=Z a'ว๛ฃ.ฮษ A๋rอ—x%ว๙"ฉT!๐๕ฅฐ|}iาฎ^๕ตS๛๗Ÿบช24ๆํ฿ฟมสpยขฝบ.ไœ.“๓’ใP †คฬแ+.ž:|๔์ChF‚ศi’ดืš@้Bพฅ_้ถอ}ง„š์งบา tSยg‡'EšชO=|่tญZW—[าjoฎqp9!S_QีอŸึ–ตB wสsqkเ„/[ตdำสEซ3#ผ0 ัจส‰Nหฐjษบ… กœฌIฎฐ‰ผ™กHื+Ÿฆ?Nฐช%…ฦƒmi ธ0<3%€k4๔ษฅE๖?ฬŒšฆZ™A‰ƒI\+3^Bม•ํฒบึiKูน็Ž3AG๎ฬวแศm@ฆ6G#ก$฿{w2ภ]ถ{หžผo:=0&8:Z^๔aตาp>ท‚Hด7T* ํุŽถ่+ฎ? ๖†9@ื~ฅฏสŸ &>บึฝใk่จ๙๗ฃw}ƒส ู๐โ›ฯm)y์[iษ็๏Wฟ๓วƒงljyีฑช.`ธุฐ้.ฝภ~`rถ๖ยวฦ-s]๙๊:ฑ็๋า€Žผห๘cAB98Š<Š Tฎท7้l.ู๛vษ่sดตดŠVRกfzฏก„j[OฐรX>!แกAA~^ฦๆ‹-Z ฅฆ๒บ.ไv๊Qฏจ9้qส3Wz๓โ๙yว/RD‰ 3SCe-ch™gsyFลฅ•ซคณon”ิ&›B"ีX”ส>Š yŸี๊mี๔สLึ`สpัฮฅ้ฌnำ˜ฬ •Mฤ`่{๋OƒลŠƒนWกบจ_ณน<ƒขช฿lJ๛ฑ๚ Ž“4m†„ฺุฮป- ‚า *่ิ—บ‡ๅVy{›ฦ ะง่ณa#ฒyร9umW๋eZm—‚pZฏnนฺฌ4˜{๚lพlภ`ร ็ิดึดชญ*y1‹ร0˜ฅาพ$ฑmํค๘๚ฒค We9][uT ๎TเณX =—ว7Hฏ๔šlR‰Kเ3@atš$jxึฆ4_›ชญฌฐ\แ๎๎IงZh|0Tฺa†(ืŠfฮ๊…‚ tก€-๖ฯย y ze=VซŸU%“ญAVฬีร5sQ5Ÿ=ื†Bแ'd&สฮทใ˜7/);~ลคf&ศ.tze”ˆ0ŠEัh น'H`Šสเ๚)4Bฃุdผึศ๚รŒกO๒ร็๖๒’?ฟqฤผต๖D‰ซ‡อ=wไ :rg>G๎2ต9`๕๋ํณ˜ะธ]๗ฮ๗๎ลฑ”$ฉTŠอ60ษjตR)ำD‰มฯ(Nเสะ#ซi.8ั<†ำ฿„กZ5ฮฏE#˜ฃ {บaWt8€๏8๑ฺฝงfาl#{๋฿๏Kqู`ิpแbศŸw๕๗!%m‹K_C‘ทูlCAพ1๒าAศ/Ÿไ>_ซค๒์—๘0งm๘[ิ*ฃP(˜ึปl#b_mW๕`นŽ๊›บtžŸฎตกนดZฺoฤ(~ก๊– r  ซ—ฤญ ]้ี=-MJ3fYcปf…cฉ? ส Zธุต๊Uื—[ ํEฌญเ€โ™ฮEqจL—ืEPb๐8ขืืE“4mAD!มๆถ<K%}SลNา์ฅฑ,B+—ิU]้ะŒ.0๋ s]žsd”ขไ`Xัe: 8งA*ีฦ๙z# _พฌฝวๅ“=2IvG(ŠŒพš7ŒG&ษาRธฟฅqCๆdฮC๒Š;\tAxไ)๓ŽLเt]ธdpื๙M่*Aฺชตณ,ฝผขยมM?๊rเƒaเอฌoํV†sฝ”„ขณIm!ภ"k๋ึ,โ๑ ำ •)X รอต…f4ไVฆz๊ภqAKWีก.j‚ใ“1่๙ถฌzžx‡์|tม†8 ‚wุFA‰_ฟเงƒŽG˜{๎ศ1tไฮ|าM^’#CฬืmาNเnสwืXp‚ะuไฬ+:™[x๘‚dŠf„2ƒฃฃญM9็ŠNๆ•ีŽบ9%i่พ@P'fึเิ'$Pื1I0œฃกผZ๛›/ๅŸ:r่Xฅ0--ๅ;ใ†sŽA“ษkใ<งN*5๙๚ DพŠ.ูฐž๋ฎฆ๓๛“ส 1pณFฺc๒๓uูๆ์a'/o+tฺ้;ึgงzcกsWฌŠqผฤ3<ลOz๖๐ัใ'OๅTthgฺ}<้ฐF v์๑0[FฟืG!ฝฝา5wฺ5Tฎ8เp1 ฅzg.I5ึี .บตw_y๕oฟY9ๆฺ›Cด›ไัยฆก;ๆ๓ฟ}้•ลฅ•=gฺt•.Lธ,ขๆZ0foแ้]ฉ|:ำ?๋ฎ•ข๒๒—'ตU๎๙ี‹๛[:g๛ ฉ(Uด`้lSC@oˆ<บ๙ง7ฬR,*น\mY–  Tษบo๒’Dc…้-d๔๕•ซi4šอ`ธnณJe๒ faBๅ…๘๓ิ*5€Mัำ/ ไำ0 ห7*„ญ่u9*อคืSEพ|&ฮeำะiU ?@ฝยDz๒ไŽA( ”!3m ‹:ะb๎(IL๏ >ร~~|\ฃ™a‹ พกช๖‘SB๔z[ภg0xมI๑ลndZJ˜—Žโfƒม์ฆlyใ9€สโะQe๘๙ุ”ส1O'w|NŽCP†_เˆsjคRย7>Jิ฿%ั>jิ๋ฉ"“ฮเrœWิชTLฟ !ร˜~"\ฅrv5 nศ์”H! „ย๑๗๕า๊\๕0ศS@mแพฃ9๛Žๆ์;š_ูkkป˜sชqJQฅ3‚ ท“˜qŠOP€˜กM,ๆฉTJ[_ฟ00า‹Ša ฿P?vŸr่ F๔5ๅ_๊˜ด๙n=์จิไ9)ณg S๊•wyฦi +(้–OF;9~iฦะU๛Kต@@ิ๕ฅ:ธพฉฬ|แ฿‡JGg›{๎ศ1tไฮ|าM^’ ๚ฏwพ‘ƒsMœดtCลช•7œ _*ฅวFช.]ู๙j•\ซ ศ˜ฟ: ณศซr [;2ท]ฎฆฯ[Kร๕ฝ-หไฮ๒hํผZ07sm ฌFMOmyฃ‹‚ฃงAพฅ่ZkิหWmIยช“ื^,ฎ๓`๔ซฌฉา'>-+›‰ู๔สžŠชN:สjXsา$า Cฟ๔โ™ 6๒31ำj_sVฯทใ็ฎkK้นKr0ซUzรึฏ|หZ{*+ธ้I๓70pmO[ษต‰/ ƒ1—นcห›๛ผ< g%™๘kW๚หซrๅ>ซW๛›หซr›Fพb)‘K’ำiางคŽ๋•CๆM๎&๋ปัœ #wๆ“ๆh๒’ไย<..ฎถึณ้ใdๆ๏AK}ๆ๋฿ั๚ศEำ}dฯhฦyิำ๛ฏ/~g฿ึwx‡8|ำพธn;วŽ?ฝ$wิฬ5วK$,ฟ2ฮ9r ิ!ะo๏ผใชฮ{%]ํi K{;{:›ณ$ŒB)›oู{JR(ซ๐…ถฬB~e}i e%ฌPBg9q์xฤ{หฒ$k๏qu๏๏ูŽ‡dษฑL์๔พ_C>:็|žs๏ีน็9E)Œซ™ทฬ๖ๆhk_ฐไUท>๐›ฅJ–ณณrsฯ}ี1t5—พฮuฆ?_๑ุฎ๐พ๑๓ุ๙— $E\†ๆ๏๖ิ+{ 3T@†$k^i–Œ‹‘^k_S]ณqx'ฆ$ษาLืฑoYกŽ๐s*V็๓๚|{ ->ky:kxu^ฐ๏๐ฎz3ฐdyๅลiR้6vึืw‰(1nr๑ผ‚d!›A=ึฦšVSฤ„คlmบใ@m๗๐๑ผฬE‹{:#ํฺ/ฮXเ?pจwฒผ†@๙ชœา์$Ž–ฮๆ–.{ฌฦรอ]Vฮj>ุ8้นw3–|มำ—ฏตงฮ”ภ•—'๓ฎ_‘ษqต์ู>zวUnฦŠUyพ๚วtแAZ|Vฑ๏เพŽhwsœ qVyYถœ‡mmU;๓œ"๓œ*?ƒภ$ล‹s“„Lส็45ี5vุINึา ‹Eฃโ่|Uื—ต3 T”RP–)ๅณจ€ำาิาใ$0IzaYบ„หym๚ฆ†Q‡ž๐ณญษๆ๔ื๎ซI๒•kีOอF 0UษฆRVKๅฑŽนs$K’Q^ –ฑ)ทฉทฎฉ฿mซ0q๎ฦล๊“Uz๗Mำ฿ข‹๖ๆ ฺช?QOฺผเ?๚๔คm๎๗ส ˜W3yB‘™ฆPฌไ JœI๑ …ับšš&9์ภฝ๓ี;!ัg;œ๘๋ึี…ฒ{ฟ| !ูอA$็~W?า€ฮผ๐ฆ๕๚ทฎพ๓Gฆู๚ืฌ^ฅ#yหฃw$}sฯ๗jฑ^~้†๕ป๘&๒ญR\่Cูธ๖‘N2๓Š?ฝzE‡oูฮ[ฟ็็Œšั‡Nตฟuๅตh’ฅwฟ๙๛ซ๗์}ฑvF ศอ(ษE{*่๕b’e‹๓อ฿คxฉๅeYrิn๘€ฒRŠฒัแฮึฝc›€€ฉŠ็+œ5•5LQผtAฎ๕ง&;1&?5?ูฒ๗.€๐2ฏฮI๎2๕Fj;๙<>Ž ๛8ฮ๒:ฆ|f๑x8šyœšฃUNŠง)\Všnฉ์œ[Šฬ\M w ูœะm[Fๅik๚๑๋&ŸU2>’W฿\็ ™ใm@ณSๆฐ๚๗ะๅEุˆ/8ล<ว9ฯ)๒3ุ9ถf~ฎฟฏล‰ณ็m(ั๔๏๏๓๕ึ|ฉš"ยlศtะ›ฒFO.สรŽ๎tƒ ฝdE~ฒhฟŸ“R’…๖T่๑b’œ๒%9ถ๏,C7”•\”†yGUH&–‹ภhCdR1BE;qV‚%—สœ ี5TQPพ0หฑปีตpu๏9ุใŠ๖ํฉ@๛sยo3Tาo5๗”P>‡ำกจUๆH๒๘…"3MกXษ&”8“โ`/ฟ๎…๎บ๚Ž)ฟฯQ๕บ{นeC$คฏ์ฅง฿=fƒฌ๋?z๏๚4€ื*/€๖7ฎธ๖-H—ๆ‰{..–‘†๚ฯ_ร[G&}ฏˆึ>๖ž/wร›ตง๚JฐxcฦฎW?อz$+เถb—'H‘!—;่ถฌาu;oํt’๕o\6๕Xqf๙’ฒ๚๗4Y‚M~๛ ”ร€QวWทฟqลžึ๑=ั„ตชบUธY‰ฤทวุA\†Kฟ;DAศ2hฃ๒๘8 ๚c_S‡!_ขŽ‰%ๅ็๑๛Ot ส“ไ)S)=1๛]G"• ษ๙8^" CA‚ $D9@ฺ๏๕ฑ’p@นล็ซvทฑXเ๑‘ภQไ–็*ฤ,สc้ซ?ั7ฒฉ[‘ฟจHมXNo์‹าwŠล"ภ{€p๔๕sำelฐ๛ฎ2ทซุผ“_XคdM-ีวzœ”ขœO#ฉสล{๗ ๒%ƒ5•ญถYผchlุ,ฆEฏuI๛ อ›สแ๘ฑฎ W•&•รลมโ@“ฒ3๚๖n~มHญhw’d\ฐ1ๅbฏ}Nน ‘ซบ,~@ืmฬ/Oด:'9L=ัะ๋ๆ ซ^๚่วฯโB๊สรฦภ๘ุฟฐ25f๒๘…"3MกXษ&”8“โีWoglฝzu'ไƒ๖]ๅีแส๓.ธ้๕มsžธaะ๙๎•Wฝ>๘ษญื~ @็]๐าฦ?๒ผ‹nxฯuƒฟ,œ<_qFกZ$ฮษOcOoNƒฆ๒๖ตoผsไ๋\ฏG่บ๎ำ๏v~;๋๛์€H$"9ฟ|ๆƒฏพ๖฿o=ผ)=jŠX,๖ปœCญ ็ฑOทํื@KVTT๚๏ศ30๑ขY=-ํ3โ<€[฿ฺm!e‰eBยn๗aะ]†ญ~Vกสึfำส็็ฎด้์ณ7ฌ]1/]„‹อŸ/$อYXžย๓๙|#Mˆ ฎ๊ใม๕›6žฝฉ"ูXUงโŒ’^/‰ณP€ข๘"‹๛ฝ^†ชคXhm8Oีmก”™รฏož*ƒ;x๔เ‘ ฟ8S†D):‹ษ$ƒฤpY,๕{jบ| eq฿\_๕žcM~ๅ‚l๑p1UiX฿=8EY2ภูQตcWU‹ำ฿uไงป~ฺnG3)ฮไณFƒ๕k'›TลI+ฮกบธ๋งช+'I2ฒ’ “%1บ็ว:งl>p 4k]AปลAส88@ไ7/ŠIq&ŸˆS4!ํ‘ษ็๙#ยฤqโvvี ž ™ตZ`ณฺCุจพฤx๒Œ‚Gา1่p๋-วu7ง‘็D;yBกฯุb#( ๚Mๅ9"ุ"๐„Bฏฑูฬ๓๒„lฐ๘]}i‹–.กm๚ว๘ำฑsz lEJJ†Zฅฺkดฃ,`คค)ฝ๛'›ญ๐x € ,ฑ˜ฝแ~tg_K#`7Yษ$.@YM!Br๚ ueœศ([–œœขR(y๎F๐{Ž‘ถ ขLF:uอ‡รs2•’ง uU๋‚ฃjE๐Z้ฉ*Œ0w…R$?ท๑ำEQŠคP6_&ฦ˜คwจ๖Žˆฃปrxํ ฦื,*R๗M{ฌ…๖ๆ ††7žn€ฦ7Ÿnœ๐ตุ<W๒๘…"2MกXษ&”8“โ’l๚๕y @ ฎธj๑๖็Lez,“ษ ฯข"‚ษˆบใทเ’วธ ›IพŽฦสุูน๏ฮ)2็ภxcฦ7ฟTpr-๎๒sWw๎๘}M 0๐๑ฟ~๏œฒืz)Š<บใำV{์UŸ์๊}ฏ8พ:)ฯแ™M๎ฏZ๗5ฬป๛‹๛Cั–ฆ@วW_๛a)V?๚หW฿๕?fฬ‡๖Uํ์C™|Mูย๙pจZฑ“ๅๅ๑ต5ีd(๔y‡Hoทฮ‘%ไุศ‚ „ฎ๚{3%ษP”˜EŠาีwฬ์ข<9ซ5า&kDึ็๓ฑ$R!รีkมหฤb |z APŽf๑  (๒:‡^u#Sศ(Švฺb‚ @…๓INFJ}~Z8—ศ&ล™|€H5๊`มษ'5{{๊›y…%+ณ9”ข๋8ัฌs๕๛ผ]‡L1ฯhŒพ›่ษ1ญา1๔HR@ภ็Gุll6๎๓๙8š๒‰1Q๒dSŒยฐh6ส๋#ำeoฏำe)yƒ'œฤฃ=|ฐ'๊(ุ่ฆ‚ม สd $€ฌlmšใ`MEQ#>2Y๒!ฃdL@ “&O~๚Adšdv฿ษv0าh?้M๖žบC=€2๙ฒฌฒฅฉ–ƒ=ัk‚ yžขiJ’รท#AyŽ@R”ปซjo{์GRิจ ‚Ž<ภ˜,+ ณบ’ฒ3y๚“๛E%ฺฮธม”i9–ฯ๗GEKๅAK๋คEeงษ •฿ค‡ใŒ“kา฿ื ŒูŽR W2ZซHย5h๕Hล`๔ษค{ๅ†แ™ส’ตขฮช๐ฆ†Vฃัฮ ฝH๒ฯnt๘Žี8ฮ๖๙Gผa_ฎ&ฝีCp’ J๑ช๎ฤฌCW-pคe92 ุ’๐‡1`Iูe๙’จำ฿F’ว/™i ลJž0กฤ™ทPฯ?nx’๓~;็ดสe E,ถb๙ฺyกŽŽแ^$“ ([Qฎ'ฅฅH1Œม`๓8(เฒา๓)<ฒ”>k’_r๚–'Ÿ์๑W๎฿฿ Ž9H๓[+†ธ๐ๅZ๏7V\nฝณรVพnC2Žขผ์ณWๅttv๊Ž5ฯ?kžˆอV.นtฃบ๎x[”<ตGส.eI›--ฝโ’๒บ=๛cึฝ(;yี’<‹~`f@P|MIqบ˜‰ยเ)“๘OดF…ฝ๙วCะhi์๊ PŒค””$6†bธ85Yhณูภฌ7ำฒฅ8ƒมKฮTฃzฝ bฬ€ำชิ ARเpFฝ>ฟO(@N*่ด1Ÿ฿ท+ธ(*H-X”!Y†อc!Š+”โรญ]ฒูํu–ˆ…กLAŠZด[}ทƒ-U‹˜(†+”bา้šิAxฝ i’ˆรย๙\2‰Iq&?ํ Š•ฃ๔”ืใแ&ฉ„8.Pๆ*†บ๙ฅลฉ2ŽRŸ/ฃ็x๒œLG”ญH–…รปnM3ฯ‰ธNถLมร0AF๙ขlqิ็v:9 ต˜…bl…JJ:ร&!ย์bฅน๑pM'dฅŒ ั%ฮธa1Y!Ÿ?โ,ฎDฤฑู'฿4E1›"๗“ษ$}qOYšฏ3@0ž\"๐z๖ถC;vดcืO;vhฐ†ดต?ํ้r)kืมฺำ1kmzXฬArถ„ล`p’ำ•จั4\nfIqYqY‰jจู IjeŽข(K’":ฒฬš˜3tํนใาฝ@’@ํป๛าJ?Pๅ๙๎๑?ํ*๊$‘ไ๑ EfšBฑ’'L(q&ล/4=฿พ๒Bษ#๘็ฏฤ!CO๑ุ๐kป๛๏Y๘3w)ห}์/7฿๗ๅภื|๕ƒŸ|w—ฅ๖“็xq๓ณo>7Zwูgo^*€+oฉ lฝ-NนงM›˜Bๆ ๕๏=๕ๅรwพ๑ลรฝ๛ศ๋/~>~ๆี๔‡๘ัMrฐแงž๛!ชg๘์ฯฉ๎๘_)1sำทzf‡Fํฟ๐qๅo ๅo—๐๓›+C–พใ;žŽqPว)C ด4ฉๆ-ZŸลDฟห^ืๅ—mZ’ฎษŸ—D_ีwฃ'นาท6ศKKWmdc!ฏm พฎื„พฑFX^บz›t;ชOุฉh1ญํต}eE+ฯ*cงฉนก'๊ช€€ฯK?@ะ๎Ÿฯิ76 ห,ฯg!!ต„‹ทกอ’Uดl%#=ึcั=nฏถถ™SZฒ8—\–๖๚^[8ฯ&ay้าlๅต้j&oe…::Tฅ%kำPยาQYฃ๓F4)ไ“Š ` ึ฿8๚gํ๋k๎Tฮ[พ.ำูSืmH ?๙m$ฏhI๚ฆ๚พIศ๒mX™๎]Ys^>8šฺืแูƒ`ํyC9๛ Š*6r!นปฆฮ5ฯˆDฬ3bฬ ถฑARถd} y;๊œQo\PX/)_ฐ6›Ey-ฝตวอฬ’tO๋^sศomิฆ.,๋3ag ภH]p๙ษ=m]ัฑJ/ูดŽ๚แG-ๆD 5DฌHc M3yย„gา$ษ š››cศำ๑ ‰Xำ>ผy๓ณ_sูE3็ajญU๊~<ฆKเฆฬs%ฯ™`ฎุ94yูฉฆช๚Tปb ๋ฤcะJsส0คi%ษ˜พฝK๏gซr3TA}Cท7)'SE่บmDŒ˜ฃ#ฤH>ห๗’ข็/อชe๋สhภW. C3ฟlR%/rโSŠL,กi&O˜PโLŠ_ˆ†††ๆg•ฌ‘ ๖ฺุ+yฮsลฮVฝŽ™ปnใ† 6lุฐnqฒทฃ>[q&Aนาu’ ‘\•’ฤE!๚3ๆhb$Ÿะใs[&ลIงรภฅ2œr:ฌัำXŽX(@f‹oบเˆ7โ4ูXBำLž0กฤ™4Irzfr่๑š3 „มb3ย็RวTะ CBTŒ˜ฃ#ฤH>ห๗’ข๛T็ „ฯl /G๓YŒ— R^›=1rO E$–ะ4“'L(q&ล/DCCCCCCs&C<œ ๚}แี#bฦไษg7sjฐ„†fฮRPPpบMฯ,4‰††††††f๖C๛44444444444๑B๛sๅย~ใต qP,ธ%a ๘ยkn|โ7  ŠL,กi&O˜PโLŠ_ˆ†††††††ๆŒg2“ไฌ8๛ย-—^zษ—็HNŸลJ*ธu๋า‘ w‹~qN!?œF6๏ Wคrfฬเ^$ู›/ฐ.›ขฌsรฦภสYทแฒsฒD ŠL,กi&O˜PโLŠ_(๑๐.H7ฬM''|ห6N๗้u ๐0iN' Qึข5k “N†0ล™eK+Vฏ^ฑธ8E€%$ๅ*๓,_ตfํ๊•‹‹Sแ๗[‘ฟp๙ช5kืฎฎXZž)I๔โ9qฮชš8–ค+eAEQ^ล’๔™{žšyNIชลiณไฉc 3–ฎ^Y"‹H3†0}ัสๅ…า๑แผด๙๋V‡‹ฒ+Vฏ\ทj่oUฎ„YKึฏฬ•!˜ผpํ๊๒ู๒4ฤS”Vถhษ๊‹ช“žqLXt๏—ปvฝ๋๔ษcM๒ เdฝ3ัs IDAT/˜วั็ซ8Qช ฒ๚ำๆๅg-]Z Bญฆˆ'ผใšEหี๚C฿๗๖“uฮ@:ฟ๙Ÿ *C&7๘พป๕‚!ำธฃg_๖พ#จณ/B‘‰%4อไ JœI๑ %แ7๎น็ ฺ้{ป(5vlš3NraaบuุG/็วไy%I๎ฦ#'œ˜,o^Iฆ`ปsบlMaฎฏ=X๋E™๓็e) ว‚|M–ยืyธฦ@8ฉeห2Zซnฎ-๘;#aซTcปeๆทm™ กŸอ๘ู GUR"C]6ฌ@šqp”…y)RิeŸx•˜สœฬ7:ำ{๘h฿ธึ+…ŠฅB0ฑD„Psช๑Šส๒ ฅ๎ๆฺ.L–]R’๎8ุๅ ผ๘cฦโp8lF 7cวfบปฌ€ฅ฿เฮๅ๓ผ~›ฎณถIkK^ฃOHตlก ใงณ๘๘‹9 แ5‚เ'0าcฑ่Hภ๎ีDฤใšf๒„ %ฮค๘…โฅัชonรทm-๔พe[ื_6|t–c7U}sพํึแฆ็ฏศ๑|๑บk฿n"บ๗ณRฅื๕dหn๛ำืญฮ††o_๙ํ๏>n๒ซ๘ื๛า๒$”นe๏๛๗c.$๕'_zl๋้ำ„ๆT?ภหซศœ่ๅๆๆสGิฃ E3~˜ฒlUŠๅ`ตึ์ๅๅศ‰ํvภ„ฉล้.FธอบฎŽ“— ณ [!ฤ‘ ำุัิb๐D.;ฐๅy…ูJ!~?‰…†บŽ&+๛Xฃ"ฉO kp ณหไN*“ &ŒL‚nว\$่6๋ปzอni‰”?ๆ T’‘ฮ3vjyน“7ๅtค.ุRกื9งหไ}ฅ-@ดฦฬ"ฟำู-ˆ?ๆ˜d’ฉ๎}แ‹‰‹Dฟ฿AK_—ฮกำ •ญ,!๏or$ฐ™E3ŠผK>ญฺ๖ๆd_ฏ๐‡1ถพนํ่?/ฮN Pdb M3yย„gา$ษCก“ษŒmAHฯป~ฃ้‹ฯŽ“i๋นe}๏฿๐๘ปžŸ๑Ÿฝฃไส?ฟsg €๒ชgžนX\ึž๙ึ^xžฝ>x็/7ฎไิพ๙ิK;ฺๆVอx&ภd2CกHE8f๗ุf “S~?)ส(-Jๆ๚}~วงศd’(?ฝtiลšี+ชธ€ฏฏ‘ฑb๕ชUk+ฬตอƒ“•ŒซTcฺ๊CU5ƒ์4) yn฿ฺ\ฝ๏Pm‡_Qœ.`(๒๒๖–c๛๖ญ๏w5cŠผ|ฝนz๏มฺnRSœฦŸD‡†ฏRกzฝcไฎ:7ุPUuยสฯอLB€กฬ-เ[OฺWyดรฏ*ฮ w!"ถทฅ,ศNEปN €\ฦ`จ๒ …๖ฦƒ{๗ํฅgฃ q4ูฉฮร•๛๖Vuป}=ี๕แว’—ฌฦ๚ช++kŒœ!๕ˆBัŒŸ@ศlฒ dR[*e˜ฬv`k๒2(ํฑ•k;ํl‰ˆภPๅMU•{6˜y๙9JFดฒ3Ty…{ำก}๛ึkGžบษส>†ˆ๊ำ„p๔–q?ํศIะํ˜“.ฃ!าUโฆไ&9:zฦถH9ฉ‹W,[ฝbษฒyyะ๛5hฑ’b1ฮ‹ฝ6๋œrฅ˜xธ๖N-อWr?ฮŠถJ3˜Sa๒'ใ)าณ3ำSี"_๛ก็$1ลฅ+ล๖†oz่&สŒแิUํญq เ8ฒทฦ50พชัีึ์แLฃ%™XBำLž0กฤ™4IrปฎT*อfณื›˜G฿๚๕s๗ฟผŸฟ๒ๆe“ีS„HY๓ˆม๖ม฿ž~{/฿ฑโŠ—7,Z …ฟธ๏ขfฌ๋`‹%]p้e…ii)้Eล\ฐ~๚๚๓๖แŽ•ทญINˆ‘4๑€ใxrrฒ>รมข(F‘สHD“๔R(ŠM;มฤ"ฒๆุม˜(ซผ4?ูRฃ ฐ”y๙“1*&o~่ฯW•ํ~๘‚_๎โ๚w„;]H’r"€ษconnžšู4ณ ฿เ,ภ#้๗๛ฆ;ุFQŠ"cฺฆ(:ตฟIŠ‚แ& ‚ $E ๅ|ฒ]ƒŒฤ๔๊ŽW_ๆH3Dšฌ๐T๙&EQ2แสG‹้้;^ี=แสbซsฅฆฃ๛๊ฆณ0%ฒ๑ พ\!Y 'ป,&S`žT(f‰์ๆC!gSM? Lฎ8ตฐ4_m;ฆ๕)&ฦb"D€ #–}tเศใฑ์AŸ7‚็I}b๚$โvœQ๐$6_ธJ3๔ฟจBุS}—šฯา๏๏+ฐ›์€ษsk{ย` €ฐFjoVธ๖รเษ‚ีh Ž&‰9ฒ๏“Gฯ~๋…๓5ร•ป๗ฤ›=ัy€ษึ?ฐXxศใฯyใ๎<\ํฬZ1_™่}hxสyหJŠ• เ*†>Œก,.YVฎเ&P(2ฑ„ฆ™~โMท?zใ<~อ2๑บAc €‹ีiนหฮY(r๙หฎฝmญj@ซ%A|ฮฯ<๚ซ7อK\hfึA_“&fa Ž"M‰ บฆHฺฌ‰:Eภฤ0ถ4UลฑูA—; –+ู( พJฮwนฆถ#™ืํbK”&Šโฒ$ๅv๛ภ็๕ฒลr>‹ลMสJ“b#1q‘Œƒ ฆ(2จL%w้ฑา^— —)…LcหไสํŠฺุ๕ธ\ธXฦEP^JQYบ"„  gก‚œrฏvdใy)Eฅ…ๅyสQใน^ำ )อH‘ธLๆะpฌ‚<ต„หBศ ฿OPแถ ืๅยe*1 E\uษฒ#Zู}^/[*ฐX๘—ฺ๐ฅ Œ฿=๕๐mQ+˜่m"Fๆš+2Gz๗| ’—lY“^0บ๚ŠLv๎๙ดjdv„ฏ๏ศ!ี9หพ;จั%B3Uš?น S C@}zq๙g@Ž›“โื๕ฟฺ>!tZB‘‰%4อไ JœI๑ ลหภ๖—~ษ+W•ญI}้ฎWฏ^ุ4๒ "]xอ#็Šผ_?๕ะซตผ%7ฟ๘โฺ๐weฟz๑ล_uผr|G๗O๘๛๑ซฏ~tilศc/oใ๑‡{n~ํ…บ=นu๓gฝ{… e{๋ฅฟnษนฑ๔ฌฏฎ[qฮห›"C3Gฌ.W‡+ํฒ๕ษ@่Ž๏m6 ๓—Tเ”วำะๅM/ะงmnใ”,หbQ~ปDณ>๖๎&]a๎ยŠt[:ZtSซใ c[› ฐpa:“๒9๔-v€€ฑC›T\พ(ี฿ะgัควl”.ษbแณ๕ถž๖ู!ณLฆ’9๔ญ1;๙‚๚ถQaษ๒t&ๅณ๗7žˆ>้ŒะทตŠ สWfฑยk้mบ๒…ผ]๎Eหึ†›Tศkํ>Q฿3ฅ•>QŒธ ‹pzF฿s—ษฤศL๗ตถ N$+ง<›‹#Aื`{ณ.0TLaAแาU8JxฬM#สะw๔ส‹,Ou๕5๔˜4™“•=ีง‹คxUฉf่งฝZ D๑–ˆOvฬe$+Š‡jล’Šd t๕‡š#=ใ!Soซ4'มR#SKซ~xzำ(งkn๙_!Sk3ฏ0w~‹๔Xต #NAะํ๔Y„sd/jฬ‰=Ÿ<๚๛ฬท_8๚ฮรฯ๎l฿F„อ>yXฦึ‹Ÿ๙ฃำ,อ ‘ผไžบพุ๖vwษ]w-๖|ฑํํ1#ฟ์ฅ7^w๗ศ+ฏ5$J(๒ฐx,กษใ'qBณฅD“3jSื™”ก9Dฌiผ๙ูฏฟ>-๖ะฬEชฒๅI† †๖lฤ)„*ŠW%[๖o*๒2ฮcถํoพ kyาœ2ำฟ4๑€KำR$ฤ`ทฮ'JM•„ปuŽะŒฮฐิ๒B๗๑†qรธ—=0ฬLเ\žฟDCCC3Kyx๓ๆำmยฯAฤbฮยฒฯ;งษ้-ๆœพศsลNšูฯ้}–โQงšxกš9ลํ.๏,\•ฌโลŸ+e?ฝvฮ•ซDC3๗กš9ฎฬ/หMb%&3ๅ้†y๛ขSส"ใ๎tบพืฯ‰'ฎ(ใ%KžำpNIXาด์Œ๔ฌL9;vTIZa๙ย%K–,^ง˜ฦตโซ SSKรึ”-[ถ4Wz๊ช˜Bู“ะค‚eห–'O”nผ˜ผ`ู0y2˜$0L๏*M`ฦ์คก™*xๆEฯl฿Wืฺr์ว๗Zงยฦ~ห๔—Ow็Žศ/GณNงำํ{จRo๙V7šใX%p*ะ๋งihhhๆ จ -?CฬA„๙oc๔OV๓~ใž{พฎฝ๗ฑ‹Ra_ ”ƒข๘ฉŸ -ตNž˜ฑิ™jรฉ๏า;๐cEƒ-bฦSOŸ0โ/๛้eผคs ฃรฬงคห๐‘HgB}šฬ˜44S)ธ๋ื~-๛ฺK'>ฮป}Uป์ฒOXลด๕\๑—6๔ฟd๓“mPิ˜๓๐ศšm๗ฝWึNNคภฉ@๛4444sฆ,;WอEๅฅๆez:ฌQฺฦI+๏~๑ษkVdq]}๛>}๕นฟค#AถถgฟnMž88P๛ี‹?Y{่๛ฯnH•^7ึˆ@ถ์ึงํ๊$ฤา๔รซ=๐~ƒoีsอผZpัปบ‹๏_^๐ะพ(9ž\:?^mqญ€—6ฟT๊[ฺˆไ5\บึๆ~?cQ‘*bจฒ*pt์ SจฮLW 9 บ-]FฯŒœj-ส\\จฤdyหd!Cำ‘.;0…๊Œt•ˆร .‹ถซไฅ@”ตธP่o้วS3ค8aํjj๓(สห’]ฝ,:ิำ๎Pไฅ€ถแ„UoูI”ซฬสึH8 ผv]W‡šŠIง7ฅฌ,ทvิถ8’"ุI๙์ƒ>ภชัM๐ˆS)ิde(…l,ไwMบพ~[ โGž™•"ๅใŒก†”ญ๓Hป,ฮKลฮ๊งT šx)ผ๐โ|ไุ๗=๓–ชdvr๑นI?ำะทยอ[7ฒซž๚ฌ7/๕cผพ๚๐ป5Wฆฬํ‡๒๔›Ÿ€ิHSaฬฅ@ภรใJNญt444441แq%~„‚ฝ€˜ห$!ยU็eหNฮลมๅ9นษ‘ฯBV>๔ึƒgKŽ=wหOฝwŒ_V( ๐ณžุ๖่๙‚}ฟปๆๆ7บ ฎ}ๅ๕›ณฃ(EŒ‰ox|๏.ิt๔์ณึemy๖๕ Zท๎?}ซ kท๗n{๋.ล ์ฺฮฮฮ็ฤ7#)Eุ,nŠ%LI– เ5uwv๊$@ะชํ์์์ิูC€Šำ๓าค,ฏฑฏฯB๐Yyฬุ้5uu๖Yเาwvvvv™ผV—a๖๎–ึW™“<2 OR๒ฝƒ&7ย–%'ฑP‘€$Yาดd<@0„b!ูYŠฬฬ$†{ ทฯBpฅ™*๖)˜4%˜๒ดd.้ิ๖ 'นG‰F˜š—*aธ๚ฺฺ{ .Œวม ส‚HRฒ€แD}‹มr๕7ืv˜ร›dฦu้โWงก™Q4 P๖ฒ?๏๛๚.Y?@JJสศ—In]ƒุ…๐ฅ>{9๗?OKุ๋<ฐณž>pเ`๕‰๖cŸณˆ;Y`Dฤ\ฎ'0ฦS3ะ[=ฏ์ๆึ=fK๏)“††††&"Bbั‚Kz๚ŽMชNซ=ซจ่`GGฟี:๑[ภYคฅฏว‚๒•ฉ2ถืิct,xข2$b>มs๛ฟ|แณwY๓ม๚๙ง๗U๒ิว]ึาEผฟuD:๙$bLึ"ฐ}๐ื?พฝ9ไ ‘ัƒแ`8ฒฃม”๋{Žฒg฿G}ตC1@@”aA’Dœ!ี่1?#yb„ฅทฝฯŽษ…*˜ษ`@ะe2บB‚ •€p[Œฦp74—ฯgaิ๕ุ1Bคศ๓๙ pOrิ&SšS pด6Oตc9เ4ƒธ*Uส๔;Œฦก\น>ณษdทc,WšX,ไc:/อ}nœ”ฉ  €t˜\,ตฬ?จu*““‰ฟ์„ฉณม>‡—ภฑ$9วq฿Lš๊๓จ85UŒy๛ป๕>˜์%„มภ(Œ…fญIOB4uสcท๚ลhภ็๓IŒ/3๚lภˆ๓าลฏNC3ฃเ,&!%I@pึHW’๒โญไO๗}e`”๙ušใ/พ—าฌC0ฎD!b›ฟ{๊ๆ> `‚’+บsอ]๖แฅŒ๘"ฯึLโ๓7—•ีkตฃว๘M).ฐb้ฏp|†:ghhhh{ <ฝ}ว๋"ดด๗ตตญสอฒp!—yฝฏฯฆฐ0”’To7 Fmนฟ}๑มีฟฝไพืV฿G๙zvฟp๋MฏืฐXLษๅ๏4^@‹<. ’1& gƒP๕?V?ฅrใg็—^/๊จMั”|จ*`zถฎ่p”7;งH (ŠˆถฐA‘ฑ1Qt’ฝC0aZaŽ8ุ;@29ใฃŠ‚0ไy‹d  ุpถ$E€฿ะtฤ‰kฆ–๑๘ฒS ž"E#ๆ0Qล&iูF6้คW1ฉูWฏม}jSŸขCฒ๖uฒาd)9E)@๚mฺถV+raIย ี™ …ฟC฿=0๒ธŸ๚ฅ‹ฅNA“xม  ˜๗ห ฟลu_รSWำ.ูบ8๐-; _^‘‡1แต€เฆOks๏ษฝ๒Ÿ;†7์ฐ-ธ~อU้ฉเญ?1N๚ฃŸdo ะจำํnnmิ! ึ5|๑FCCCC3sกะ๎ๆๆq๔)gึ๒ฯ{ฯ๛ื#ส‚ฅ๗โ6๎๎๓฿ปฆ!ฐ~๙ภฦg„#์ฆศฉ‘bฆ๛|&@ณไขyขšŸjtA2@™Llt๛sพญm้%๙ุร |า๕as็ˆ๓๐์ื_'ขิัก(jศ‰ฺ6|Œ G•กๆขฅ 3€2|ŸP‚ ิIuยYื็ŠAŒ[ถB†q๔,*MอV๐l] อVLQPขตเ`J&ล{;<] I-Vช๚๎ฤอZŠC๒v4 v1นYJV†4M#3ด Fบ‚Bu–šาVึcx8ั/ิิgIฆ๙๏Dงำ’ฌR่AญQ๔๖๗‡ฟษฒฅฬ๕ํK฿ปยšฟy๒ชv฿๔๖#kํŸ?t‡7ฝ๚ฦฺงW]ถmPƒ์‹^ฏ๛๓๘ภมxždz4 อ™…pห[;.7๋‹CmV งั่ƒฮšc๘ล‚ k‹=ื=x1๗฿๗_๙b•jํeหี’yRH]yๅ•—+IušŠหH\๎่›2๙ฬ›*“๏ัv<ๅwNมPxผ!เ‰’3ิL?๘อ:ซฯ้" ‰/sCค@•"รLMZG๙ล_v@,6G(`!*ีbฏฮˆืค)๚!฿@wฟจ๓ใ๐dป€๖ุ๎กIFฤ๙€ง็ศ๎บ๎ฌฦ^๖Eหnx๒.ไˆ์ผM<ฐ}คื!pJFa ํBะะะะฬPพ\-ม}ึ~“'jŸ*#ย๒Mฟธ๔—WmY.๎/๗>Iฏ/ิy๘ˆ'eูืpๅy%ฬ๎๏ผ๚~ญ…ต้™/ผ:_สฒณฯ>ปศ๙ถ=‡#ฤ tฉ ค-\{ล็ฮฝ฿ฃ@vึตˆŠ–Vlผn^šวm•‘ขืQkนŒฃำ6=o๔MญอลJส-สT pใ% ๆ๊7ขdฅq ุ7I#ๅ๘mƒ.8RM/ไ0a7๒9›/–%I8เต๔u๔Zั{ค ทล ( ํty}มฉ6}n/ƒ+Jคb>ฐ~Ÿรย…2ฅJ)ๅก>›^gt[ข‘๓Bฮ€)R)Aณ> P‹Cf]€ฏ‘€Mg็dวWvฃษC๒Dฒ$นˆๅํo้rเฒ$Aศbtใ5)๎"$”ฐ \ฬ$…Tฬ๒อ„4ย=๒K2Jฒ“E\ฐx‰„K˜ .~„@G์ข`•วƒ†fสPฦฃ•ฝ๒ฅ็n๙ล๚,๕ถ๛๏yฃฮI ny้ถŒO<๚C฿ฤg0}ำํ—–zc~“ลt(๓IDATตกึœ\ดd๕y็ฏ+`tื{ธห1p*F!lvbZกกกกก™qถPสc\f็ฤuำณD-เyœ.้ถ#6 &3Œ5ํ…fVรั”–ง2šด.Pฎ&?_แ๋<าlLฤd1šำบโ้๊ํgy’วŽšŠ| กกก™;P>‡y–Ÿ!6 ”ฮ้:6ฤœฦฑs4ณŸล`–ฆHsสๅEฝ–nญ‰vhฮ[/Rv}ธด8@?ะะะะะะะะะะะฤฯ${ุัะะะะะะะะะะะŒ๖hhhhhhhhhhhโๅ#pฌœ*๊J„IENDฎB`‚aristocratos-btop-d43a485/Img/options-menu.png000066400000000000000000003073011517514752700214300ustar00rootroot00000000000000‰PNG  IHDR’†t sBITแOเtEXtSoftwaremate-screenshotศ–๐J IDATxœ์y|#g}0๐฿ŒFทฌหึiษ–mู๋]o๖๐๎Sš’Bi๚าp5†+\)G9 /)P(ๅก …ด”#@ฅคแmSHGK(ืfณป^ปพ-ห’-๋–ฌk4า๏๒น;ฒ%_’ผฟ๏Œ?๓<ฟgh๐x‚Y$›ปำฎU<“‰๘f|‰ย>4!„๊๘NUlWYEb‘Pิ๎L!…ฅฝอKhVุ•Bํ1ฉฅปท)9vyาJQ–n+Ždy…นซวnเi^),-$๒ๅW'}ffftา-๊;:ิ้เR๖C๒๐•หSพHVๅ์10‹›Bˆ่NUtWYyโฎ $RŠ๘ฃ๏ึAืๆVdS E1ด: อ=‡mvณ^มฆ“9 ษuชWใ,‡Žt9M๊โR|%Q•ฅYะvœ๎Qฦย™ฝ˜nบžำฆ*\="ๆ๎ž6y&œ*ศฎžC๎งตEนฅL฿งYรฅโูโล‰B๛DeฐษRพล4+๐EVัb•ฆ— Bzั%Viz2v๏๋4KฒแบVท">ฑโ–ฮKญe*˜*RRya)”ฬ๓ภ@moขธซD]'DwชขปสŠ5โรW‰ฦึำ{จซa1j$ลl&ฯn:7hj?ูฃŒ—ฑป`ท๎X๒/d6Nตธ:ีฯ๐๙๓—ฆ’สŽ๖fI)]i2 Wฮ_+]ญzb—๊ฏFฮxๆ’๊61?ฃ^ 1นบ4™้มgฯ_ž็m๎VอrVฅู,Yฝpa,ฆho5์sœ!ด2แ‰p้๒"Jฅ”ฑlธl<’คE†RฅFNIUล๒J.ƒBAhjํ้2) …‚L&€|Lq@Pญšหdw้่Bี=ฑช่ฎฒ๒Dพส-ฎV!8z๑ยฅqJฆำH๖ทปxรU*U!1—*๐™เ์ด–‡เtd>BsนฅŒะฆ์็•ฑ้ไฯ้นRฒศตp„”Pชิ…ค/รp๑่’ฎ–Bฆtุสฒ์R†ืษeฬ>ฦ‰B๛„”k[ฬฆๆfƒชšmzฅšž(จธT|ynA’ค „LญีJ$Bž'ษ•CRs๏™N=Ÿ‹ฬŒฯฆ๑šV„PCSต;ฺบui)๏เxธก‘kvช2ฑ]ฅ่S4Qพ%“Rฯ%ƒžไo„6ฬH’lkkkiiฉไขฆณgฯฎ๛คฒ๕všU2™pไˆlnt>@„ ,เr‰ต;๐„ต‚ุ๊ธภภภึจ"ฮk!ท๔oๆ€”p๙ฬJH๋ใฒ–ว‰B๛c^Qขsํึ3‘`hส—ฬ๙-ึds‰Hnํ#ฯ๓Apฑษ๓1สB๐ซ—ึrแ๑ณa‚Rš:{0:[๙?‹ปJ„PฃXUาก‰แุ๚ฑ _,wุNUtWYyข8&ไ๑)ฺ;Žฺๅ|>ฬอEi๑ผ+“‚$แุs'?•์“Y–วใ^ฏ—็ืGl˜'8N…B122ย0[lฟฆพโ๘ๅล )‚ ภส๔€H)`‹†–ม/O0ึๅผvจพี ช8ฏ%B>86ผPษ}{'Bํ {Eา`ณ|ฦร^+Q j.O1<[(€L&เ@&“ €Dีlคา‘T–NคŠz ฤึ=ร w•ก๚ทaW)ฐLพฒฝค่NUtWYyข\ผ*.๒Œ†<ฅิูบบ;อฉ+!ั+z–'?jวQGar"\ธz๒ณๅ>Y.—ปnงำ977ทึะ๕9š››็ๆๆถœาัฒฒK%*ณ]+•HF[ ็@ีาัnัP€Daะฉ๒y|๚B่:!พSUVž(Jiํt™ตJ))ฐฅ หฉX&Ÿฯ็ ฌ ฐ…|>Ÿ/pี]Tส0ฬ๔๔ดษdฺะะ๕d2MำUZ๑zิ]วOห–Nฮ{"หงJ(]ัSn Ÿ_Zœ๒ค a_ภะ}ไค•yใf๛.Pyœ^Mืแ~'EpL20“+{ฟถq"„ะฎ#€4๕ฌWˆMžŠƒพ๓Lฏน4G84`.<ฌ' ล|–ae\.ฟฒ›ไbiUWวฑ~™OฆฒภลswฯIE๐Ezia&ธ[UBจ‰๎Tลv•ข๛O๑DQลL–pด๗ถ)ฅD1Ÿ[f๏ †aฎบตP(ึnจ๐ฬrๅ97jr๊(\T|8jปํฮ๊uXBํDmwVธซD5„๋dgตํ‘n=ฟ!„B!t๐ํ๓[Eฅฝ†๗ทF„B!„ะฎม๓!„BกJm๓„B!„ะ๕๏@!„BmฮB!„B•ฺ็๛งB!„ะv)ฌ}78 ณ—ฆข,€ฬvดฟ]ณ๎๗ฅทธˆir๊ณRย๒หรธศุyOJt๕Œh™bซส–๖‡Q-#X:น8;ฬpปืึCขฑน;ํZษ3™ˆoฦ—}Stu9 นกญณญE#'ธ\rใ ็xะvœv1—KฏIXฟผ๛p€B!ิ ˜ธฯSเS+ฏ8.†'.ฦˆาฒDืัgอ–}c1ะแก…๕ฏt]ฝl™ืฌrK—Kฯ “๛Hท==่/ฮณ๋•ยฺแ B—/„๓Mแ^g๊LRะ•็”Yบ:Uษ‰แ‰จl=‡;ฬษ+มฒs‡๓„Bก๚ืไ:ีg•@ฮw)ž-ฝoXเŠ…ๅ#*‡M“๔OUuผY|๕Šห$›ดšt๘Jฆ(ไBกD›]+‡,S}ำ8:้OGi^>ฬN… ฬXฟาœคVื” eŠ@&ไ๗ข\ๅs๏™Nส'>2~n&นำแ!„BจคฝฮzกษuชCไ—คf%Bฃ ~ณ”ญGฯุc้ิขืสฎe]๊ฤkVง()ฯr+ศ“ณ’ฆ๕_ง๒qJฃUs™Hqว9)J*ฌny6œ/_;? Œ๎cํ|,ฝ\[n‚B!„jFb07็#Cฅ TญวŽถ*ึ6ๅg็G $JSgO‡%yy‘[]ดL[]ุpะ[ภษCyฅณ|.23>›ฟ$ฉชœ+ื—™๊ะA0หC~Pตh[ฮ“๓ญ[Aj์่hJN'wๅœ? „Bํ’$ฺฺZZZ(j๋aXe/ๆ"ด๐-O่ะฤplะž/ฒ[`–o›`‚ฑฌMฅ`ฤV-x‘ีณ› „*ˆภบ๊ว…วฯ† Ji๊์qร่dฌ์)ˆ sฎว>q.ZWว๒ํ9฿ฅต๛งืฒK›;:4ฑฉแฅณ‡ซF,หฦใqฏืหo5ฤ๙B!„ะq: …bdd„aถธU โ!ธZงๅ–‚+ท),“gฏฮ"o้๊วฅ› สฎ.š(บ:หฒ$%!–Gณ†ฎ3๖์ะ๚xฏทo๘รITอF*I@`้Dชุกื@,ฑ+cณšKล–๒9ฏยฒ,ฑบๅI™Lสไ ๅG๕า–N—*659๗ฐo$—หnทำ้œ››ผ๘„Bกำ<77ทๅไก ฒ&4“มGEAข5™t2’ ฅsณ*“Yอ/บ๚U‰ขซ๓™TฆษbำHI’RY,6ูวg5 UKGปEC…Aงส็W&eJซปงณ๋ฐซ™*็ี๘t2ำdฑkd$)mฒYดฉxโšใ ™ฉำฅŒฮ๘R[^^ฦ0ฬ๔๔ดษdฺฒIx!„Bhศd2šฆทฮwตี็/œhƒ์เH้BฃVันฆWีŸ๗๊;:–’\!๗ฬ„W†๚ขซ_(พz>8ใUtธ;dภาK S ™๊›uเq1œมsาF|‘^Z˜ ฎ๑‹t&ฯJนl^ุ*็5˜ะดGูuƒ]N3ฯL๙{ฒ%๚fฅ€พ็ุถ~ร0•\V‡๓„Bก๚Wz’!>}Nqrๅย3Wย•ฎ~Mข๘๊<๕ŒF=[V~]rกฉแศ/ุธ็Rผขœ"…2๑นฑ๘ฦหŒRณ็‡ฏY^}าnย๋—B!„B•ย๙B!„BจR8@!„BU ๏@ว้ฌaํ~…9kgๅฅE/N„˜†~iCฟCา๖mว‰็B!„B•ย๙B!„BจRxB!„Pอส–๖‡Q-#X:น8;ฬp ํ8}ฤ"cาa๏ด/Ymวisy8ุฐŒถF*š;อมาษ€g&˜ๅฆž6-Yˆzฦผษฒ/_ซwสึcวœŠ่ฤน™ˆ6H•ีํnีษ:67ๅ‰1โฝฎ 8@!„ชนฅหฅˆ็…ษ}คž๔g ็ไ”๊]}๎ึไyoชโ"eGซ^บ>ฅœ€ฅqe_Vนฅซ]ฟ4ž'ิŽ^gst ิอ‹r} ] & w8 ›ดštไJŽ€ดoไY9AA2c{ท๗๚R 4 u‡2๊ ชชาg‘f€DJ๑t6ฯqdŽ‘๊คซ9ฏ้uLๅUใ!„BจF(Jสณœฐ)9{!ษ๓๒šฦtเP”T U๖งM'่ธฦก™ุbบง็„‘ ๙Y{๏กฆฅูฑ@ฆ&J{[sฦw)-ํYNkฆภYา ’“J)/ฒลๅœ"ฝฎ 8@ีุ{฿๛๕?๙ฯื*’า(-ย8ชฤ๚ย5ร8Rช7hx:ฐ่ืHญFฝ28#ir:ไ2%วยLlf$F*อ]๎ึ‚bส:|ส\Œz|q๒ก,ัfŠชผื‰ร๙B!„Pอ๐tิ3๕lHKอžษZHxG}‰๊€แ้จ็สUy™@‡&.…6_]nlsุˆ7ื9.โ คธ=I†bp๔\อผŠXฏซนB!„:๘$jƒษคW@ฉŒฅ…=Jlx!„Bกฒ่ภุ`X`Yเว#B้v์ฝHl8@!„Bจ,+0ฅ‹‹V๖&ฑQเ!‹๗xโโN*๚อV6๑ป฿}ฅอถณLE~?uื]_๛ฺืJ?w^ปจ6ณ$“ษฌ,Wป่–฿•ฺฏฒร-฿(=d‡๖น‡TขCB!ผ!„B!T)œ? „B!„*…ื/!„Bี ฉli๏pี2‚ฅ“‹ณณม ”ึัีaัส„|2เ๑ณv|‘7wธอj)pL:ไž_bฆž6-Yˆzฦผษ†บyy=e๋ฑcNEtโL ษuชฯJญผn‹Œ๗ค€TY๎V\ csSžPฎืU ็!„Bต"ทtน๑๑แ๑œ 0นtำƒ,itu่ฉ‘้,ฉ๏8šพไ+๗*aT•ููฬ๘‡ฦbEPุzทƒK)ฃUป˜ฑ๕›๕sษจ$Eห๒[VGคๆv›คฐีัดxh‰ะท:%‘‘‹aชตฏข‰๙2ez]ใ๕K!„B5B6i5้๐bฆศ๓l.JPZญ@k4ๆB ฉวๅc(ชZวูุ8ถศ๓ว๐วsE–‚ € ™ัuธืฎiฌa1ฉs8”ัน`~๓l)ลำู<วๅrŒT*(ื๋ช€็B!„j„ขค<ห-_qษู IžJ/ƒBAhjํ1s…‚L#ศี4ฮฦฦ,Nฮด๕๔Ÿqมe|cSq ถ˜๎้9adB~ึ{จiiv,iจณJ{[sฦw)-ํYŸุz๔Œ]8–N-z=ก,ภYา ’“J)/ฒE€2ฝฎ8@Uํฎป๎ฺๆšO<ฑฝ*DีZuืพอ๒wี.ืพซ[พฺBชฐฟqn[mkU‡!กสlxํฐPฦ‘$)!Skต‰็IฒฑŒืiK‡K•˜ผ<อ*kgWkfฤ—ab3#1Ri๎rทใษยึลิฉฉ*,ŒฤXฐฎฆe็G $JSgO‡%yy‘!นเoq๗๕;:67]zคธXฏซฮBฑฝัษ›*~˜๚๒Eฃ ๒ฺwRห.ฺลฺwqหoฃœสํœSฺEีaHจ2‚Hฯ๓Apฑษ๓1สB๐ผX.T)‰พล@‡งRดภ,ฦZ™ดพฬ!7ดw;จ?ฌu๖๕ป˜ศ์คฉAnค&ตNง229มHืRyถภ,7€ ฦฒ6• €เsมษแเ†๕wฺŸp€ฺฆํŒQช?บผ;gชฌ}ฺ๊%ปV๛.m๙ชิฐ‡์ตฺึ.ชCBaY–ค$ฤ๒ˆฮะuฦžบ,@&“p “ษ ฆฦa66‚$AX3 $”ฑณวLฯŽzY๋ ญKSC[ฟE?ฟmŒ™šRฏ“ษๅGo\9โขะฬ็ํฒเx t#ดฐ๑$รez]ๅ๕ใ!ด}ีŽTช=บผ[gชญ}ทjปR๛ฎl๙mจIูตญ]T†„*ยgR—ลฆIs‚ยd1ฐ้P€K$:mvm"•่l-D|o~ุ 6—+ถ›ๅษXPตTน lั;šเ8”@ฯ &ใํบ“๕ ž๕•ฅึ#'ี‹็f@6Kด&“.JงX‰ฺฌสDห=RIผืU็!„Bต’ฮx๎ใฐ๔ายิBธ˜wZีีqฌ_&ไ“ฉ|x๋ฮคfย]ํ}งบ(ก˜K๚fC pฅ7ไใกกรงฬลจวื'สแใ๓^}G็ฑำR’+dโž™pูIhฏซฮB!„j†งฃžัจ็ชิโ’|ศฟ2ๅฦ6‡xyำiเ"@Šซ"qDkw™$ ฟ?^ุa™;ฌ}ป[bYqi~|x^๔WšธฺำํนถWดเ่น•ฆไย3Wยญ%๋*†๗๓#„B(ตมdา+  TฦาBU‰kฅd2ชจ—นรฺkซmฏoต“ „Bก]Dฦรหฟ86Xถบฤ5ltj0Iฐ…—นรฺkซmฏo8@!„:Pฎภ”.†Y]จ&qฎธ’บร2wX{mีขํu ็!T|ใ๛&ภใ฿b2-qEฏŒDสๅฯd2ซ?wฎ๒fbํWีะ=ไ๛วฐอ พCBกสแ!„BกJแ!„B!T)ผ~ !„BจfHeK{‡รจ–,\œ f–/†ง4ฮ#6z๊Lขถอiื*HžษD|3พDฆž6-Yˆzฦผษ†บyy=e๋ฑcNEtโL ษuชฯJ หoฑเ"c็=) UVทปU'ุ่”'ฦlา๋*ƒ๓„BกZ‘[บ\Š๘๘๐xNP˜Gบํ้AVa๎๊ด้ศl†ฉuxƒยฺแ B—/„๓Mแ^g๊LhUฦฦ.flf\2*IQภฒ|ญCญŠิn“ึ?ŸŠ๖-ะ2๚Vง$2r1Lต๖u[41_ฆLฏซขbผ~ !„BจFศ&ญ&^ฬyžอ…B Jซ•ณ‰ศุ˜/ฐวล๋ ๔ข4/ลt2#(R@ €]‡{ํšฦ“:‡C ๆ7ฯ&‘R<อs\.วHฅR€rฝฎ x!„BจF(Jสณ๒'œฝไyศฦ# ำื0ฒƒ$๗€ 4Z5—‰‰-ฆ{zN™Ÿต๗jZš d๊์ƒาึœ๑]JK{ึ'ถ=cŽฅS‹^O(หpE–4จไd†Rส‹l lฏซฮBuแŽ;๎จuจฎ5hน*์๏|็;ตŠdU†t}๐ฺaกสaชœฤ{ฆSฯ็"3ใณi€‰อŒฤHฅนหZ๐OŒ'k–บชHMํVaa$ฦ‚u5-;?2ธH!Qš:{:,ษห‹ ษ‹ปฏ฿!ะฑน้าำฎwฺ๋p€ช8ŽA›kฤฒ>ๆ:™ีaHื7a๋,h7pแ๑ณa‚Rš:{0:+rC{ทƒ ๙รZg_ฟ‹‰ฬN๚—ไ‚1R๋t*#“ €t-•g ฬr˜`,kSฉ>œnXงฝ็ก:‚ฃดน†๋!ซืฯไงCบฎฑ,KRbyDg่:cฯ] 6ุฑ๐z'Q5ฉt$Uฅฉb‡^KDg™ž๕ฒึZ—ฆ†2ถ~‹~~)ฺ๓9ฅ^'“หh[ฌะฬ็ํฒเx t#ดฐ๑$ร;๎u8@ีำ อ5V)E[Wำž: ้บฦgR—ลฆIs‚ยd1ฐ้Nvชฅรฆขวๆ3,ฉ0่T๙LXฦ;šเ8”@ฯ &ใํบ“๕ ž๕•ฅึ#'ี‹็f@6Kด&“.JงX‰ฺฌสDห=Riวฝ็!„Bต’ฮx๎ใฐ๔ายิB@฿yฆื,€C&เยใฯz’5ณ‘q1œมsาF|‘^Z˜ าภ•x‡๒‡Ÿ2ฃ_cœ|(‡ฯ{๕วNKIฎ‰{fยe'โฝฎr8@!„ชžŽzFฃž‰Iฯณg=โ๙+!7ถ9 lฤศ๋œN๑R\ใ%ฆชzฅูf„\hj8TๆwthโR™฿ํ๛๖†bp๔j3ร3Wยญ%ฺ๋*ืXบE!„B[จ &“^Iฅ2–1ฑ~์[ž@!„:P่ภุ`X`Yเว#ห6dbุทถ7 œ? „B(W`Jรฌ.4bbุทถ7 œ? „`ฑโใ๏I$vRั? e๒“฿3–๎ธ"Q•7ณ$“ษฌผฮk฿ทRyH•{e$ทz๋~๔ฃาฯr9E๛งจj›yU๐uBU๏@!„BU ็!„BกJแ๕K!„B5C*[ฺ;FตŒ`้ไโ์l0รjKWgซ^I ล\20๋ e๙Zวy([s*ข็f 0๕๔ถiษBิ3ๆM6ิอห๋ญoQนDReuป[urŽอMyb @™^W9<€B!T+rK—K‘œพpาD˜rtี 5ททหโƒ็ฯM&ไํ.“ดึaRsปMRX~งšยhUฦฦ.ฮๆZฬz€คจ†ohQนDB฿๊”Dฎ\ผ8™าดY4PฆืUกแถB!„ะAA6i5้๐bฆศ๓l.JPZญ@.ฅ–"‘,ห๓ลl<ลศŠZวู๘HรกŒฮ๓ฅAA2ฃ๋pฏ]ำXรโซZT.Q"ฅx:›็ธ\Ž‘Jฅๅz]5U๏F!„Bจz%ๅYNX”œฝ0บศdรแาdJฅ”ฑlฑvJ{[sฦ7Ÿ^ูิLl1ญ๋9ั& ลX{๏!sanฬ—jจ‹ฤฎnQนDฎศ’ •œ$•Jyฑิ“ฤ{]๐„Pีnฝ๕ึmฎ๙›฿lฏŠMp‰๊ะ๖{ศ,ถŠ๛็ึEํV95 ํฃ ฏ๘ี,)ืถ˜MออU14ส_ป"ช‚ิิnFb,XW’˜ุฬHŒTšปญฤxฒฐู๚๕GคEe…ไ‚ฟลื๏ุ่t้‘อๅz]ฅp€ฺŽํ ่ธโ‡ูฏ/‡Dจ>ง|›GUyฌฐภ—๕ๆyD IDATP“ะฤ%:ืัn= †ฆ|ษlฑก‹ื!R๋t*#“ ภบIนกฝA…aญณฏ฿ลDf'K r#ตh‹ฤ› ภ็‚“รม ๋‹๖บ*เ!ดMึWCซ&~[วSๅมJ‹ษบ๛ฺo,ห’”„XับฮุณCWยZ›ฅเป0nัlฝS๊u2น่ถๅฯฺอeฟผรLฯŽzY๋ ญKSC[ฟE?ฟ้ศzˆตhhšIšงฏ]]ดืซ8ƒ๓„ะ๖U;ธฏ๖ƒ]L*‰d๛+/|{kํsHจ๘L*ใฒุ4ฉ`NP˜,6*EQBก€“‡’๕ ž๕•ฅึ#'ี‹็f@JF'€Aเy฿xQO}m€hขั^W œ? „BีJ>8ใUtธ;dภาK S คฉwภดš)6yv*^ร "ž+ฝ๑ ๅ>e.F=พฦ8๙ฐ ฤz]5p€B!T3<๕ŒF=๋“ ‹—ฯ.๎N้ญe’$xAnlsุˆ7ื9.โ ค8M|๕๕6Oฌผฬ*Bฺ™bp๔ฦM\ mพVๅq๎0qWZT.q=‘^W |~+B!„ะE(๕&“QE€Dm0™๔J(•ฑดP.q๓ีื<ฑ๒2ซฉ*s‡‰ฯ? „BPltj0Iฐ cƒae_Œ, ๅ7_}ฝอ+/ณŠjก๒8w˜ุ(p€B!tPqEf๙ฒ+,/ฎ.”Ib๕uถHฌผฬ*Bชสใabฃภ๙BลJ_m๚!เ้งj4ห?w\ั™ฒ๗me2™ีŸ;Wy3๗ข๖๗$p๓อ7?๔ำฅŸฐบ=7ฺแFตร-_MทoDF›ุ‡fึaH!„๗? „B!„*…๓„B!„Pฅ๐๚%„Bกš!•-ํฃZFฐtrqv6˜แ$›ปำฎU<“‰๘f|‰๊^๏…6ูŽ๖ทฏฟ46yv*g๊้mำ’…จgฬ›lจ›—ืSถ;ๆTD'6ผ*๎ชDReuป[urŽอMyb @™^W9œ? „BีŠาๅRฤว‡วs‚ยไ>าmO๚ณ k‡ƒ]พฮK4m‡{ฉ๓3ษ๋ๆfปฏžธ[~>ชDืัgอๆ@aด*cc3ถ~ณ~.€ค(`Yพถ‘VIjnทI …อ }ซSนฆZ๛บ-š˜/SฆืUQ1^ฟ„B!T#d“V“/fŠ<ฯๆBกฅีส€N๚Qš„b:™” iญใlhW,,ฃšmšไ|0AA2ฃ๋pฏ]ำXรbR็p(ฃsมๆ‰)ลำู<วๅrŒT*(๋ชจz7โG!„Bีฃ()ฯr+็’ณF€|Lq@Pญšหdซ{*ƒิฌD(เ˜ุbZืsขMŠฑ๖Cๆย˜/ีPg”๖ถๆŒo>-l‘ศYRก’“คR)/ฒE€rฝฎ xBจ.|๓อตa_-ท๗๙วqm๙สีแ–ฉระŽmxํฐภฏ`%ๆ3z>™ŸMใลKปAb07็#C9`b3#1Ri๎rทใษปรDjjท #1ฌ[$ ษ‹ปฏ฿!ะฑน้ารห๖บ แ!T/ถ|ถฑฺาxทรฮ]?[พruธM๊0$ดสฮ ธ๐๘ู0A)M=nŒแ)ˆ"ด๐ญi'ไ†๖n๒‡ตฮพ~™๔/5ศิคึ้TF&'้ๆ‰ภ็‚“รม ๋๏t>Š๓„Pนฏnhcœ(นถ|ๅ๊pkl;$…ฉซฃ… NฮๅŒ-\pr.ม‰'ฎ’›ถHผฬ๕kU^๛nญพe‹vซฬ-7๒ๆs หฒ$%!–Gt†ฎ3๖์ะ•ีlคา‘T–NคŠz ฤbซฃ*จuZniๅฦสุูcฆgGฝฌ๕†ึฅฉกŒญ฿ขŸ_Š6ฦ™ฅ^'“หh[ฌะฬM“"‰C๓๔ตซ‹๖บ`g`p€ช/๛ ๋Uญซ“๓%{หWฎทรNB"ฎ'€‘7•ส%ฎ’l•ธy™ซ}ทV฿ฒEปUๆ–qnพ=ื๐™TฦeฑiRมœ 0Y l:TะถtุT๔ุ|†%*Ÿษ—YUNึค‘fWž2ฤ&ฝฃ Ž@ „ ๐ผภC๙?qษ๚ฯ๚J‹R๋‘“๊ลาฃZEEˆ๗บ*เ!„:ฐrแgๆAๆ‡ŸYA(›ธถสV‰[”นญฺwm๕_q™[ฦน๙๖\'œ๑*:ว2`้ฅ…ฉ… ฤswฯIE๐Ezia&(r U‡ะจUt.ท๚‡เนา ก|<”?t๘”น๕๘ใไร.ํuUภ๙B!t`ษN‡xyรiเ"@Š+—ุVqโๆe:+ฮนซ๏0๘สห2N‘ฺE๑tิ3๕lHrกฉแะN๎"qฎ‘hํ.“$แ๗ว ;ฬนฤ๕ๅW^๛๖ทล !>}..–N‡&.mฑญwซํ[&nC18zฎฒฤ๕ฤz]๐๙ญ!„ะ%QL&ฝ’Je,-`b ๗อตJฝษdTQ;ฯนฤํลY[ฏ‡์กP(V? œ={ถ†ั „jโC5ฝ Lnพ๙ๆงŸ~บ๔s*ชผ™uา^จผ™uธ้P…‰LF ,SไW8Lฌ]bษ> ท6ฉ$R9Eฐ…'์0็6นmลนW[ช2๛CjKด^•X๛)B!„๖ˆภ˜าจduk—ธoถช+ฎค๎0็vทgmผฒC8@-3>}๚๔๙๓็K?๗?†L&ณ๚sTฬ: i/Tาฬ:t!„j๏@!„BU ็!„๖œฬเ่่ฐ5‘ 3ด–ฎ๓ฤฺชร r$"t0`wF!ด็(MณลbP‘@ฉ[J ืyข8าx๊ Ÿx๘๛?ู“฿๒฿i›ดlFขๅ๔?ะ๗Ÿ๘ูไ?ฟ๕o?ำ\]™uธAฎ“D๑?‘ฒฅใศ‰Sgžs๚ไ nซFฒwสึc7<งหPŒ*B*š;Žœ8œ็œ้ฟกช&@a๊9q๊t .}#_ฬฟก‡4นN ธโtงถ”‡TY{Ž:sฆhgณ|yฝอz]y“!„j๙ล๑ก(8เƒใC1(pื{ขฒี๗?๐หฅ๏๋ฯๅฯฟ๓ภิณ๏z,,–ำrว>sืฑฤoพ๕ะ๗จ็๙ฺื}ไฯพณ๘Šหฌร r$Š‘[บ\Š๘๘๐xNP˜Gบํ้A๒;’ฅๆv›คฐ ฏ>ธ๎ษ-]ํฒ่๘ฅ๑<กv๔๖:›ฃใiฃUป˜ฑ๕›๕sษจ$EหŠ}๊ืต=„๖-l| กouJ"#รTk_ทE๓e6ํuม๓!„๖ฯ …"/€ฐฒฐอD–กi†ซ$q๊+ช(s{97ฏh5Q๑'๚ืฟฤ I>๗ง~๓OฑŠ8yวkฟ๛าฝ_๘๗G๑[ฟ+วn่฿š†฿๛รr๖'ฟ๚๏?๒ิ€ฑตU!šณL™U_a‹ถท=๗b๕_y™๊ "ศ&ญ&^ฬyžอ…B Jซ]>DL๊et.˜/ณ&ชูคีค#กห๓ลดoไู๑ AA2ฃ๋pฏ]ำXรโ {ˆDJ๑t6ฯqน#•J6๋u•Vฝํ Bก ฉ7œ9ำkฆ@ีบผฐฝDั2ทฌhํท—นฝœ›Wด–˜Ÿ๗GAbณšไ/๚M๖—O2ืyโ„fฦคoๆท๒„„”{Ÿ”ZฃฅพEซ๋๘?/8 ภ็i๑cิeสฌ<๘J[ดญํนซ๏0๘สห2ฮอท็Š’๒์๊๋ ’ณFPฺš3พ๙t฿|p P”T U๖žใงฮœ้?ฺeRLl1ญ๋9ั& ลX{๏!sanฬ—jจณข=Dูz๔ฬ™ำง๛O๔น-๊า(Ÿ+ฒคB%'IฅR^d‹›๔บJแ๕Kกซ>}บึ!์‡:lf†$jqrt*™ไธ๒ย๖Eหฒขต฿V\ๆ๖rn^ับฤ๙…y—ี Šพ?พI•๙“ฟcศ›ฺ์ภw’์ฒรฒf“bฑ˜๘ึ ๎็ใฏ๏:๒–o=qล‹1@4dล2’mโeV|ล-ฺฮ๖‹ีw|ๅen็ๆs ำD_มJMํVaa$ฦ‚ตlฝจbZ0zepFาไ8tศeJŽ…™ุฬHŒTšปญฤxฒมฎ๋!ู๙‘มE‰าิูำaI^^d@H.๘[}ŽอM—ซ-๋*‡๓„ะ5yมซรfึaHขถ'ภ๊ย๖Eหช"ัU*_}ื*ZKL๚็3pยfmพ้Ÿง ็“ƒ,š›%‹L<๑?y๚๕ฟo~น‰บฅE–'–ว ๔ท๖ŠŸตY$๑๙ฬ๓?๓ฤฉฎลลEัœๅสฌ<๘Š[ดญํนซ๏0๘Šห2NัฺลˆM,HญำฉŒLN0ๅ๏ขG•@X ณฌ์R0Fืจ!œ$ไ†๖n๒‡ตฮพ~™๔/‰ฮฤ๋xแูณ&หฺT*€ฯ'‡ƒึ฿้Y-œ? „ึ4ส๑๏ชรfึaHข๖(Nนฉณณ… Nฮ%jV…ฉซฃ…‡Hๆฌ‡๎๘ใeo?9ยภq€๕†Lเัp@rไm฿็ืปคแ๏ีํ๒M}/y๕eŸโรณ์ฉ๎.€ุ่XT4gู2Q`Y–ค$ฤ๒ˆฮะuฦžบ’ึ๋dr๙ัmห™ดš๙กกyz“rะ&Xvใด@ Œ=fzvิหZoh]šสุ๚-๚๙ฅhc\/ฆ๋!ใy{‡,8(-”ฝฒLฏ Vq็กer{‡๊ฐ™u’จฝ‹S"oา้Š๑๒์๖ ฉะ์O$‹๓~เึ—;ฉฉ‡< ป2‚;n๙‹ท.]jบ๙ต}™ณŸฯpx“KFฃพดnม|ๆŽWพ€๋cs.โn1ržodL8ใUtธ;dภาK S ™ZGt1กฏฒณ็„“˜Ldฺe tf๒๑PะแSๆbิใซƒะ๐๑yฏพฃ๓ุi)ษ2qฯLธ์ค`งฝŽP(ึž๙600p๖์ูm‡Bmƒฬ่tธˆ7ช๕๕Kํƒ}nษm๑๒บต/Wฃ$ฎ‘hํ.“$แ๗วk|ss ฺ^;ข๓ชD|~+BกฃTF“Iฏl ‹ชoตก๔Zๅj”ฤ5„Ro2UตฟXฆmฏox!„P™ŒXฆXG฿ฺ[๛0ZN๑๋พ\’ธŽD*งถPเj|aQ-ฺ^3•œจ”!„ะuNเ L็D่@X๛Nญ๛r5Jโ:\ฑ>v ตh{]ร๋—B!„B•ย๙B!„BจR8@!„BU ๏@h=ื{zอฮw<ตIฎใ๗œ๛๑;ๅ~ž฿^๓;‚$็๛า!„๖ ฉli๏pี2‚ฅ“‹ณณม MฎS}VjๅM$\d์ผ'U(ีd๏tYuJ วค#Rฆž6-YˆzฦผIv๋"๊“ฒ๕ุ1ง":qn&ๅบ ฉฒบญ:น@วๆฆ<1@ผืU็ํฎ๖ท}แmc›งฃต!„P[บ\Š๘๘๐xNP˜Gบํ้Ah๐ะ]๋่ˆ&GทM๐ฦBeํ๎v‡งrFซ26v1c๋7๋็’QHŠ–ๅkjUคๆv›คฐๅ"†ะท:%‘‘‹aชตฏข‰๙2ๅ{]ฅ๐๚%„V๔™๑ภo?p@๒ฒ‡@`37€ฌ๏ฮ/ไโฤ์์๘๙งบซ_ณnร~๔‡—ฆ'~๗อ7๕ฌ›‰ห{๐๐w?๑<ร~‡Bจ๑MZM:ผ˜)๒<› …”V+ฏuLŽTฅ’ฅcšๅ๙b&/hตj@ €]‡{ํšฦ“:‡C ๆ7ฯ&‘R<อs\.วHฅR€]่uตกฺK“{๗งŸ ๐—น๛๎ป๏พ๗ฑIหk๏ป๏ๅ๚‘‡>~฿SK‡o๘ovญdื฿๒—ฏVŸ—jั=๏ธY&SฉีjตZญ” 8–๎Gt5l BกF@QRž]}ฝAr๖ย่"สึฃgฮœ>ขฯmQใpmGXฆภซ๕z น^ง”J)`b‹i]ฯ‰6Y(ฦฺ{™ scพTC}Pฺš3พ๙๔†+ฆEบ WdI…JN’Jฅผศ6้u•ย๋—Zz๖ฑG#Ž7อŸXๆ~๕่ฃห๗?ศหฦ%ณฟ›ˆท7ฝ๒U‡ฺ^HฯgมUน๛eŸ{กร๑ยO<๛๕ืฏ;็ <๚Žo{๊ๅ/}๐Jร^T‰Bh๏mxํฐภ—Fฐู๙‘มE‰าิูำaI^ฎr€‡ึ’๓ณ้Cงž#ฐ…t$ล€˜ุฬHŒTšปญฤxฒฐe1uEjjท #1ฌซiโFH.๘[}ŽอMg Lฏซฮะ$#ษืทตาขขถ๎แทmP^โŽ๗ฟ็=F…Tู#Vฟs\‘ๅŠ, $‘š๘ีำOk@ู~๚ฦ ะำฟ~ฦท2y๘มภภ„BhฟฅY๖l<ฐื[จ~tU ั็m๐lYยcY›J€๓‡ศGฆ‡" )pผฤrฤฎ ไ†๖n๒‡ตฮพ~™๔/5ศ1?R๋t*#“ €t-ตLทแsมษแเ†๕w๚”œ? ่งำฎPผd$ฬlฑปฝfXฯs)•J8๙‹?๘ูื๛ล‡^๒๊Ÿฉ๏ึํธบŠ’@ฑxๅแทฟๆa€ๅ'8aFบ๓Ž๛ฮฆืๅbข‚Bจž˜ๅ๒wปw8:7ท‡ีฐ,KRbyDg่:cฯ]Ihป:dม๑@้ŽVaใัbT=ฉฆEO.EREJฅl‘สุูcฆgGฝฌ๕†ึฅฉกŒญ฿ขŸ_Š6ฦ๓•zL.?zฃm๙ณv@3?4žทWุmD{]ฐŠ308@ะ๏77|llหษƒ˜ภไdnธ้ญŸz‡eๆาฏ% rฝฝญ{เฬ)]†ixใ;ož๚5€vเี๙†รŽo๐ 'ืRไMฏ๚ุo–vฉ9!„๖_˜ayz๚37ฐท๓>“สธ,6M*˜&‹M‡ P$Z“IฅSฌDmnVeขี<]ƒิZ;[Tฬุ|–ิูZคKพ,ฐ‚w4มq(ž๘Fšฆe}ƒg}ฅEฉ๕ศI๕โน™อ•vั^W œ? จY&›งท๗ะ;๖ง๗ฟ๋k–ช}˜๖}๕ู/์ษฯ๒็‡๗ึ/ร๐๗๎๖วGพ๛ฅงšฟ๙ƒOกํอzำ{?๖โB๐ส๗>t๏ƒรซ%ะฃ๕ํGŸŽ๏R[BีJ˜aด\ป3๙เŒWัแ>๎K/-L-d >๏ีwt;-%นB&๎™ 7ุล๙๕† ฮzี๎V ฯครำž8\้๙x(่๐)s1๊๑5ฦษ‡r๘สปhฏซฮฺ@X๘้G_๕ำฎ%Œ|ๅฮ฿ส๊งปเpๅพทว}ข„~๚ํะžFˆB่ แ้จg4ู๊&ไย3Wย/Snlsุˆ7ื9.โ คธ*ืHดv—I’๐๛ใัฤVดถ…ฯ†ฆFฤ; thโาธ๋น™ลเ่น•ฆTmฤz]๐`!„BŠDm0™๔J(•ฑดPUโBฉ7™Œ*ช\โ+ฺNHตp4ณr„BกX000po๑D๏ฌ\yฮฺทŠBํขฝุ{๏รp‹ศd”ภ2E~eซ&q‰TNlกภ ข‰;ฌh[!ีภuาฬัyU"^ฟ„B!t \)FWชI\‡+Šคฎ%๎ฐขm…TืI3+‡ื/กฺ๋พภ“!„:p€B!„ชฮB!„B•ย๛ฺšZ๑๗G,ึ|เ๎KพูZ๊?t๊s7—–Ÿx‡/ฏi4๛Mฏsผฃ|DA๑,}94๗•…Tชึ!5 }็ฃฝf๙๒‡ฤ็ž™๘๕Nu.ล '_ง^X~ท?ทร๋˜๔—zแ}C~_u๋บ๛๓฿~เะใovพใฉฝ ฎNษmฒฝkํs๑‰+Nื.žzE*[ฺ;FตŒ`้ไโ์l0รŠๆ๖NgณFFฐt2เ™ f๙ZวูH(ณ๗ˆž:7“XIั:บ:,Z™O<ž`–…ฉงทMKขž1o’ญiธ; l=vฬฉˆNฌต๔ฺDReuป[urŽอMyb @™^W9œ? ด)ฉ•ํญ/P’tผT†yๆห๏{฿ใฦ›๏G^ๆฌu,๛ะฝฦํ8Mคห—ท8nq๖$า็ฟ†ˆj$๓g˜ษ]่า์…๙™$ 2ฝอฆyq๕ฌษุ~ง ‘^P['„L๐_Bฅทเ๒๓๙S—ไ–.—">><ž&๗‘n{zะŸ•[บฺeั๑KใyBํ่ํu6Gว# ;ฤ_ sWงMGf3ฬบDา่๊6ะS#ำYR฿qธป5}ษวญสุุลŒญ฿ฌŸKF ) XถฑฆiRsปMR(lžH่[’ศศล0ีฺืmัฤ|™2ฝฎŠŠ๑๚%„6%Qืฐ?๒,ฬnlI๙g๘ฬ๘B X˜Ÿ} ๙น๏สS็ว=ำ#ฟy์พWธฅpžsภะง^4๐ว.NO เ}'ข9แฆฯŽฟ๚ะ-ทำ\๑LๆหๆY฿_ษล‰ูู๑๓O=tWฟ€๕๏wฟ๛ 'ฎŽ๕: S่นผ7<อเโ7‚)สฅ’@๓ภ_~๙ษsฃ3žฑgŸ๘็ืUภ๊–๙-Ÿzbhfโ์ฟลaj5๑๗@~#@เo2ืธE๛.—‹"๙E$่๛เฏำพๅM฿บ๐ะํฯป๋ฑหฃฝฅฤ๚g™œœ/๙E$๒‹ฅ|cหญšD๗zW ฤยฯฎ ซซ}ำgฦฟภษห๑ฯTณvิ„ภๆวาฉแD์้HlชXๆป)พ„ๆw>๔ิ๙qฯ๔ๅ฿็w.=o^ไ๛ะศ&ญ&^ฬyžอ…B Jซ•—#กห๓ลดoไYœ6ฝ1ก๛.]zฟ/„ฌ_ง€,ว…๛ศฝ/m๕>z/ะy_z็แๅ์ฦ?}๓‹ขว฿๖‚ฟใ’ZF^ทT7=วelทs—=”า nT•๋Ÿืๆฌq่๛†<์์x$๙ o์ชKo*๚jO>v๏Ÿ~*ภ_zไ๎ป๏พ๛ว&kำŒZ!๕ฎ9q๒กำgพึืzheะ!ผj(แ฿>|ฯญถ™o}๚ณ?M}อgฟžฃฐษ๗ฝQQ””gW_ฎœฝ0บศEIRe๏9~๊ฬ™ฃ]ฆฦzทXmqูx$Ioผ‡’ห PšZ{บLสBก “ษ€‰-ฆu='ฺdกk๏=d.ฬ๙R u(Diokฮ๘ๆำย‰\‘%*9I*•๒"[(ำ๋ช๓„ชวŽ๒ฟ็๓้ะœw.JkOพ๊fc$อwž์ืBโW?x์W๓^ช๏ฦำห†ง~ฉw}ๆ ๗}๛ีาฌ‡๒9!๔ฤง๏๙งฏ|๑G“šฆ&H<—v็๛>๛ศW?๗๘@[›ฃfmฎค”ฝ๋ำ'OตIžJ๛ฟใ ๓dฟ’?๙ย'ฟ๚ะฝ๗ืฟ๒ฤœd๙8Jโษฯน‡;็ไ6ปกถืฉยo๛สณ‹ภๆปŸf@*ฅส๕ฯksึ:๖!Qทพอ"Ÿ ฬ%‚l’R2จ๐ซz๖ฑG8œๆ~๕่ฃ>๚ุณกฺ6h฿šœ|`r๒)ฯ–X}“๓5&i้7โ฿อซv€'๛๕ษฟ|๊ซ_๚่รฟยuบ฿ธษ๗ฝam˜@Yˆาx™ฺปTศึ:๛๚]Ldvาฟิ Š‘ZงS™œ`ค›'Ÿ N7ฌฟำเp€P๕ž๛ฮม๖ค๋แะบMกPHื_ฟ่g—–ขะ-ถบhN8ด–A(dSฟ๔ƒŸ}ํฑ_|่%ฏ™๚ฮo่x๖กษงjI22๑๎™ฤฺฅฆ ) o}ฮหN่|ƒOฎ[‰ข$P,JcŠ’&Sห>ว0ฤ๚ง๕ตฉ–R๑นOาฅ•ช[{ฺNฐัฏx‡\bYลฟฺภs)•J๋็ฮศšป๎2L๛.},XVุ0jY๛nฎทฒ,mฯาW{%'+}๗งE{‚eY’’ห#:Cื{v่J˜8Œ„๚y†G#b ษ–ฟ€2™ฌP`€2v๖˜ู้Q/kฝกuij(c๋ท่็—ขฑฅ•zL.?zฃm๙ณv@3?4MŠ$อำืฎ.ฺ๋‚…k3–ƒ๓„6ง8m3ด‚าIPš็lฝน๘๓4 ฎ็ฟๆ๖%_Qเ˜ค๏าo/ฮ็=ƒS๐Š—ฃ๛฿๔—ซ฿ฏy@๔ศฃhฮ฿Šd$% rฝฝญ{เฬ)]†ixใ;ož๚ส\๏ซžk7œ0€๓yฏy:u๙ษ _ฆ(ฉ &mบลถ|ฯ$ิsip nปๅ]๗Nvรฟ็/_่k๚บ็ฝo๚ฆ~๕ๅrz๑๒?๘yDo์cฤrŠกŸ'~่}oโ? ๏๏n๑|ไแป_zช๙–ท>๐ภอฅว^๗ภฏ›yp่z™?@ณ~ง~y9ฬิ๛๓ฟ{หงฝ๓ตˆ$ํ๛฿/๒งนา๕K„๑ิ>t๔ฬ“Ÿ๘เ?]€ว>๗ต?{๐ตวž๏วฟz๘แ?RปFิ1ฑ)ปฮดMeฟฺ์O๏ืื,ปU๚0ํ๛๊ณืห๒ม/ฮ*฿bืY›ž-าฟ๕อ}3มC€ศwS ำ๕Šฟ}๋๏9อ‡ฏ<๖แ|๎"ˆ}฿[>8ใUtธ;dภาK S `B3^egฯ '%0™ศด'ฺ —ีิ}็™^s้ฆC&เยใฯz’1๏ดชซใXฟLศ'S YX>/๙x(่๐)s1๊๑5ฦษ‡] ฺ๋ช@(k>8{๖์.Gˆะพ๛มภภm{ู“ป๊gฟ๚`ห๗~๛g  8žo~ใ5ž๓บ๏เแก:ržs?~ง‘฿#vf็๚ค๏|ดืœฯ=e “๑Llง%’vญพP[ชU9เ๏Cปคัพ›{๑e†[rc›รภFผผฮ้4po ลญ%ฆธ-rฎ‘hํ.“$แ๗ว ›—นรฤ*Bช…=m{4ณDด^•ˆ7"T5฿S฿xฒ๐โ฿gžyๆ™๙า‹rOํ…“ิŒฦ๖ป{z๎๎i=ผ g๊ฅ7ถ๗ำswซŸ ƒP]‘จ &“^Iฅ2–ึ'n™s กิ›LFตe™;Lฌ"คZุำถืO3+‡็ะดื็B]'๔!‘ษ(eŠสท.‘*็:ฉœ"ุB?{๗Eั๋-—หฅ๗ค7)ข€"ขข4Q@Š(ลBฑ~(Q@คQI  „R/ๅBrน^๖nฟ?๎Bฒ—‘๓{||Žน™wv'ท3ปณปํ็ูษDkB๊Z๗พSM#Kฎ? ๛AA(„^ซ1๖F›?ดL์hษ๔บฆิ๒์dข!๕‚๎ญ{Ÿฉฆๅะ%AAA,…ฦ‚ ‚ ‚X AAฑบAAคืPุพB.รU’ชทซๅz†๋ภho^‹e๎J-จ๏ต–ฝทŸง=แ*‰จธจZa`9…x๑)ฺบโIฟ}ฟ=<“U—ฯซโZ%R8.๎ถLBuงด ๘Ž€ดีYS,? ‚ ‚๔ฆณฟซ>/+OIฐบษาห•ต๙ื๏˜ž็Iต๕ sQ wซt ำู฿›Q——‘งฦธ!!ž๖uy2ก ๛N๎uนkด“ TRG…F7๔vจVก;yปRตฺ๖1ป'Uœ}ฝ–ๆ่ฬปS&'ouึ<‡อ_BA้%>OV[%ื ธฒฆฆฦ็3ะ๋ด&4{WžคขZq๖k>O&ฎQโƒNV––'ฦร0ภ0Œ!๔ qใ๕ฏn1ลึรƒ]Wzoใh›Hฅำ *…ZฏW*5t:ภLซณบ€ ‚ าKh4บืฆIn_“Zœง\]ฐš› ๋ฌxŸCฃั ว-ศำี–Aจ๊ห‹Šล*อ*YPPคPSSŽป…4ฮษ๛ีvfปyูหห2d๔ ๖๕:œbวaRไ46S‡๋:ju่_-AAษ=ฏ& ขล?ฉvN๖jฑM^๊, (|Q™“~=ซHฦ๕๕qคh๎eงgไืฑiU๙y"๋n่utGoขฒ๔a"!ฉ,78…EG๑eฅีrhฟีY]@L‡VI$ฝ ‚ า๏lzชจvzn฿ฮVีPฆ้ฉP\ตี œผฑ๚Ž*‚ว…Z ฦด๓๔ ี”ื๒=รข}4โทส๛ษิพง'[|+_@o? ส๊[Yี๗ฌoํxก54~@LSฺผzAบUHHH^^^oG Hื˜า๔ก๙lTwมqœBฃbฆœ›"3งฺx๓+ื–ฏoDท>tŽ฿;, hBฟ 'ีํ›%ธห ๗ฦ‚Lนkดณ ขฑฎณ=๋žมุ2˜ฬ ฎฆ๓y™…’ฤฬ UีkuAใAA^bKๅ>ฮฎฒ=๏ƒฎ๚ๆห[2ื๊,„žฟ„ ‚ ๒@กrํl hก๑C?Jผ c …œ?ู u๏0‹ีฤฤฤTtื)าNLD๗O#= ? ค๎8 ๔@w ฃ24ื่ M๔'ฑ*IรpญV฿ห‹zฃ๎ฝ†ด}ถJ์!‚ ‚ า…ฝVc์6่?‰-่udฉ=ฏ7๊งก๙K‚ ‚ ‚X AAฑ? ‚ ศC‡โ;mฮผ๑D๓˜ฑ? HŸเ:๗˜H$JZ่ 0่ห"Q๙w:›iฤช+"Qๆ†!/ษถOิไ‡I-๗~๘,>'•7ถ7ส๎1v1๓พ9™šSTt3-i‰vฯั๒]cYื–๚โ~งธŽYณ๏ฌย’yWw<๏ึแ้Š๎4q๕—}ฐiร4฿ฎŠช3zฌ%๗It—๑ยฎศ‰๏;ศ•ูAaa‰๑vฆ๎ี1$a€ ฝ้KถGxŒฏ-`L;๏ะˆ˜ธ๘ุ่Nœ๎ํ,าxžใใ-๘E$]า๒ี-‡๏=(ะ…KmgA หw@dl|ผqQใVขpEวลววF pๆvอฆณ4$Ÿ˜ฤฤ„&ฑ~|๓qv6ขฎศAฎ1h๔(งญ;๘ฃFy๔่อTšพ_ฒไ˜pฤk&y๖dน่v๐ 5}๖#๔‘ณฆฎฺ!ฝต]o‡ีี๚[Š}ำืตฝบใW 7k{;œ๎Rฝ{ๆT/Je}?้จMกbl ก๔’นฏภ–R]gบญ-ณQ$`8๛๛q$๙Y๙Jเธ…๚:Irช;๛R,'?W[ŠBฎนฏ%-_rกO ช ปPA๘†บห2สฬผœ้์๏อจหหศSc\O๛บ<1Nw๒๖fิ็คWฉ0ถkP˜c}NMgๆ- TๅY™•ชใ์dH่๚‚๔!"jิH[—QฃB‰ฆGีู~c[าีผโย์”CŸ  „ฝsQTธe๖ซ3ฏmŸ๚ศœC7nšํืnถv#ืฯ(ฬฟำซA4๒</๙๗ภ'ฒZฝ้>๑ํIW๓Š o\>บ้๙PPŸฺ^*J^ฺดภใ_‰า$-ึtBqLโาCื า/‰b™)}ุงyขK+P'ํ‰DขผO‡็์ำiฟฎY๚้ง‹–~๐๓3ี !ภฐอy"ัล•OL๙๊ฏœโ[)฿O๖Fุห฿žนž๛vีคํsขyอ๓้'6œฬ,สOen่๓?‚a๏~ฝ๐Vฺฏ 1ฬ–๏๐ศโ็าo็_็๗-opฃ€๓ฌ฿E"ัม™ฏ'‰Dy_Œ oฏตiKญ[ˆูถDยฬ~'ษ“T‹3ึฬ)?ŠDขรฏ:‘VH[ฉ!rDขฃs\ุฑsพ๛-o š ‰tว‘ขO|ฟผาJ‘HTYQ!ํ{=๛ด๎$<_O‰Deน—<ณs–ฝณ๕l[ๆ~‚บๅวชํ–ท}๒๛ขฒณoS้๑๋REฌ๔`ž ล˜B฿Qฑ๑q1!|S›ฅ ผDฦฦววF„zฺ6ทcฆะ'426>>6าืฎฝำๅ@X’ฒ*ฅญ€gLะI$*>Ÿo|ญ-W*‘@แฺศkซไ:ƒA'ฏ)/oิ4ฝš€&๔‹Š ๗ไwัป tŠqinn™ฌร,้’–ฏn9พPจฌฉ”j๕z๕Q…3 Rl๘<™ธF‰ :YYvšฑSฮคำลbn0่๕R “e๖'ฌBฒ"ฮฮBใ้;nผ5x๔3G…็ๅs๔?ฎš`sq๕ฬy฿฿yeหw๓Œวzฮฐx:๋„Usjค‚!%ด๓c"xbมt๎ีห%4๏1ซ^A5›g[ฬQ๏๏Z5มต่็7)๘ยๆo ิ—”T‚ซซ+g๔Gž7๏โย†’า๓ฅ '-™๖๗้›z็มK^C'/ึกีห>N2~\ถlูฒี‡n฿์„B!@}}=ฦs๖V\๎๋ฏป.5}ๅ1iftแฃ9฿งๆ?ใฮ36n|ZฝฃIก>๚d–Osใgฉ;v$ำเ๕ุ{ฏ?f๊)ฦญX่™“ZLqฮ‚1f๚Rุ#๏l_๑ธ๕O_sž๋ผ๐Pิ\พT Kเ N อ฿R๔`ถตiKm[ˆ5„tฟw2OฒjZัๆ‹~_ปlูฎซZ€ฺณ›–-[ถ์ปi{!ตฺqคhฃ—|6=ผz็ณcg๎)”en}qศขใ*าี;น฿I๋Nช๏/—-[๖ร•ถ'”[มšำถ…tหู–o<ังua ืญ\น๊e/ั5_gwa฿ฑ๏ :๘๘sฅ™Wฏ(ำ:z๐๘~ถฒขฬซืฒEธ“Ÿซq@u๔๑ใษ 3าาา๓kTํฟ&ใ xR‰T"ัุ ุฦ$Dขณตๅฦทๅห%=F'๐ฆ7.เา๊Š†ฆ๓๛t6Iฃsxฌ.๊>๊๕b‰ส’หํคKZพบลhLhต„{ฟ#[ซี2ๆNสะht‚ยq Šˆ‰‹‹่๏h|›ผ<+ฟึ๘งEใฐ8๙kฬ–‡ภvfš=Eggก๑‚๔U)ษ._Ÿž|ษุฟ๐‹ŠๆCรลร‡.ต๛๘u …%ฤrด—mKซ}สW@งทsM๖ืง๓฿๙p๙—8vf๓lห/*Z’3฿l๘แปตป.ๆ-ผ]RlWืมLŠ5.1สลคฅ%๓ฅKOoX๘้ึ{ฏะ์ไฅืคฺwŸM%…bถงŒ…ฯ#*sาฏgษธพ>Žฆ7…ษw๒๔Œ๔กื”ึจ{2$EEvzfVVV๖ผ)หื™ูNœ๒`^๕C‰y+ๅ‚๒ตูทฯ'Kž™ ภ`ะ์ฆํฬ™ˆƒ\Ž™~yznะแ8P0Š™<ษๆR2˜ ‡ฆี™Lฆฌ๐v ิ๊๊จฑฅฮp๛vI;ฅใZว๕€a˜ฅ?xšฮ ชSพžทAษช'(๚ฆCฐNงัฯ†์ว4 0xG>ฟ๔ญว‚„,:@‰5Ÿ."๔z๗ฆ1รบ:9ณy#“า%mZ๑ซป“—~;|)ก.ฝ๐๙‚น฿ฅซฎ]Jีอx2>ฮ9ฤ9ั–ธz/8›ฏA›ถDาB:ฑ€ผีYฑ:i5;ฺู๊ ฉีŽ#…i%ทEช๙ำnจหSvฌ‘y7ฺ.๏ไปุ๒mะ๖ึr๒cefห ๖๎ปฒlใๅ฿Gฯ3OŽ)tโ5Uาแ‚†aDำDV‚ (TžK€ฏ‡b0 m—์W ` bใร0ฉ€VUƒ€\"aธูา๋้ถI๑Bƒ);ฝ8Š๘>ัพอเสฑฒหjู  ร๔wn]ฝ@sฦ ณ–ขฑถZ€7V฿QE๐ธP+กฺ๚ hฤี5e…ฎ๑\—‡dภตS๓ืT฿Qธr8 า8;บ€ }ƒ‘ฝs๑าEk~ซ`๛'Zญ แๅฃG=<1&&fบ๛หšFฃ€Nงต"OญVืtบฐiuJJKภu๔่ซ{๖–;/)ญฐ"ณฅ๔z มไฌกพภฮNจฏHKบ%eˆชช๎Y€ะ*คRนFฯ๗ฮๆแล[ž}b๔ŒdSน๎๎M+เ๙5j๚ฺำwผ[ฝx@}๙r:@xฤƒ} ๋_–4ฏVmฉu ฑN›nyžA˜–มฺซf'Ž: ฉiว‘ฏ>๘MฏพŠ๖๑๒4๔ูต'สZ/ืe๛t๗”n๛ฑ"ู๒ฌฤ%ฏัใ8wย’กอM‡ุg—2ำฎe&- 5“sฟB4เšF Go}yVFFffNฅผyIhนd{y2}Yฦ•+Wฎ\๙/ฏŽ#7!•4rl์lฉ‰qh€ใ8Fฃš๒ข0tถฉีQูv|f๗๗ฉก“ฃmWอ“ฒฎีƒajV Cซmพ7ปUH8๊‡€ (vฎฮฺฒyฅี๕]3xฐ*$ฆƒˆ[๓Ÿ=aผŽDgงก๋าw0”’ฟ๗—D>iผ.]œ~] ฯDฆTEฟบโiฮ๏ห^8meฆฤ้ f†zLM(หฬ’ๆน้Šหˆ็ปูE ภ๓‘^เJoœ:Q™)…งŸXธ๊VจํไDQf–ชn—h8Qฅฟ‘\๊าW คไถ5]Fาา/ฉDทnษaะฐy^wฎ€าc฿-ทฒž}_๖?4ผ๚๔๓~ฆJฑ7‘C$)piป …JฃSเๆ˜c+ืุ$พ๒ฦˆ‚dG^z๓•Pื) ู7ฌ9ƒฤŸฒฤดบƒวR วdตตjจพtฉโฟ>[ล_UาAญฺR Y ก๙’ดฅ,sกถู๏คy’‹ลžOผนA๛๊ภ'š๎= ญฆูVg๒B,]]ญRฯฃ/Lm,ำzค,ใา๕ า ๏fv1 n่“ข์ƒi‚๐q/ผ]–ฒ?ูา๚˜ั?Vไ[žฑไใ—o}๙๊๎ม6พฑ๎ฅ_ง๎8ŠrฅPD†0 ท[ิ“ิ*%ำัžW#RR๘B>กฌำ01ŒJฅb…nใdห4P˜,*Eฃืจี,กท7ุธธ จ`ถeำบฌฬิ๕”ห|ซk นฏทQ_h”dนณOVฅ$ธฎฮ|ฉธ้wžํ์ษIqZ^mทNabปyr@W๒ฤ]ิ ทดกมฯี฿ RPm]ฐ๚[M—[Z‡d5*|œ\ธาีฦลž%)h4กีv๑0‹CาTพฃฃmJŠSนN๖yยLœ†ฦาwฐšฆE4ฅ9๗ฬuดตฏฎแiฆช๊ฦ้ปชbXlขขรo๕š5~ุโฦiซsฎ\ฝ% H๒fผM›Fื qำฆ‹ถdžศ๚๓ƒ9Ÿณ้ฅUฑ†ฺœC๏ญ๙๒:”–”8gfฮฌผฎ{ๅ‰า’RkชHV#ภdแ็ฆ>ท๒=Uูiโ๘A๖็šWืa๏ฟ2a}M๚O‹VnฝI~U๚฿๚sมKๆ}๛yึมงŽ;ฒfืฒงb์“0aฬฬ๗žดUZ๗ฮW—ฎฯ<วจูฯพ=ูหŽจหcรัไ^พ,Y<ี*ทห5ฟ:y["k!\าถdnะvฟ“ถ:2U‡พ1yหŒ๐G=ฟXด;๙ๆซiฎีYFeqHค๒n๛gฦ‡หฟc๚ทฎ๐ซง„ฌœN๎wsปธ-แˆ%›ึ„€๓˜e›ฦภษื&—XSฉถบๅวŠdหSๆ}2?ธแ่ฌmg<๕อŒ?—ฎX;๑ุใ •)Iื๋Bีฯฅ๗รมล!(ัtMY–‘%Rใโ’<ภH7:hd5…Rะˆหk„~Qq>:YUqmวเ!S%. Dน*ซ D ฮๆŠ  ์ธ๒บฆฎฃ^&ำx ๘ฦงธโ‰สŸฏ•4=ั45…ลL?AnLL'‰›nึฉœก๏่> ห โBœŒงึƒA_›—V,Jฎฦ้z…šhwIsซw‚NI!ว฿7<šAจ%ข‚สๆฮv›45E%lฟ HOก‘‹ ‹๋pวDวๆ์๎J-จ๏\D–‡dจฏ(๘๚…วา)zญผพธจVk&ฮNรX-ž,•˜˜˜ššฺน"Hฏ:œ˜8ตdคg…„„ไๅๅucซฎœ~ƒ๙ใิˆU—บ*KŠฯะgcœ)NC^}๛9l๋จ1[ศ็^๕2Eg/พใppิอ้Z`…พ๕ำ๎Š฿z๑WKฯvร~GฌาิB๚2า๖ู*]@yH๑b^h๓Xฆบ:๋๘ฒทฟAƒ‡nQ–ด๛ุ๘ฅใพ๗9:zUmฉ๗7๑p<1A? ‚๔™โ6tm–าร๓‚wm–Hkบฝฏ?พ๗ื๏†Ž าI่๙K‚ ‚ ‚X AAฑ? ‚ ‚ b)4~@AAฤR=|ดOL˜ h~1z๎ีb)…๋์๏็.`ำR"บ]\ฃธ๗นย|฿Xouvv•†$G฿ร฿ื™ฯ ิQqqตBoฎ RคฅSX๖~ž๖<†ซ$ขโขjEB”ฎ IDATฯพพAบDุข#ฆฺ฿}ี฿ŒX๛i[ฐ๐ะ๗ฯ9F)1ใฅŸฌzฅ‚ ‚ “ž’ช<+ณ๒žW๗ะผฝ๕9้U*ŒํๆใXŸSฃ3ทz[กO ช ปPA๘†บห2สไ‘"-้์๏อจหหศSc\O๛บ1แnฆ7ฮ๑}cน2M‰๎ถแฑqฑŽฌvsh‹Iง5Šล `ะ)๊ฅฆ้vLกOhdl||lคฏตี๙BกฒฆRชี๋ีwDu rฺ+Œ&๔‹Š ๗ไcํ”Nฑแ๓dโ%n0่deูih๐€Je ]ฐ๚zฅ™‚€ํ0ภืม”%i้Yฃ‚๏ไยฅQ(L[{–Tฆy@Pi4—Mฆ  ฑNJ{ƒ‡๓žฒb๑„(/!Mื(K๕(/*vŒJ๔d0ฆฌxF:}† ‚ kฏ?hkหDvข\T5ลU๕Nnอ๙ุz Œ  ิUล2sk๊+Jพ~แฑtŠ^+ฏ/.ชีo6p Itl^๊ฮญิ‚zธ\$ ๅชฌ*58{˜Iงคใ๏อ ิQAฅย\A S+48C๗– าา55E%lฟ HOก‘‹ ‹๋ะ๓—FีฉG‡ฏ๘ํฬข๚Œ฿>]พi'>ƒ9 ฒž;ฒํYใ฿มไนP๘๓ฏRูW@›๕ๆๆื=ํฉาย‹฿~vขdI[พ๘๎ฟฯPUขด_>.Bท!‚ ศรcฑ๎>n511155ี๚Ll|b|ต9Y"u† ๗๏pbโ”๛iษrBBB๒๒๒z; Aบ:  ด#tี๓[AAy๐uษ๓—d%ืฒบ"AAA๚4tAAAKuู๛คoš! ฒ]๙๙ฝ‚ ‚๔(tAAAKก๑‚ ‚ ‚ –Bใ้2œฐgŸn฿{งOฏ๚u๓ำร9ฯ1xฒ V.Š์|N]V{์ฬ ึ๛๐ฑnŒ4„จลKบฐ~๏<ื6_ัyoอ…#ผ›์ข7_แย๚=ณ{2Dr์‰›““[0๒รฟ“Oฏˆiฝ@ิ๒“;งทญUKœ/|ำ๑s=๚อ๓V•>`แก๗฿‹ษ?ฯ๔พ็ ๏™ป, ท&ฮ๖‘ฎ๖ป_l็E>–p๖ปคS๋ฦ๐›MZ#ณีด,NหY^MหC"็๔wgW ้าเ-gถ 6อฦlขๅy"า_ ๑‚tNโธ๕ "sสot8๏ฃวcฤ๛‹ดู)Ÿ~๚๛๗zฅtaศ๗ถ,˜?ื“~อ }|#Lfฉ้฿œaoŒฬ%ˆž ฐ]*ฉL2™ @*•?X‹5์ฅ๙ณoLzb‹๏(ณjี›[ง>|แ‘๚๎Žณ ชIฎ๚Ÿ๏?๔็4iำฟIkิซiyHQz,จว‚Gคป ๑‚t‘ภ๘ H’พ>ฒs็กฯฟM;•"eุฤ_ส|}๋สำ'๘Œ€>๙mV'~o๏WO?้G}eaRา๕๒UmW3q#Lyพ๛๓—GyQอ/I‚ํ็?@qiำฯ"าWย๓†Gf”y4ถแฤ>๑ึ(๘๛džฒฃX{ŠT*ฉT •J€โ:|๑–'ฯž;น๙ฆ‹Vืแ‹ทz๒LาฑŸ6Ndเ๔๖ไไsk†Q"ๆ๏;sแBา„‰๓ฟ:tฉ}_ฮ‹ณ3ฎ๒,xปื4fํKN;7ภ๑ูo“““““Mk‘ฦูษjๆ0โ=งฮปn‚ท๑ุ#œฒ๕์ชงFฌุ๙วู3{฿xศL’“๙›uฏฦ๓ฌŒHทgV“<$ท‘KทŸ-0%zŒ\๚๕ฏ'ฯžO:๔Š1žญV็&ผ{๔๗U <๋‚'-ˆtห[ZMาfCšศป้๏๏M/ถฟน๛Ž- วฌ Aพ้ž_'ว™Lfo…‚ ›ญ-@ูุ{{Uf๒พ}้7ๅฆฏœGฦ(ป~พ๓1t”ุO˜ฐhปเทค’ี~Ž_๒Œฐ)ฮ๐g‚%eๆ์ๆ‹7yฒ‡อ๎RTRNฤฮ:ุฬ5 ,jฬณBlnž[ท๑ฬนฬ`?&ฒŒฬ:)ฬˆpะ\ษ €ํํ€;>๚ฤ'ฉœ๏›ฮ04dz ๛ๆmU8xะ8 0ž\7o c๙•ปsฑห?z4ะสmาถ Fโ“๋็…qฎŸX๕AJฅoยปk๑4ณ$i†•vผ๘ๅ ้—c(™ีรgึโh๖งถg† “ษ 2™@&“5vๅ=พ๘ฝะ์ /Œ{rฺสรทMใ"ใ‹W…๘๐น''ฬูญz๎™กP{pะกใ7]5œ_3t่ะกCg๏ฏ DฮZ™ณ~๚๘Iณ๗ศ'ฌ˜j]@ลป^:tฦ…โ฿ :t่ะW~ฉ0g'ซ žใฆบŸ_๕๒ห๋ฎผ๕Rี”สŠŒeX๘๔ไOŠฯxร\ฒพxj่ะก ~ฟฯS๘dณgซIาขw‚า?zaฤน฿‰ว~0;›ฑoญ ษ๙dๆฤ'งญน์ท๔อัkฐ"็/‹ฝ๔ษ“[จR~๓ะSG2s๗ ตตn›ด-ศ#ิ“ช๋g3ฎ—๚w.Pผรุํ„d ๛๐วฃ iPg<๕Œณ่เžBย†GhCว:ศขปีฆ๙๙ฏB !๋ไ3น ฏ @๑ฅณ7u:yiq•ึธ g``ๅsน .พp๖š $D`&GCฦ– we7จUW2สบ-ฮฮฏ.J๚a๏•๒:ัฅ2 žMƒfuFRRฉส หหสUณ›jDพ={ฒšd!‰/ป!ัจซS.ค3ํภร?@œr:ฃNญmฬ=๔๙Gวo฿3 ‡อZ฿ว__Qด[บ…ด๒ึUำB—Rr#ใb้ถ ๑n)3 ฯAลfณ๋๊๊Z&s.ณผผำำ388˜N7?IA๚ชิิิ,พi–=žพwvคy`ƒ้+ื€๘่ฮ‰ง1ญ n๎c_y4ม‡หคานjฌE ภ(ฆพƒN"ัะ๔z€ปฃ”ึ๐”๓›Oฮุุ๊วM•฿ตBs๓vฆ.vุ@o{?›pโฦทภ'_ภ€ใ€วMฅำ้ดฆOc_ฐN`่ฝz ณ€มfw6O#ืัQuy๋U7"ฺ‰BƒWฟY๙ช๑฿Sg๖}Š๋ฮป๊NาŒC?€ๆๆ฿4ฆัh4ฝพ๕ํt:อm๒ง๛Fใ@cฉE9f7<'d๒šๅ้ธใ9รี๎‹ณ๓ซ7WSฏืำhญ/คUถไ5่ž‘oฯจfหš—ฤqœNฃ๑ฆ{{E—.6/อ๓VJัถ็ฎ6ท_‹ƒ'-จฅๆ-oU5-U›’RJ สea|p๊™ซ๚ฎศณ%&&๖vาำpฏซซ+--m™xฯo›ม`(--mต‚ ‘J•l>฿Ps#ทT1 ^,hq๖”ะiๅ: ˜ฬ„ ‚/฿๘้2'๎“om3๕˜Bฅ€k…มk“>๛ฬ฿A_Y6~ุผ๛ๅOีํฬ<โ5"ฮึD'Sะ๘กu้:€Iฃ5'pาฌกำ้Toฺบ#ว˜ —5๐gt6Wp๓ธ›2๙ฏKฆษJส‹฿TfผV0ไรนฒ๓ว6,$Ÿ๗ิป๔z=…j*RšฦŒ8Ž—\:sOyGk;_8M๙ร๓ำ.ส ย)[‡S ั6Oณ „‚Yvฝ‡4๖ลกnชผS๛/U[ด)ฆรอตn๒u’ลำจช 8Ž7๏#*•ŠใxซD วN€ษ๋:ีูีฯ0oุ‰.สอไhMA]€ดู$Š’S6ว‡D ฅ'ฏ๏่7๋่จๅตณi•ฺฎ‰ฒซ๕๒Y*้3ะำาEnฅJม๎ษ7&ฝ:็ู92ˆา๒ Fฅb@g;น9†?โลUโœ๐„้qฦn=+jโฃ“&?1q@จะšYมผ1ฯดyโ๔1ฎlะ๋๒z H32๎wฺdw(ฟ๕ŸจŒ™7kึx'…ุ๊jืลCHงะ†ŒŒาบcU:ษโํiิี„Šขb็ฤQกถ –ำเ‘๚ขข:Sโ'"์™tฎืSํ[ฤแพ๎ๆฎO {๛อมึN0&-จ 6ฒฤา”d}+Sขr/ฆช;ศำ๛ูตVผปy๑Vืฤˆ HwAใ้"สK'WŸ%ฒ๘?z•Oทˆผปชป๘๓™ิj็ฉซ'Mโค.yDฒมcไcณ ‹Ÿ7?สตๆๆถuๆYSบ>ฦ฿ .ฟ๔ฺU…สฒทฏ>sีPœY"žฃ#ต&5ฏุ๊ๅgฯ๎๛ปŠ3bมA‚’๔/?๘็€ๆาฉต?ๆ๑ŠŸ7{  $cห๛r‡,[๖๔ผš๐๔ฒec†Y๓fm๊ฉU฿g+"ฦ~๘ั3“<ๅ™IY9V]๐œ?์๑๎t~ิ#๓็้๚x„gC๖ŸWษฺ๋งี'm฿g˜ผ๕เ๎•i‡SLcFYา–/ชG~๑๛Ÿg}๙๓๚ต"s็mซNํ8สท3ฟo}™r`๙ฆšงถ}6ลฤ'พ฿ Sถุต"ไ๚‘‹ฆ<รINNvฒะw๎ปZี…_‹7๎?ฒ๋’กŽํล*vา็z ำ๚ํ|๛ฬ๎4ฏ7w๓ฤฎื„'ึ๎ศ4๗P]๒…ฟ‡1๘€๙ฟ&''Ÿ(EZ#าD‹ทgทT“4$iา–ฯKโ?:p๚๘oบ๕แŽ๋„)ฑ0โฝ='ฯ๙z’j็W'[?4ู>KŽYถ0ฮบ7หิH› ib~JŠpHB้ลหN””ฌhl(ฬ/๏ฃWi‚ฑXhœ”ชญ๙‘_ิม-&rค๖เแ!ใิpdc๒ƒซ~Hชู#ธฃึฑ2J’{‹ตt๐€ )ty๕ห๋H๔P]@‡บ€ mก๛AAฑ? ‚ ‚ b)4~@AAฤRh€ ‚ ‚ ˆฅบh@แบ… 4 lะภ g6ึ5y"HภฐฑฝFN:ถmจKป‹pB‡ญ๙๎้3kmyฤฯชฬCŸ๕G็ฯฏป๐ใฏ{พp|iวŠ…ƒฌถOรฬ‚ H/bน„ลล:tี0yQ ‰‰๎์.ส้ 6>1แnคฯ0jฏ…๐}cน2;S.฿+ฤีบทศ้ข๑Whฏญธq3'ฏŽๆๆุัหNค`๘ูธ จทฃ่๔GfŒแŸa๊„ฏฌฝVfีชนงŸตvิโ+ ZŸโ๖ศชE‚ŽA‰ฆพฌธXิˆwQv๒า๔๛๏fuปoED๚“.n!ญะXf็{]4••gหฉLžƒ€ญ—๋์ใี%ก;ฝถHฬ๑๒ฐi,ฬ.—ภ๚๘y9๐่Mcีํโ*nvI้Vt๏„u_Œ‹บ๚soาU0—aใWฬ uฑgซ.M|-1a.tP–eิ+šz4[@'Fฃเ-ฆฌฬธ%ๆ๘ฤ๘๊ Elo;X~ซ FIะ^>N<hd5%…ๅๆว dฅ#}ฦ๚๙90t’๒‚‚%aฆ…˜:ฯ6 ะj TCUหฤ–=๊ิEื่๖‘ั\ุ๒’‚ชฆWิ๓˜šโR ืหซ(ƒPภ :๚๘๓ไ…้iWoT\yf—D๎D๓ˆ`๓„x•ฦf3ุlป †ใฝŠ๙ๆ ๗์O7qโkŽิ๊›฿๑ผฑ‹‰OทG=dอK๎ >ดmไศ_^7\๘`๕ศ‘ซGพ–\ €E<ถ<ฎใ—>ž2๙ธIำBฌ+๖๎นeW‘๔๐[ซGŽ\=ฒฟ(4–ฉUP1 ๛M~iำ|› A„้์ใNT฿ผ~-#ฏ\สฐๅQd%ืRSSs๎ฝVภt๖rั•g^ปš–UฉR‹nมูNNิช›ืฎๅayปaภ๗๐ณ•e^ฝ–-ย\yV–Ž๔5,GWvCAVV‘”cฺลค-„๊่ใว“fคฅฅ็ืจˆๆDฒuO้š๋TƒmcAzฑไžัญLาhะ ๔สF‰N๏ ว่›รีJสไz}}]c€—r๒%ค๛พ๗ลค!๖ะGN?52xz๑•ฦ ฌ3<]๋๒ทๅ(q€า Zcข‡Kภ๒ิจ9_ดrบป*%dk™'_^„)•8H ฒส& p่ษะ๛ž๐๑พŒใ฿7=pฺหŸษx๓—ช=ฟƒ H†a4jฅคบ˜๔‡ืWk๔ฆ๓ฆวcCญTตๅ5 o”l™ ด$๓&ฆื$2•/ัฅ#ฝH#.ซlPจ๊ฅ„'“ !]Œอแ๊สไ8 R6]H"๋Qท7‡ยq tำŠป&๔{ฦ ลหหหมมF๋x\‘ฺโuŒ…Bx ่Iูอ sW๚1 c:‡Dุ€Bีซๅ;ŒAŒR-}EhcUZพ|„ฃ `ธ#บVฌ(’๔๏ษฃ4*MoะทJคำ่ฎ‘๖„๋€JWWW˜=p<žY๕ิ8_ชวxNpญ{cํ๓ค5ืำ ธภ†…s@-พžี€‚€๙ฮI‹รฆฆธŒๅํ;ะiPK๋Eฅฅu*s3ณ52%ฯ/"สKฏืHKn฿=E`์-Qy.พNŠม4&ดwยซฝาQฯชQ!ข๙C;b รš—l™hEš้์จ)ฮiัฑค1เ8^___RRb0ฝLpฯ8มำำ“ลbeggk4ไ# sๅแ5นWj: ‚PW็fUช[คutปตลBไ—˜˜ุEA็๔‡ปh๋ๆผศีงŸ_ฑ!ฟ+2ํmzฝžB1อมข4=4ืใๅ—™OEGk;>9vช๒K/ๆส ผgทl€1ี@ฺๆia0<(O+*NpE*€๛ˆฟŒ๖ืV๖๎ฒิญ† ศรฃํ๑จUืHฏจ)พYSŒัุถฎ~Nาœ-YF '†์ซ๙ญฯ,้่ํข/ฯศhะt—QํNXiฟtิณ๊๗;r#€€ฆฃk๓Q–ฌGmีมว_ศ ๔AQŽE_+j๑e‡ษdxzz–––6'3ๅพดดดรมC'จUJ_ภขP8.มnผ~>ๅ้ทp๑๑ตปพพช|pnิฏชฏt๕ศz‡อžd–Wิ;๘&xะ่พฯLY?“nfm*สโ00‚nใจตwท็1(PS_ํๆ?4g๏>ๅŽ†๚าš๖ ม>NO๗hฒญฎๆศ๊]฿ฆซ:^Aคลฯว‰ฯฆS\ซลกลี„V(Fg0(Xว‹ฦ0ŒJฅb…nใdห4ะ™,*ลฬ*—Ž๔ตšekวฅำูBO7้๐jMZ__^.ลUีyืฏ_ฟv5ฃTnU๑Maaกฃฃcหฤ{ฎ?0 •ช[’ธธค„็ํIร๔‰จH‰€๔]อ๏ซิPฦฐ ้;๗XฟฅSo'ธ?ฉ—@–พ๕+ฯŸ-Ÿ% จช ๗f๖ีI็Ž}zษ๑๕Y—7ฟ๗วุuฏm„๏:p}๛ฏกซ๗๖”’ดฯๅ>๙< ๗7CŒ๗Gtat‹G-i๑๔ฐี/์™BSคŸ^๐NšEื$๛8u๕ัตWOฆ){;A๚\yx‡xฑ้˜NY_Z,ึ}บ@dข(JำณซิโJี ˆx ๔ฉจเV%iN#.ฏ๚Eล๙่dUลyทƒ†@vŽฬ5z ‹qnjDข'(ห2ฒDjาา‘พฌ…htโr‘0p@”ซฒช@ิเll*V๕จ JQ~c€›]u~ํ4Fำ๊ึŒลบ๛๎ ห็‡tL’พRา๗Y'&NiZrVppw…<์vๅ›ฆฟ…„„ไๅๅ๕n0‚tน–”fควฃ๛๋ฑP„ฑNื๒Œอฃฐ=ยBi%ืKd๗oวPฯชท๔๖–ว0h}ล}๗ป๊๕‡‚ ‚ ˆu ๒;un‘1ฦžหEEŠ y ตนปะ๘AAคC๓B๊ IDAT—h๋‹oิ๗vbe๎7‚ ‚ ‚ ๏>ฏ?๔ุ-4E้คๆ้้‚ า%H;'ฅวา_โ|๐๔ม-฿!ก๋‚ ‚ ‚X AAฑ”uใชSHBBBBBBbbbbBBBBBฌŸm;หณรฃ}l:ส•็eฬ3ยmU8ˆ•h<ฯ๑๑vMถ๑‰1ํGใพไ›]ำ๒%cฺy‡FฤฤลวF pโma,—ฐธุ@‡ๆ)s|฿Xcž๑ฑ‘|„ฬฮึ๎กแ:๗˜H$JZ่ 0่ห"Q๙wz;(2ซฎˆD™†๔v}{โๆไไ฿Œ๐๏ไำ+bZ/ตไฮ้ฎํๆม๐ยว??๗ืูฃ฿<๏oU้๚๗฿ฝ˜๓L๏{พ๐žน๛ศขpkโ์ชฬjR๘์~ัฃk2๏qfท|ป๚Hc่–๏อ๛tฝ‹๏;ศตGh|฿˜–ณAn, หw@dl|\LDˆง-ฃ๕Jt็ฐ?[ Z‹โใbยƒmzํŸช‘ญ_์็ฏJeน‡‡{๔`๏ฒล๖Œ ๕˜{kk—ฐฌ›-ฌปA_›๗_-ุ๘ฤ๘jsฒD–ผ4ปc๒า๔Jมฦ'ฦฏKฒCศฐœ\m) yซ—‹ซสณ2+-zg …K2œ8’ฌ|%p\ƒB}$9ีZะิ—k Rผลยสฒฬ,‘ฃ |ธีื฿–Z\dะ่QN[w๐G๒ะ๗v0ˆeTR™d2€T*7~ฐkุK๓๙g_œt  ใ05/฿ยอญS‡o…๐ทXตqv"ค‡„ๅ[:=าzW‰ณwIo_๛๏v๋Žำู฿—UŸ›‘งฆ๐C‚ผ้๕-LGๆฒFำใ<วb ำ)`ฏK}–e‚nำฉฑ4:ƒะ๔–4ฎU๔์/“i{R่Ÿฐwษี’ฑsำ5๓—0ฆะw@”qP่มงp<"#<9 —ฐฤฤฤฤฤpใ๐‘.๐๊iั Œ&๔‹Š ๗ไw๐Fwคc:Eƒธ47ทL†wผlgP๘ถ6๒ฺ*นฮ`ะษkสห54]พˆ ๔ฐ%9ฑA่$ “&ำYม@Di๋2jTh๓๓œํฟฑ-้j^qavสกฯะยน(*2๛ีƒ™ืถO}dฮก7อ67JงO|ฟผาJ‘HTYQ!ํ{ ร6็‰DW>1ๅซฟrŠoฅ|?ูa/{ๆzํyW“ถฯ‰ๆ4_jx๚‰ '3‹๒S™z๗ิ„`ุปฟ_/ผ•๖๋‚A ‡G๏>—~ซ8๚?ฟoyk„รด฿ฅRHฅRฉTjืแ‹ท์?y๖ษห‡pLKR\‡/๒๋ษ3Iว~ฺ8} €ำs““ฯญF‰˜ฟ๏ฬ… I_Lt&ฮ๊@า๙sง๖}9/ฮtqฑๅ๙vOc๛อฺ—œผwn€ใณ฿&''''›ึ"“„™(n#—n=xู๊ใฟ|>+Z`\V8eู๋UOXฑ๓ณg๖พธณน<อ„˜รˆw๗œ:wz฿†งจๆถ’ถฑณฟๅ่'ฯs่ว7Œ็šY=ํ?vฯŒbํž“žฟ๑™๖ "ญู๎ฐBl ค8aฯำ๑sฮูต๎ี!๎ เŽ๔๗๗ฯ:š๒šป๏ุขp †ฌ:ป๎• kv๖ฟษัฃ—n?๐ำœฆŸ†ฆฝนwoใoiณ้‹˜BŸะศุธธ่๐ Wฺ=‰๑๑ฑ‘พv-sฝึกุ๐mdตี  ืJk๊4|>ทๅื,Gz]]›ฟlƒฆQฎf0Mง๖๛Vฬโi5Z˜}PBฌฏ-`th4ฦW3๗p :IƒœยfำภL๏—๎2 ฿I่7(&.."ภมtีŠคู๘ฤ„ป:„วฦลF9s00อ๎ฑjvษก›๊เใฯ•d^ฝvฃL๋่มeEfjjfนR[“ššššjA๒=leE™Wฏe‹p'?W^๛๙าู<&ฮแฑฆF7ั+๊ลU๓ิl๗qqฑฑั‘aฮvทณeKาhtื›zดธดบขAฒ’kฉฉฉ9ีไ/Mว่ถถl•ขWฏ#ญผyk๐่g&Ž ฯห+ๆ่~\5มๆโ๊™๓พฟ๒ส–๏ๆ็3p†ล{ิi\'ฌšใV# y,Cšm๔’ฯฆ‡W๏|v์ฬ=…ฒฬญ/Yttสcาฬ่ยGs(พOอฦœgl๘ด {๛G“C'|๔ษ,Ÿฆ<„ใgฉ;v$ำเ๕ุ{ฏ?f:„ ฦญX่™“ZLqฮ‚14ภyg๛Šวํฎ๚๚›๋๖\็…‡ฺึณธFฦภ`P8ฆธ\&AืhL—zฏFf{ฟพ-ต๊ๆต๔b•ภอfฐœจU7ฏ]หฝร๒vทรฬuณ{ฎš]’9›รี6‘๋ MรF ‡ำfZZiIๆอJ™ฮ ืHd*:ร์rFชšยขย›ลuhzF๗PTdงgfeee฿ศ+‘ฒผ}อNูด|IำO>ี18>>>>!!ย“knQŽgD||B|LฐคคFyyUฅ$W<บ|q|z๒%c7฿/*š บ๘ื๎ใื–หะ^:ด-ญ ๔)๗_ภฝ?นwแนœฏPหjJKJ๋Tจ็Fล2Sวพๆไวซพฺ๖ํ‰[<h8ถtา”——l๑‡/ๅxy5๗N}บ์หํŸz€้๊f:๙ฉพ๒ล์k–๏ผ@wtดš€@ใ ุŠ?>Ÿ=็ป‡๊๑บตiG~ซhศ:นLฎภ+(P|้์FN^Z\e:p{ึ]>—ซ0เโ gฏ BBฬ5dl™ฑpWvƒZQu%ฃฬมมกโดœg` ๘านบ:ๅB:30ะ๔…:#)ฉTeๅeๅชม๊ โขำ฿๏N)ฉญL๙;C๋โ*+ถ4ŠDr รฃPmรB=›โ$]ฝไ๘ถ#ทd๕ญ๋9ZWทv j]ฃฮ๎ŽพุศP0 ฦž‡I‹S๛xหŸ๕—Rr#ใb้ถ ๑n)3 ๚์+ืิ*•ช่ฟ๎จT*:x๊U”๔ร+ๅuขKd<=L™ผู๔1lW+ฉ“๋ะึื5าน\บ1QืP'ว BฏRช[œ้ฝnL{ร/žƒƒA\ืโ˜k<'$ฦtช’ำนฃ>ึณธFZ†Ngsน:ฑใr™tบถiDิร5ขะv<ƒJ…ทำ๛5H๋ฤ*=เrฉย0ำภ@U[^ฃภ ƒขQn`2ํ>๗L5ปไำ†M“(‚ `f๗2•็เ๋ฤก @cBcGใส1๊Uvฎี˜ฮpiช๏(\9๒I‚–/ijzq1๐}ข}{]บฒ8G!๔ uฯ๋๘ŠฤฤฤvพํƒOV๎6ฬ[)”ฏอพ}>Y๒ฬ\ƒ`7mgฮD<เrฺนตi%ทEช๙ำnจหSvฌ‘ู•Nงัฯ†์ว4 0xG>ฟ๔ญว‚„,:@y๗ฯ๘+ ื€‚™ฮMจ๋๊ไL\†.iำŠ_ผ๔แK u้…ฯฬ.ฝwงฺ๖ iฦก@s๓onำh4š^฿๚gžNงนMt฿hh,ต(ว์ั‚2yอ๒‰t\‡๑œแj๗ลi9:npงำZOUญ๚mษkึีœง^ฏ7ถ/หท!ส*^ฑ๗เkrEMฦฆอW›โ$]ฝ๙7ห@,,จนF}ฑ1ฉ:๒๙7^o,ข3^‘๑ืฯ_{ฎTP›’RJ สea|p๊™ซํ๖]Z๎M4›>ร0ฆsH„ฝ(TฝZŽมฝฝ {๕Z7ฆ#ฏƒ.ฮi๙ณซ,ฯฬชb๘DRK *eอใŸพีณธFZ–ฮpฉŠšF†ฟ ŸM}ำบ=T#ŽgDผ„^#Jม‚ฏฆ:๗˜i`-๊Oด;”่กjvษ๘ h๊D๓WDqฯ‘แ่ํข/ฯศhะt—QL_ ฒํ์ธzYฝT๓0Mq่1L_Fužศxr๑žIๅํนz้Fใ‰”v–lวqŒFลŒ-ย`ะ5Jm‡ด’FUKU;๚a!ดมศนxi–๒Bลจ็@ซี4ฑ|ฬ'iฦ%ดu.oZœ฿เ76ฝnุๅณซฦฬ2„V!ี๓ฉw6ฯฟฐrโ๔ณ—>๑f›Y(4t:s๛ฯ?๐๖๘ƒ๏9‡$L\บ้ฃqซOุ3๓7+Op?P๔z=…jmQ(ฆ8Ž—\:sOyGk;_8M๙ร๓ำ.ส ย)[‡S ั6Oณšปษ]ว๑ๆาฉT*Ž[ื•e!Yพ•&.JHž3๎{™ลซwvwXฎ฿4eั฿: tพw๔๓๏ญgbฦ‚฿๋Dษ) ›ใC"…ƒา“ื“OWmƒFฃ้pXlธŽ Q^;›Vู๑!ฆKกฎฮอชผ็๙1ด์ตฆทบ18ŽSจMวb•†๋šถ'f๋hฏgต9HHE•ส็สฦชฆบ๕ฉ>˜ๅ5"ด‚gวVWชไLฝป=Kwง๙ซช‘้่]V๔~I˜๙ฅ[uณzคš]rฬPซ”L=Fก0B>กl๎1๊4šภ†AgฐYt ร0*•Šบ“-ำ@gฒจ”v†Ql—ภเ€€พg๏ฮจ๎ฤg4ฃ’,[–dหถ,ฑc'๑•D…’ฅๅh ้–%4ฐก-W`—ฃBธn%@ูาrๅN€(ด๒[ZNo._q,ว–,_๒!Y’uฃ™฿ฒ'‘d9ql'๙~=ฝ™๗F3๖|฿ฬ›๗ฒ็0ฑ“R”ใษT*9Ÿ$HZš“%๖๙&ฎฎ"MI™กธBŸEN—๓pฌืํหP็J๙$Ighี2ำ5m์@‚Lน8^กN|>i็[๏์Œ?ต4๎๕€ข๖ฌ3++W|๋{๏๑Š๊™t ƒ ทuญYณๆย VฟV'L’‘ไQ$นฅฦึษ}แ ใๅืŸฉ๙้?ๅๅWm๚ูJ€ึ}๎ฤ๋หึ<๗ล๖‡ฎ_ณฒ@ เ™qNXƒฺๅซส”J™W;ใ๚ฬU1_ 0ฌนkหฅ•ษ๎ล๒(J(‘ ศZฒบ>'ฅำI๙$ ฺ๒๊ฯ(SfŸ}งO๗ ส14œฑ๔ดe9Š์r๖›-jใYrพ0็;gVวฬfวŒ7‘^•า•hŠŸ™อ็๑x<๒เ5'ํี๕pค๏9ˆย5ทดบฆ@IEว์vO `Ÿwฯื_ลV\พฆฆห†iฌ%’&้์ำพW๎<0 3=m zฯๆ๎|์ฆs’ง:nBม_ฆ’คXSผ(WJ@8ส3%4-Rๆ็*ฆn๓ฦฐ^OฆR‹)’ไหิYgชM*T™๛hขๆ]dค฿.ศอSLœฒ +›ม…รฉ”๐๛9ฦ็ฃ3ฤแ๐ฤw๓ถG3ˆ~ž`Ifภ\ํๆฌ<`์ึniqiu. a๏pgืไ+ฑัeษขj ๓๔์3„ํ}รJCอr}ิ;h1uซU•Ck›W[[ฅ‰ว@หŒ๙่moทEC0รา™%…ayyN\ZdTAlฤดหโ์ท*Š K๋i2๑9-ๆ‘ษ†_ะb่˜?4$‰Mš๓แแ.‹ภPผ$W@D}v‹ู€ }]ฅ&~อซ6€ฟงฑu0 โ‚jcpฑHะk7๗ล`–ง.ก`ผuภo?„?ป๗ฒฉ{ฎธ็๙ มม}ปƒ3าži๛ณบ๔[?gsด๋.๘ท‡d ํwฟ๙lัอื๑ั–ํ๗_t_๎~iใฟืe}@(๋.๛๕ไA๓฿ผš–%*(ึืฯบ๊ง.,ศไnฐ๙_ ฃoํผq๎x๎อป๏ฉํk-o฿๓ฦื\O>^u็ใพZม ฺvฝพลœ์f๎เ฿^xีm๏|๒+gำ;บ๕ผ‡Ÿ-ฌฟ๎ญžyใป๗>ตmm๗o๒ผuP๙ซฟ<;><ฮ_] ]ฯ\2‚l๐๓~ฟ๊‡๚)฿ฟ๗๗ื๒แะ1๎‘gว“V๚m?Sฤ†[?ธ7{S๔;H"ฝ*ฅ+ ํ%๋‹o๏U ุ_{เฮื๖ฅฝ๚ฑŽ–ตI~๙#œ('ƒหิI]๙หวฎอฯโyบพใo?rŽั๑๕ืสŸญฺ้๒›”}ป?yeื๒ฅฟชE‘ฦw๏ูาฬA’ำ&i=ึcส@G฿?}`์Vซดธข6Ÿ"baทอ` j๏ณ)Kืhƒ6—๚เcู9 cdE๕‹ี๑hฎฺX0D…‡ฬ=Bรข๊Š {ํ]–๑กNI…Jแทw'>‡8๏ภ@ Zงp†ๆช๒ ใEรa6ย๘#Œ฿ฯE"“ๆmGฟƒ‰ช‘๐K๊ˆ0`ฎv“ ถF#๖A V๚็็{Fใ<“gข๘W๘๒๖์ํ}ัcV๘งWึY6”์ํt๛-ด๓๏ื ^พhูฆoŽk=ฒ๒๒r“ษ4฿ต@ ะ฿ปo็๏ผ`ใว~ ่ขหŸ~B๖๛ žlžvE4Ms|๕ฟะY__ป้๓“จOโษtAแe/ชQ:๖=inหž|{ด`ƒอส๓„ะ‰ญwว+œหyฟb-M@,8า๑ท{ท~x่”m๛็g๋nุ๖ืซฃ วqภy_Œ-ฝู&9๋7Qใn๋ใ๗œL‡“ •ฅสpužDก๖ษทG' l? „ ฺ๑ฦต็พq๔๋7o^‘ปy๖ชƒะฌ๙‘ซ?dพkq’๓r๛YŸฬw%PjฬH๛๎‘๙ฎฤฌ:๙๖่„ฑ fA!„Bฐ€B!„JถB!„B้ย๖B!„B(]3}ZVTฏ๏‹ฯฯ0u๙(ศŠ๊ Cญ๑yะq'ศ**ษฯ’๐I.๖[ป๚ว’อ๋Feไ๔นˆ {ํVs฿ุฤฐส”4ฟ|ฑ6ุนำ์JQ!ศ,0dKD,เ๎ทXF&/j*—่"MŽxษฒข๚ลjŸโัkถ:๑T˜ ’๓๛ํ+€ IŽeภ๛ัฦ๓ปsพ๋…B'*žT[bศ• I6์ณ๗š{]Hq1M)Q๒"Š‹ถnหฐŸJฆ+.Rห๘\ศmณX†ษ็ฯI7็”XŽ”T• Z;ใณฑงซถ(o้า|กฃ#U,‘ฐ๒ vŽป }]Qคํจใํใว_:Eˆs๒ณย}อํฃQjห—ๅ)‡ฦF7 2tฅZฎoใh˜kJK๕ส–NgL˜SlะสIฟoฺ?-พบุ vwดt@ฌ-ซ(สqท ล'๘ ;{-ึ3ติ@os‹-Dะ }UIฎำูํIผM4›฿บ๊cXบแร #ื%›ว !„Pš„š"1ผoฯHˆ'-จ(ฯ๗์6ปน„ำ๔ทI็๒mƒABค-ซิซœmรQRฉ/อ vถv๙IEQEižทฉ7ษ`น้็œDe•fŽuํ›œส๙ธ\ต้œB-/’zฟ„•_ฐ{tŠš๖Cผๅ-’Lplคฟืๆ ฑ P๊ ูRš  v[ฝ L&f๐!fy์เd=”†%†ฬุpgkŸgๆs•ขiล˜(Kวb,ฤbl,ส$-™‹๙!{Ÿัส$เ๔D.{อP”+ล)ห!e๒ ฿Hป/ส๘†๛๚SๆŸ๔69‡฿‚แข๎1?•ร'p ็๙ฃ\๓ิถ๒O7Gฒแ๗ซว6้๐!mŒš[?พกUo ฉ]uใืSฎ`†๖พฝuห[ญ8s8B่rdฤt๗yA–ึ๋๖q๙B€Kx1MฟMูํ~†๐;=aตP•)•แ=žH `ิๆศ/SŠ{„ซงŸsขผœ’"แp๛~O เ๘]ตIนN'rX‡ฤ%ฉb‰„•_ {t x9ๅห Š‰Oฌดำ์NQ|ฅกฬอบ๛:;‡๓*ฯส๛ต>ฺฟwO“ฉฯร—Ky<•พX๊๋jต{_?ซ-ษ“Ž'คพฎฆ]ป;†ƒS๖žI-– ๑…Œใ#l๙ฮฅ็๊’ๅ’ž{ำฆส}๗ฏั๊๕ฏื{Yล\V!„ๆKศู7ไ‰AIe’˜ฯMv1MŸฏฏฅc$~›ž‹๘  |ˆDธŒผฒb•(‰๐๙$kงŸHq^Yืi›ฬŽำU[”[ๅ๋ํ๗ฆ~V~๎ัฑˆ˜vpDยŽQ/@’ˆ„*ญศีูาb๖ˆ ๓2‰นฌgbณิ‰ (>MA(เฒธใI"ฑ$โ๎๕ลbNวXIฎ„_T$–D]ฝ>†BSŽSpธซ#"Žyf๒pอ]คป์๋ bก8ฯืฺ๋K๘ฬน๛ปฝ‹J๋VpLฤk๗„—(Wrใ'5OตจฎHถํk๎K๖ŒQœฟl…’ v˜RG@s!ิดcGOภิา ’ๅส/-u|๛LปŸ็ุณ้gๅ hwฯe5Bh>%ŒXโ7“ู€l๊๖rpŒS ฒ์UVVฆ8:5เ“$วq_"“๑x\ˆ%ษd๗\ษดsˆueโ`‹#uฏ"€cผjำชB 7ะ:ส€&eพ„•_{4+heQQ†ปซล=~:%ˆจ l๏p‚N—/เฬ๗›‡ทŒFcŠ ๛MˆG แaKฏฐฐจ*Wภ†Ÿฆoณ๗XฐL)!SwlUฮ9ŽๅH๘=žษ›= ร๔nฟๅฒW๛ๆฏ^!4X€'ฮRR^ป'tyขE )Œบาฝ˜&Ffjี‘=ฆCF:a"เ๓y1เ๓๙‘ศไM่ร.ๅ)r&ยป๚ไUฅ:o[Ÿ?><“WmฆใGค๓‚ช•ฺ๑ฯ2ฃดฟนน?˜fๅเอ: vvy>สJQฯaา6ำื B>/3[F‘ค ;K๑๙i ๚™ˆ&9&a ;†‚พL!$HฑฆxQฎ”€p($”gJhZคฬฯULy˜'า”.*)Y\”=๓|( L อPf H xโ์Lq 0ัยiJส ล๚ฌ‰S”i zญŒ&y‚Lm6=ๆ™n€ƒCฐ^ท/C+ๅ“$กUห๛๚+N—ฤ๛ฬU1_ 0ฌนkหฅ•ำJBก“ส‹8ปจP-ฅž0S.…BpฌSŠขธxD5•วๅ็ไสhOจิfN็ฤS#.ๅIs&1[CชาyaุQ]ตฝ ใ๖X=ฌฝฃ!xHท๒ oŽ_eะ‹ๆ^ฯ”RFิ ัL฿`]ฝfy‰กบžๆBžA๓` ๊๓บย๒MDฮ‹= Œj•WิๆSD,์ถ™,Dํ}6e้โm`ฐำๆR|C3๒‡~์w"ะ,๒˜GŠ +๋Š)sV IDAT.p๗vO4ฃA_ˆกcษ'|แกnซฤPRญแฑa๏H—%มSaX^ž\dTAlฤดห’ฐฯ{xธห"0/ษQŸbถGaสธีฦ๐๗4ฦ็T €‹E‚^ปนG๑Yp์=๓ฦw๏}jฺ๎ๅy๋ภปใษวซ๎|ฯW+xAฎืท˜g6ฆ9BุXbฃ}=™%e5ZŠ`ฃมฑ๓P’]LำFฉ*7ช&?h่tฦFญ]โโขฅต|.ไถuL6IŽธ”'อ™bทF-f๙าโ"Ok—S8—Wํ๔*"ํQzxŠฌLJ•+ด“ใ/%Œจ"B(N~0ุq-X้ŸŸ๏k๐LFsซผผd2อw-Bณ /(ม1—ŠB!„JถB!„B้ย๖B!„B(]ุ~@!„Bฅ !„Bกta๛!4cคบโ๕ืฌ;=ฆ#@#„B่D7+ํ‡ }ัธrBฝA|m•๑ฅJกชฌบฎพv‰^QBGOuฺ/|บิํ‡ฟป๖ - ฐlำN›ญy๓iวฉDมš—m6{Wไฤ?ๆ๘ฎ'ธo๋ๆ‹‹Rฎ๓ชอf๛เ๊œใT'„Bอ‡ูŠใƒ}-อม) ั‘ŽฝฃD|™'/ชิ๘ TjDฃํ{}ฺฺEมIQภ08eB3!ัƒ/q^d๏/พ็ฯฉ=๗ึฮหๆถ Cฏ\vZC9`ฒฬmน!„šwวญ‹FฦQYZฉป(pAA|ฅพข๛พ๗_ปฆJฆัˆภฺcMXไ{~ฟtQำณ>Q็ฤใE็?Ÿุธqใ๓;#Ssง฿m็f๎}ไฺ_>๘๊^้าŠŒฉุช‹๎๚๏ลฬž'๎}gxšœ!„Z๐fฅเ๏omlniiigฒz„…Ejมม๏x™9Y!ป=แQskcS‡C˜›G v˜lพุlะฉe๔[ฏ๙รv๕๙่_5}๕••โ๑oB;ฟ๊บปo}๑ZฅสCMญŸa๓๓O฿๓าท@่๋k•V+ˆดฺ๏œ“ggฌัhภำcu',จpqฅ\Ÿ>—_ุ๚nหxขฟ“7฿|๓ŸffjN*S! $ ‘ฟรGฏZtวไWค๔{ท๖=Q็ำฟ~สฅฬ‰BกมฌดX&‡รแp(เ๕‹ลโษฏYฆ<่r†'> 2๕‹Kd๎พ*ฟฒถzqพ_คFhฆbุ|‰ฑ๚ดŸ๔7ข๓xไฒย๘!‡รภ01 ๘>@4ส@”a@ xญ.ะVžUษ*ฏ๙ažบปญ‰หกijbkำˆ๎ุzœ๑–?พ๓ฟMํ฿พ~mhโซบ[Ÿธ4š฿~ญ•™&'B!„Nณั~d—็J&>q@L๙N"—ลฦฦB๑”าPฆŽX๗wy%šŒฑฮๆจFญ !4Tnฑ^œฯ๚๕ถ๚๓:]nโœ‘Htผลƒx[ยฺcํูg—๏~๕žำ~ธ*ƒฑ๖๔'^eู‰ีi*uSŸุ้ถแš๒šณ๓žฟ~ฎ›VOKhํŸ{ ๆŠkW ฆษ‰Bกมlr<™J%w= O’“%๖9_๑3คดopโ#ใถ๎wลbˆ€เ8–ๅXภึB3Dฏฺ๘ัKgtํ6ป”g^ฌฑ๗ฟn๘~‚ฌึๆf\๐ƒ6จ_hฐ5ทุaฐื่z^๐ซก+nนฌึn&มบ0ุ฿ฯยi?ผ้กฑ๓5฿›xลZR๑ƒŸิd-*ฆKฯ[ทฎถ๗๋ทพr]๘G;ถะะ้†๐ŽŒŒ฿5_ื๓w?y๚็wโž๕/ฎƒ5cMาœ!„:ฬฦ๓ึูo๕I K๋—ื/-‘,ๆ‘‰7+ ฉD ธษœฑr‡ฒ*๊ วศ—p›ก$ข O๚‡Fa๋y๕9สฮmw์ฮฟyg ~z฿๚GwŒ”|ำํซณ:๕๚'๖p=ึ^Ossw๓žฝQ€kO’’๏?ิฮ๑’ณ™~๗xข๒ฬ›ทnz๕ >€๚œ[ทnฝฌšฑๆฟ~่Xำ ฟ}ๆฉ[๊nพb๓ฟ๖zโ,/๗งบๆ—wD™:'B!„>B(N~0 “ส]&cทฺB๒ฬ˜j๓Ÿ }ย‚0;๋;?Sxฯh\“^N„fKyyนษdš๏Z „f^P‚#bฐTฯx’L•J!"€+ใ วIย‚0๋Y‡B!„ŽBช็ฯง8&e'ŽS?ƒ„a"&vึแ๓ดแ๓„NJxAAŽˆมRฝ?อล"แx์6นp|$,1๑ธžu!„B่(ฬึำ!„Bก“ถB!„B้Jี~เg๊ŠŠด$๐3๓โ ˜ˆ‰๓’ˆB!„ˆTั%อRซ3ล$P’์๘&bโผ$ขY$9ั/พ๘โ‹/พ๘๒ซฏโ ฿ถbพ+…B-Qา•ฦล™)ฒยฌขลี๕+V,ฏ]Rช‘ฤƒ *#ทlIํ๒หk—•็ห้ค+K kห‹™UถยXฅŒ%ิT.ฏ/อž|XVTo4ฎ\นrๅŠ๚๊ลzฅ แ๖Nฉฦ_")€†H(ฬ๒B"กpŒรDLœ‡ฤ„็g 8\F–n๘pรศu—ฟ?฿9Yเ๘K”๐‚ฒเั9ๅห๒D,ํ้iv%ษ#ะVVส&ณ=DHtๅๅโกF“ษะื–ั}๛ปGร„XSZ*j้t&ธEZX[ฅๅ†ฺญ^Baจ+ฯ ๕4๎  ฅ”๕8ัxVYQฝ>ผฏล"h…พชฬปป“ฬ๐z‚™ม๘Kl,แ€ๅ€›XภDLœ—D4”kžฺV้ๆ่O6œฃ๓~๕ุ†๛?>คQs๋ว7๔ฏฟ๊ญA ตซnผใบsสฬะททnyซี;฿uG!tŠ"ๅ:ศa—ˆSdสIฝ๖ถึ]@‹ล|๏=ศ€ฯ๎Œhep& ๖}พจ\!/%ฯ๙‚กฏซิะ่mšl?Lโข๎1?•ร'ุcล…(U๏ฑnษ๒ๅๅ9ˆ๓ฦ0็%อ auฝp \๘ฐๅ;—žซK–Kz๎M›*๗ฟ๖Gซืฟ\{๏esYE„B่ QnA–ฏท฿›๚n#Eั)ฮ-[Vท|ymUฑJDŽฐ…‚B ‹h:Eศมธฌ\มษeก1Oผ0ฏuOCCCะแ-‡8‚–หEAเdl<@๊็ฑ วํŽ…9ˆ…ฦ0็%อPำŽ=ASK{H˜ดำf~iฉใgฺ,๘?วžM?+W@ป{.ซ‰BะชB 7ะ:ส€&uFH™”฿ึhๆe่-าซํ#QwทwQi Ž‰xํž0๐Rm!<ๆๆๅฉฒx1wซ–งส)ฮ_ถBษ;L™๏ิ !ี๛-(๘รฌ:ๅšงถ•ฟyฮๆo’ไ™์ฟดtร‡O~?4่a€สlฏ]yำ_Fๆพ พ€ะI /( )3Tว4๕๘8ZณธF2˜๔พฆชFfyภษ€ oษ2A฿Nห๘/’Gr1–ง^\/j่t&Z]ZXซ 4 H–•ซขญfฒฌ8ึ1d่๋Š"m-ถP<๋ไ๛@๒•†ส ฉy 8;>G:EVกชธขข0“•!พ€‰˜8/‰hžp,G๒ฦIไ๘ร0ฝoYทnบu๋ึ^ธกSศผDž"‰ ˆrพ@[ตาh4ึ้eคj‘q™NŠ'Vๆจไย‰(—a˜Cึไ8hiถJFณ1– iš‰š้P๘œฟวแ ฅัƒ๑(๊เ+ิ:ฎฟเh๐eAaฎ$ๆ๑r™๙๚\Iฬใ s˜ˆ‰๓˜๐Lแbn{z9Oaร฿พ๕~ห”๊‚ํ{ํหพร2E‡พํตืhg๗7o~ธฯภy,_ฮ›ฏฝ๖๚๏พ฿‘๊y๏ฉ$;;แpฬw-Bณ์ฐ สผDž"‰ฉฑ>๛ภ”žElะ5d๑lpLภeฒ ุ‡cก๑Yธจ฿92O๔„N‘ฑA‡ฒ Qฯ๐ˆ/q๖O1โ‹@ุm‹฿่I๓๔แฐ,U%ž$SฅRˆ ฤส๘&bโผ$"„B มผDž"‰hAIี‰เ๑๙ว„ฃ์ฤB 1q>žŸ)`%4๗ฐB'ฅร.( ๐yŠ$ข๙5ƒ๙งนX$?b“ ˜ˆ‰๓‘ˆB- ๐yŠ$ขๅไU !„B!t<`๛!„B!”.l? „ฦ‘๊๚‹ื_ณ๎๔TB!tj;ช8ึTึ„;vwนŽjX*กฆr‰.าิ9>๐ฃดฐฆRร‚๕5งžๅ๛ฐIยa†ซŸาHaVก!?Kส'˜ f1๙“ผD93๔u•jbๆ˜ฝ}ทล“duBY`(ศ– ˆXภoฑŒฦ :ธหŠ๊ซy\,์s๔šญฮ๐ฌ๎๑IBuฺ[๎๛ลwKณธกึO^}๔‘พ\ผi็฿ฏผ|ัฒM฿LฟLไ๘ฎ'Xdปฮฺ9;›ิ฿๔ู7ท-๚เสkwฬZN„Bองฃi?๐ สไ+2ภ5v4e†ฝ–๋™5ืำ๘=กฏ3อึŽu๕S„@]\ศw˜šL!Bข+/ฯฯr˜์‰วํO–3ุื’N๓Œฏ.6ˆ-kห*ŠrmC๑๑—?๎่mnฑ…Zกฏ*ษu:ป“ตIN]า=๘า็E๖พโ{œฺsoฝํ๗ฟ|แธ•6๔สeง5&หq+!„B'บฃ่ฟD*Bw๏`@ฎฦxู‹VTj๘๑โ‚ฺ๊B)ญ(X\]ฟbEฒŠ|๙๘|๚:ฃqemeฉNฮ›ฆ˜Dซ|ฅaiŠ๚eฅ9ขT๋ ”๚Š๊๚ๅหk—–i36“(ฅกฆพniพ์ิM˜ฬIฝ๖แรฒQoo๋ฎd‡™ไLผบLžแ๔EY6๊๎๋ 0q็ข๎1?%เcgบ#•ิีษภตใท~ณๅ๎๚ๅ—oœNqฦu`ืื-แdฏnวn“ฅk฿ท๏oฝคBผฎว๖ี+œ๛?fฎ{ซ”ํ›อึองŸผxe๑d๒L*๛๔›^๙ฌ๑€ฅc๏ฟไgๆ’gๆry$Šx`(Pศy.—d:ƒknฝงีฦได๑ถ†ืบงกกกmh๚นผฎB•F8z ฅนห#)ฬS$m๐T๚bฉฏซqื๎}ฌถ$or}Z$PดX*<ต‚UŠข9Rœ[ถฌn๙๒ฺชbU๒ษX’ๆๅU-_^__[]Yข–$๕(Šๆ˜ุx?'ฦ3ิ๏ รtว ๅrQะ8i&iœE}]aศผhหKw^บสมŒŽz'พQœw ๙m 2oีํืCเฌ{_ฺดZk~mหcŸzชึ=๖โU1ซuดZญ๘์๛ํš*™F#k5aAฮ>ฑqใฦ็wFฆ&&ุf’zง฿m็f๎}ไฺ_>๘๊^้าŠ เภปwmฒรภ6ฝผqใฦwฝ{@}้C] h}๎‡vŒUฌ~เแ+๕$'B!„ค™GัRE†oฬห1๎1Vก@ฬๅ๒eศๅฅ n/€วฺผภecaท7H๓๙3,&ู๊a{Ÿm, ป ้dซ‹ฤ’ˆแ‹q:ฦh‰d"gpธซรต฿โ8ล&€”Iนถฦฝ-fฏคHฏJ๚ำ%ฬ้๏omlniiigฒz„…EjA๒ี€งZดbลŠ+W.ห—$ฏ•8ูŠ+Wิ-สp[‡Gฝs'ฑัwoฝๆ_ุี?ๅฃoี๔ี๓WVŠวฟ ํ|ช๋๎พ๕ลoh•* 5ต p๒‡อฯ?}ฯK฿กฏฏUv[ญ าjฟs๚OVœužฑFฃOีฐ ๛'oพ๙ๆ?อ‡‹L‘3ส๑d*•œO$-อษ๛|คน}๊\)Ÿ$้ ญZๆqบฆ}š ™rq4ฦ Gฏฺ๘ั?ฟ|้‡๏ฺx๛ใ\ฌฑoพnKœีฺ์ลnุดฟ๎ฝฬ`knฑร`ท5,ึ้์M~ต‡Tซก฿ฺไpH*~ฐnบ3‹)ลา๓ึญ[๗B"๑6’ญy๎‹ํ]ฟfeภ;2oป๐qฦ5›ฏ]รต็ไษฃH(r J?ฌ“๛ยฦหฏ?S“('B!„ฆ™฿สSdJ|Ž‰ะ1ๆ๕†๓ฒ๘(ฎ—‹าๅF&ร“ฐฝoXiจYฎz-ฆnีขชrhm๓i๋*5๑ž๗ีฦ๐๗4ถ†ฅ๚ฺช๑แ›–๓!ะิb %\๎่+(\R_ฦcCžกNณ แ๊Œj•WิๆSD,์ถ™'฿อ†a† „NฑX5ฏ#ศrภz>._HC8‚ € พฒฐ4—ํ฿๋มB๓NนๆฉmๅŸnŽdร9:๏WmธำแCฺ5ท~|C๚ซRป๊ฦ;ฎ;ง\ม ํ}{๋–ทZ๑žBอ;aถŠvX<“Ÿ พาPfศๆG]ฝ:G‚๚บJ &ง?ฯ•กฏ+ŠvูD…๚L>3ึw s8ภฅฟMฑnูR าจ‰oนลB ิfI).์๎6๗{ข‡u๗ttฺ|8‚Nณ๕ƒ(ท หื๏=xา…œ}Cž”T&‰๙QzๅeีแQ&ท|QNคง-ย๊zแถ.ธ๐aหw.=W—,—๔›6U๎ปํVฏ%ธ๖ห*ๆฒŠ!„ซTครแ›,Ti„ฃZšป<’ย<^๋ž†††ถก่akŠrrxƒ๛๗์iๆe3ูf ฟนกกน/jkhhhhˆ๗nโe๋‹%žฮๆ{๖๕FTฅ:ูDA*1ะถ{ฯ~งHฏ:QอN๛Vjธžัร‡๑rสฦ•ตพอิ๋ๅยฃๆึฦฆ‡07์0ู|ฑY)!4BM;v๔Yฏฉฅ=‚dน๒KK฿~ึ๎g๛็ุฃ(/WฬeB% อฮfํŽภม„ฐฝฯ6Š„N…tŠUƒ#}ร~†cc>V เ๛6EbIฤ5๊‹ฒlุ5:FŠลใ ฺ๛ํมฐ1'JY%ดะอF%R–Ÿ/ฒ่v2ฤFL #%RสJ`ั(!ศ,,ีQร}#ฒสZ}ุ} o _คFhA|็ๆJ-MSน>๒ๆู PยญŸ๛๚+N—ฤ๛ฬU1_ 0ฌนkหฅ•๘ !„ๆŠHSRf(ฎะgM เH…*3`=๔ฝž@H@๐Yr6เภ อ`›ัp˜สPd๐iพHH Š,)E’|…Rฦใ9yB1Ÿ‚V(e1ฬซ„Yaชุh_OfIY–"ุhplภ<€X…‡s8ดจข.'๊ฐ๔b๛ก…สั3o|๗พ็ฑ IDATงถญํเแํ_žทผ;ž|ผ๊ฮว|ต‚ดํz}‹๙๐W๑B/ั /ฤะ1่`๘D*T ฟฝ{๊โ ฃฌ pI} y†:อ^€)ใ/T ภ฿ำุ:˜๘๑B๚ˆ๖๗(KUkˆ˜งgŸi$ฬุญาโา๊\ยแฮฎ‰๑›(yAU]   vZpไพ! '?ฦ†††yฌ B)ค~พg4ฎม3อญ๒๒r“ษ4฿ต@อฒ…Aแe/ชQ:๖ล-ร6“Oi‡N‡ล`ณ5~+B!„šcT–*รmwอ๊h๘วc›่คr๚/!„Bกใ‹i฿=rlำkำ2ห›D๓Ÿ? „B!„า…ํ„B!„Pบฐ€B!„JWช๖?SWTคอ Ÿ™_ภDLœ—D„B!ด@คŠฮ(i–Z)&’dว0็%M๏œ฿Ym‡๘๒๖สใ]ฆ`อห6›ํฝ+rŽwA!„Z8Rอ@R ‘P˜ๅ „4DBแ‡‰˜8‰ ฯฯpณฏ๐{WŸWNฏพc]๋‹gž—น{๛ถ]ฃวตLมš—ปƒo7Uฏyyถ๊8แ”Nล BG˜มl,‰DYธ‰LฤฤyIDำ๋๙๙งŸ~๚cSภตk๛ำO?oQgpข ณ๏{yำ๊Œ/๏บ์šgบห/๒้kŠ็dB!4็RตbAํ s /`"&ฮK":J†šZธ?๙รๆ็Ÿพ็ฅoะืื*“fŽ|๓๎ณป!๖๕ถ฿_?MS W/\\)ืงO๖ๅถพrฐ ธพ|๏/๗•ฟ๎ชreฝd.v!„Bs.ีฐฃไ€ษLฤฤ๙HDG‰/เDฃ DมฑฎNำรฤอษง2/~ฑํว ๐ฅ Kณถ#!„Z0R=ชŠ+* 3y Pโ ˜ˆ‰๓’ˆŽR$…xภลƒ‰ฦภ1ญฮฒ์D"MQSsบ>ผ๕์ณฯ>{•ฑฎฎ๎šmุ๘C!„NNฉž?Bฉ\udฤ0็%Mo|ฅr s๙ฺkฏต;wo฿ถฏนูเ†M*ไlอ-๖lำšh๕ม~N๛แMฏ๙^๕xNKใ^GํYgV‚ตWv๘ฯืm&˜r๋!„:!ฅฟ€ เ8nส&bโผ$&B<ผl}ฑฤำูผ{ฯพˆชT'›ศMสไผม{-AEnถ’DA3“ึ6c.—Gข๓ 9ฯๅ๒ฅ*ˆm ิ๚_.ๅม1W>ะ฿ะะˆ ต54444์฿žฏtฬ?Aหrห–”ซนAS๋แไqHฒ˜VคRmป๗์wŠ๔yŠY˜๑6aD1544444์>เˆ„ฃ^ˆM้ฤั”ห)ท3้ญ<ฦำ฿ฺ้TVr$ผcฏ$ภฬ๛/๒pl—๖X›๗ฑ เ๖‹ค|ŠลW'ย๘†บปdซ†ํฝฎ @ะ้แ๒|€ฐH,‰ธ{}1€˜ำ1V’+กม‰%QWฏแ‚ฉฯ\‚ร]qฬใฤนf„VjธึQ4)๓‘$ษqม—ศd<bIrขกoฒปูิผ2~˜yชEuEr ˆฐm_sา.nโe+t@\pฐร8ŠฝBำหฟลฯแO๏๚แ–ฏmz๒าภ๏์l๊ฝฝ2;๙บ$AาYYRbภา๐ฮ–๑yc๒KK฿>ำ๎gม๙?๖l๚Yนฺsฐ#!4฿ฤyKซ๒„S<ึFำˆ Qภ#K"ฎ^_”pŽ‘:1<ึใฐc>Ÿๅ‘ใ9ˆ‚fVฏ๔ถsน|…r9aw๒r{ศ ฉJ?b›A๑i B๗e฿,T๖่Kชห+Tกฮึ‘ภ41eฒ˜6h๏ทc1Wดkฦ $Œจวัสขข wW‹;ภธ\พ…œฐ;yr…ะ=˜บ'@,`๏nsห4๚’%ฒพ}]ฮฃyNsˆรFฃ1E๎†ฝึDษ<ฉฆค(GLฒ,P‹'มqDต]“=$&9Ž#&r ิๅหฒX yฑ8l๕C1—`จ™บย(ฎa็|‘@G€N•eY‚ bฃvPj‚|๗66bj!(‘สPV๛”ึ%๘ๅ'ฯ˜ฝcงd๚ฺขฤG1.ะืb ษW*+๒Lอ๙หmsส|‡ำœŸ8Eh}ฏ\uุ๛โ๒ ๏พ๕วล4%คjุbมฟ<๚‡‚๋oy๎gjฆฟ้_๛?๋‰MSน>๒ๆู PยญŸb !t wดŒNฝ“สFaข€gjรqI~s:<ิพo"็‘QะธdWฝ$ืปiถuน‚:yธ๙rษ˜cŒ›ฎ๔Cทถ๔ ‹ชrlศใด๕๔8‚lV>กิ{tŒฅsว$qฤก9Rฒ˜ธƒ ้lgZ #j ณŠŠคฃ-cMˆหา)2ภM+$n{:]๚ ‚$˜ฉ9:Š>ผ0อA%ณ’โใ?Xf๑๒\s›SYจ‰๕55นbญY\3๔ˆใ8˜๘) M%9ŽใBCํ-‡ สฤม”ี9"K฿h0y7๊icZ‚ ุ๑Cœ,|M_•(ข: vvyฆ<( ป\ัr…TFK=ฮฎiบ€Suก!Wไํ?ะj๚ฐ%อศ๊ฐ7ร—XŸว—กึJi’คฤju&ใ๕E€ Gp$‘#ฐด@ศ# ‚ฬ์ š$xขœาeeูIปJ…‚พL!$HฑฆxQฎ”€p($”gJhZคฬฯUL้ญ%า”.*)Y\”=K=ธN ฦ†q{ฌึัo<ˆ4%e†โ }ึฤฉเqนฤ9น2šว*ตู„ำqvQกZJ$#HAฆ\ ‡๑ˆ9มฃ(กDD‚ kษ๊๚œ@–N'ๅ'G@ฎนํฆี5J*:fท{b๑๛ฬU1_ 0ฌนkหฅ•ำ<าBก“[ย€' YRŠ$๙ ฅŒ $ฟ™–0 :๖*%fุๅbyjYภๅŽอดt‘ฦ ฯ‘‰h’c"โ7 gก๒ัp˜สPd๐iพHH'ธt์ฅ3พกฎึ๖Vตhษ"ญ$้๊ษbZžPฬ' JYฬ๏@8Ž‡ฏโ์‚ผฬ™†ช‰#jเซ z‘ร๋94N บ\œ\ง‘๙cฉ(JžฟxIฑ,`ทฯzxใแจอ๔‡ะู*,*Yฆใ่๐€ฝoXiจYฎz-ฆnีขชrhmด[-C๑ฒz>ม{าiŒj•WิๆSD,์ถ™,Dํ}6e้โm`ฐำๆR๋&sGC0รfwชSW4่ 1tฬš์ฆ4jํ-ญๅs!ทญsภฑัพžฬ’ฒ-Eฐัเุ€y(้@ลแแ.‹ภPผ$W@D}v‹ู…)ใ/T ภ฿ำŽ@\Pm,. zํๆลgn ํ…๗W๖ฮ'ฟr6ฝ๓ศญ[ฯ{๘ู฿ย๚๋ZึๅูŸชเฏฎ†ฎg.น๕—ฉ“บ๒—]›Ÿล๓t}๙ว฿~ไ๏Ž'ฏบ๓๑?_ญเmป^฿bžปั๎Bhb<Œฺ--.ญฮฅ!์๎์J>@yย(ุ่ซ”x›—‹าๅFฌฬt9๕๙ ]ayˆ&ขgฯไnkๅcฃ=ส’Eี"ๆู้gIS๋hv6Ÿ—lศ„‡(yAU]   vZผ‘‘^[f้โMpุ2่ฬษM^ฌT_[ฅ‰w^fฬ{*aD="ฯสค„PนB 01๘].:WฐtฅlPผ่เ}ฎูฝIK…_2ุ?-X้ŸŸ๏k๐LFsซผผd2อw-Bณl~/( /|'Jด6ฟ•?ฅœศณ…  สขฒ,Wัฃ}ชrXฮฯ?B!„š7ผฌฒ:ƒ,๊ฑvuใแX`๛!„Bก๑Z๗ดฬ[แ1Gวฮไำ8 B!„B(]ุ~@!„Zˆ๖M?!^~€๙ฎ ำอ™ฃAฐ€B!„JถBsTื_ผšuง็ใ X!„ะ gvฺคD]บคv๙Š๕5U%๊๑๙7HaVัโ๊๚+–ื.)ีHHชสช๋๊k—่6 Sร9ฟณฺ๑ๅํ)'|žห6ํดูš7Ÿ6ๅ๘ฎ'ธo๋ๆ‹‹Ža๓‚5/lถ๗ฎศ9†m „ะ|‘ี/ั fe;Ks…G.Ÿค…ตฦๅล €ฬ*[aฌšู*+ช7Wฎ\นrE}๕bฝrฦqBŠฒ‹Wื-_Q_ณคD#ูฌt3Žฝ้ฬผ\ูtyg%Žงs ๙ฮถฦม !า–U๊Uฮถแจ@]\ศw˜šL!Bข+/ฯฯr˜ผJhด}ฏO[›ฃ่q;8 ) '‚C'ฏl~ฐƒ*^}วบืฯ<๛/ปs๗ะ|ืi ฝrูi ไ€ษ2฿5A!t"ใษRp{ ™\Fยฬgb๔6ทุBญะW•ไ:ษง๙›Guฑ^่4ต˜œPUฒธ4ืุ็Oweแฬbo^F~y้g๏พ(๏ฦ๏tฺฒ–-Yฒ-[žฑcวCQแ-e„ั„‘f(;ๅGXfP(ซฌB)กกŒRฺR( …ทƒ้ฦ+‰ท,/yศCำZ7~ศ6’cวv<๒%=z๎yž;Ÿ๏ž็ž็ž'Qส)‰ฝSฌว7'B>ๅดฝ4ห†ผ#ฎ€P$ cไ2ท}`ŒfูปซพขษNA@„@mฬษž“eฺZด:๕๊Ž;>i ŒV์ฺฑcวปรkพy็žส&K[รw>sYN๔งE—>๛ท6u๖ฺlถž›ํฯฅ๐รg›lถฏ๎={ร‹oi๙ๆ• ศฝ๊ๅฯช›;:š*๗์d’L๖ฌ?๛ฑOj›ห฿Yฮ๗O ”?ผ๏ฏีm-๏ดJ5๛X๓Mฏ|บ๗@ปฅฑโ“฿\™'<ผ๐น๗|ek{แ๚kwีVํผ่ไM๏5x๏๚ด‰4Tง=๘ท}mอ฿แฺ, ภฐyอf๋j๖Ÿฝv]๚x”๑rži๒^u[kอ๛w‰bp๓๏๖T6Yฺ๊ฟy๏๑Ÿd๐ร๙หทฺ-}฿๊cฃ „ะฑโ๋V–ฅkีiซŠKK 2โฦY ีฦœย’าRS~–>f:หW&ฏ,,)++)ศ1(๘‡c–••ฆช&#๓d๚๙ลeeฅฆUYI*ัdฝˆRง•็ไฤฬห9อˆๅŒธGณห๘๑xB ฅ@ฆˆ๑{|ใG๎ฆ*ฝ,+Q›ฑช('^—šW˜oผ[\ศแ๔RBมโฌ’’1r™{ฐฯbYzl``”’ห…1ฦโDE\F~IiIAฆ&|Ž1ตJ/œQ›๋ฒV$JI^Œ!'S#ŒทŸ“Cๅ้ฎk % h:@Q|Ž”$d—–š๒า5b 0็Vd& †้„์ฺ`gc— {ะ GxฦCฏo;W฿ว'ž‡+oใณฏ–%&ตๆŽ_]ž฿ฺล็\V›ป๖ฅŸž๔๓ฟ_ “.ธฺิ๖๎‡๛ษิ๓oIฤ_๑๘ใ๋•๕;y|3็Gžผฮ8‘†zug}๔A-›|๚›Oฟ_)ื}‹aน…L<ๅž›ฮŒา)<ใก78?ั๚็'Ÿซ-mร“;nฮ‰^xษห’†๚sทmJp)O:}ต$œัู7].ญฮJฅœนm๓ฉ<๙๗๓[ทn}uo๐ˆิu๕๏ฟ`โpว;“ย5ฟฑํ˜ฏธ๚†W:ฒฏyaว ้าufำษโ}ฟ{๔น[}GคB๓Ž”+x}ชj,>eBœxcบฬำVSQูะร๊3e๒ค4…ปฝถฒชFkำ๔2€pฬ4™งm_EEM๓€ ง'Œ7&rชซ๖5uปŠ๏Gง๐ล2!ล—ศD3ฏซEL3b9#๎ั,s?Žh‡ƒU(b…๏t…h”” –N‡4YO๔ดAญ” มW(ฤ>๏E๑Yš?[ภัQu /b†่_Yu`DlLTFฉ๋Oฟ๎-Pง็“พ*-'5๊˜งนzสใดšุX•$4ะ6เ@สe5ํผ˜ค+ŒGใ``ธฝ~˜kำ3ƒอMŽ#ซาŠLJpผว^Rๆ:้ฒ็ฯ(1ฉกa$BLบ๑?ืsš` ำฺ9ไ“]rช๚ษZร? |๒ฤถ๋\[ฌŒ‰ัถ\ะฤ๋๘ฎy$%ๆโKr’““ย1G?}j๋๓฿HzOพม|ฆ>Aฝฯ]ำn๎า”๕ฯฏัhT๖ศๅT€ใํ—~๙๊—Dน‹‰ฑ“'ŒX๘O ๘ํ{ฟซาm>ฏ๛_๏ฝ๎ฦŸ๐๙แ‹‹๛ŸOxฯ—’K3.xŒค$x?๛s#œVศฯสหอ๕๗วny๊?โKหฎ-Yซ„ด"“F?|ฝฏพ–&To;}อ๊้o๋WๆJ`๔ฟzใ+ก๋ไ›คŸ‹ฟBอ๋ฒ๛หห๒HKคAG—‡`F†œ R>xB.kํ‚aX‡—* ๗๓Š%าะh—‡ๆ|cษJAP>1Gฟล๑}Fพถๆ „qห๚ยาŒXฮˆ{4๋Ÿ€ำมKิฤ๒G7ฏˆผ›เv8YFษŒ9!&Ž!๘แ๊ถฤPP–ษ๙๚š›ฦrGฆpHห€c'ฯŸฝว๎cฦœ.YฤˆXญžv;ไ่จญ่ าุ–๚^pัšTsา~เ)Œy™ส€ฝ ตหแ …๓โ€s๖{ihgฐฏ@&…A!Tฅd&QƒrCฎษฐwดt;้น(BK‡@(…hั4…Q^"‚Ž›๏ฦว+|ฮ๎o~เ๏k' …B`{ใโ์%^`S /r้Yj_0FL^o8Ž†a€$ฦ๏ ก!€f€ ข<ต8จœ\;๋ `ฺ…&Dณ1'sˆ†XzฒH@u้k๛ฯฃA ฉD |>5!„T ฟฑ‚ฦgฤฒ@๒ฟ‡žL—‘ช•, ”œ03|I>$K—(%5/Aศ๚]#ถฮฮก‰ž zlิ>ำ:-=อˆๅŒธGวœ๛๐:œโl}จท>Dฦ@”?G4cตu6?uZnNbSm๏b์ุ>Œ9๒.๚`บuoŽe†ใ8–e˜)๏ดsั~ U๚๘`WUำเม…ก้C‹ฦqP๊ด,ญฏใ€•ึญJtถึz๔ฆxes(๊AhY C2>ลƒ‰๊x?ธ๙™อ์ณEฦืขDเ‚^W„็฿๓์๙บ๗ผห?—^๕วoM:<โDF3้๔ ‚ๅ„ฤฒ ]5ฎ™~แg›{00บ๛ฎ3ŸฌpA:หBธ| งqC-ว๙๛๋z~{W Iั1๛๖2_ทฒh| Lิ๓พฏ๏1ห A‰๚๔ฬ4ญk@๘bษซTRฦ=โ L1ฐ†ฆio|ฬGŽWฟ"ฅฉœS˜V๎ ŽฯศW๕Cl8$าnJ’ t8}Yj) พลทณ4M“o.จาKผต๛™Š… vผ]zฤ 6Ou๏นธSลƒ‡U!Xทำkิ๊คฎ/F+rูผ@ณึฃ รŽcYŽ…EVBณ–rฺฯึfSู้|U้%›7G*wฝP[๋‚๕g฿ฒญ%GqกภV[i๘๘}>0hใEฮฎว]๛พญ๎‰xๅ'y BeBrฆนดXแ ฤ˜ฏน๙ิึฏ'_y๋59๚ ซz๊‘ถŽยฒฏฦ ฮพๅ–L8๋ถ›G๘็น5T๘3ฃฆ!7_~ำี9Iญ่ชญs€4็์ ŠbWคSสต7šบพ๙฿ฏ#็^Sํ‚Ÿ˜ฮ85wฬgบ๖๎๕’ฟn๘LKO 's๛ใฮuบำ gฐ/!4_พ1AฌRิื๏‰.ี@ดฺ<A๐x<‚#๙1Z…%…"`~ฟHญ’าlŒ.AษพWsจ IDAT€X—ฯ Œzƒtธ25Qณ๋2W$เฐT4 F์๗xx†8yŸฯรSวสƒ-อHๅŒ^[ž^๎‹็๊>เ€‰"ํๆQ’ HกJ! gK‰๕ธ<ฦxฝฬี?ฦ‰4๑*ฺ=๐D้๑”j9ใต ˆT*้ อ)๔‰*๘hวผิฝ็ไค&ฌ™>R:hทŠำฒ ๐ุ,C4Œw†๘G+rŠตก!Kv> ๅ,๋‚m/ {ีžrใ๖S …/฿ญ๘วร›ž=tๅ•Jุม๏ฟ๙๊(›7ํ๚ฎ๘ล]ฯMิฯCm/ฎั“"๚>๕/ฟXqว /?]ท๋ญ`๛๋[ฯ/Ž€P_}พ๖Oฝ็ล}ำ.|เ‹_\„่มซฎธ;ฯ๕ๅ+ฟ|ๆ฿ @„ยงDl?ดฟฤKษืญ๛แํฏ ๖๏฿u๏/ิNฝใ™ํ๙ๆึgฮ„O6๏๚ฺ9๗‡ฎ~”z๐ฺ_]/๔๕5ืU๚ ๘แs/mศุดjอŠฟ]๗ช๖œ็ฯž๖ฮ „ะ<กํVซ,=วd &เฐตฑ{๗€:ญจิr๗Yš:4+๒ฒก~Ÿฝฆฮ\Yค๋kตฦ‡{ŠC/‘”’,ๆกฑ‘N‹=4žnศ๏ ะๆ %"aGปฺi…%|ฮ๏๊k๏‹šfคrF7ฝbผ^<ฃ”$š“c‚>ทฝฝำ}|J:Svซ(5ฃ Iดฯฺู;ขษyล<ึ๏์kตธ‚ƒ]6Uๆส"oภา7ขM`g\๗ๆธ#GูŽ‰พŸ:าl6———๋๎!4ฟฆ~พo6oXgr๚ฯ?๊žธ]7^๔lMD9ทแอ–;ณ~๚ฮt็}.ุถ๗๏7 ฿ธจ`ท๓ZNูููMMM ] „ะ[67ดผฤ‹Sƒ๛๋l3_๓โุVรฤ-^]{h–ตฟ๙๒>Œoฐ๙ำ‡žู=ํEcB!„ๆถZผBอฺ|ึŸŽ}๛ฺวส›ปโ „Bh1p[ซ๊0๛Eฝ*B!„BhQม„B!„Nhfณ๙ศภh๏bB!„Bhบฐ€B!„š.ฟ„ะ2–๛๓~wQ,;9๓ฟ>๕มFœ {ๅ-๏ฝr‰ฒ๓๗W\๙‡ฮใWD„ZBHi|zZขRLqก1‡ญร2เ›ๅ(™!{ฅืบท}bŒลน:jb~ฦXiqอIFหส”GIœ˜Ÿo 5๏m>ฯ”";hหแ–๒ึ`Š)O๋lชlwp@ฦf•d บk๚วwฆํ๐3จ˜„4ฃN!ๆ1ทฺํ Mภ!d๖ล™}กEฌ๋k6พn9jด/]tสK็๎ปŽC™BhiโkSR#๛k๚|„XŸ•kิŒ์8ZตํhDฺ๔4ฝ‚๔zซน๚บ๋j{}ณL|ู‹v”๘ฺ=/lฎ_v™งHอีyวยU`ž\)‡›+ไ$ฏฅf*โ“”ฉ็บิ ‰.3ำจฎk™j๐Cศฌa๛กŽฺ|ใรwฌฯe๊?|‘ัŸDHr/~๗ฅษ"wG๙๎฿ฟ๒งo{ƒค”๎ฝ้ฬl%_ฮ3Oo"]ฑ!„ๆšO9ํv/อxG\x‘`ถํ‡wิiSfซ%วฒ=ฅHส4j%|Š"้@๋ืb—‹SCm6qŠQ% -ญcœ*ฝLใทฒ๊D`ป]’œใlซ๏๖mแฅ‰T$%‰‡ฌ’Œ๐!ๅ˜Ppผr-Iาหญ~€วR(ลเฆ1~ฯขmซE:C๘‰ภo๗ัเฑ๕r)ŒD๏ข:€ฬพ€ะ †,ผ๎ี๛y๙บ ฎหs๎—็Dฟ็Wฑ๏฿ฒแKท์ฌำ•ๆสdgพ-ทแ—๘Mo๚.y่๊)ถGกๅลำ]ื<~†KIฤšžmใ๏ˆแ;๒ัฑ81ฏดดคฤT˜›/^]ฦ'๋BตU•uฝ>ฟญกลNJฌี๒๚TU5‹RUแg๏2aภา้&๋‰žv;จ•โู—~กEq๋ฮน๐ถ—[Vsฯyq@ำtืฎ-7nธqใ%ž{๛ƒวฅุ!ดเH•>>ุีะิู?2Ÿa\zv‚tโT ึจญฏฌฎูW[ืุ1ไ_ดƒpๆAฤฃ$V*B}jณู\l”“šๆ‚ค‰qZR…œq:๎3"ภ32ไu .ึwงฃโหโ4r>หฐŸฯงC๔ฤ/<‰ZซQˆ&sMq@ŽTํR$S(คxย˜๐ ฤภ Ds‰GQ"ฉ˜a์ชsKดcฑII2Aไ ‘ฒแ๎ฯ-JVS!ง๎bX่nทhŠฬ!€0mรO\‘;‡4Bh1ฃ(Š ้ฃGœญว“k4 I|™6Vโ๑xฃฤ$ ‚/A' 3โQ๒vี”ซฒบX{symฯ๘›ั‚฿ใ=์Hrฎ๎อ‹๖้จHน.อจ—๓IžPฅใ;]๛%ึedฅฅ็cว๏์SY D"ัไณู|่:ีAวq}ภ@ \ภˆ็gT๏›อฆsนห๙[ฟค๘ม-O}^†`d฿_žzฉsํ“[“voบฉ๎’~wฑf2N+—]๓vฏ7+ฅNหKS1- ‡ฟ/}ุ9Œูl>2pฒuXlช๖ƒPœคขํV›_a0จปีๆb0 0โ๙9l? ใ-K‹†Bช3KดฮชฆA€'ๅๆPึj+Nซ=วŽs…gAฬจ0ี๘%žTฅั(ลPu๘bเ‚"„B่HฌgxˆJ,,6™L&“ฉ0[ฐู—t—ย"…žรLี@๐Šฃ!vโƒธฯฯ),๒วEhYย„–%ผก 8๎ž1ฃ‡ฉๆoๅ˜` ผ+“0"!„Bhก`…็0ธB!„B'ดi๑›๊„B!„:ถB!„Bำ5ำ๑K2ฃ)Oว~N‘ถฝญร'าb‡K%3dฏิ๛ZฃM 1ฦโ\5๑'f์•ืไโฤ|ƒhจyŠก*9-9N&$˜1Gล286พDงH—ป*)ุฑฏu(ผ๔Ž<ตde<ใ€cžกฎv๋ศbœty^œ๙k๋.ะย™?|j‚• ถํ๛อย7.*ุ๖ํB@ธแŽ฿œถย oเบึกฦ7่‰ู).4ๆฐuXผ๓น๕Rล“้3าไ"’ x์]ํ]ฃAJž”ž/p~‡อb้๗2 ŒMอ0ฤJ$วึถ'-K1ๅiM•ํศุฌ’LAwอโ\a*ำจ˜อ8ๆ4ร๛พž๚ฺžฑูgŽ'‘6=Mฏ ฝž้c๘บ๋j{#,Nศืฆ่yมเ” โำำ$Žๆบๆ1่ณrRตŽแ-#]– ๋:xฮฑฎฺ:›Ÿเ+y ##ฎศi.;-=๖h3•~๎ฝ‹Fฟ|ๅwฑT๖/t™B-ˆˆ7hพ6%E0ฒฟฆฯGˆ๕YนFอศะ‚qฑ้R“ˆ†ชA?O–œ“mpUถ;8RmฬT๙Z๋ผค25'3ัฝฏห ญ!6ะ]8‘>ป Q๏เษ•2pธ นBNย\ u:ณ™ฦœ–นฟฤืญ,KืชำV—–dฤ รกBต1งฐคดิ”Ÿฅ™hจD  ิiE%ล๙๙’šv yGํ]n๚่qฃ IIโกฮ)ฟHน"ฦ3ุ็ ฑlศ3ะํ c,6›W›r3“ผ#ทแBง— NœมtzuวŽŸ4…F+vํุฑใŠaˆ5฿ผsOe“ฅญแปŸน,Gu{ŠKŸ›:{m6[oOอ๖็R๘แณM6W๗žฝแล๎ทด|๓ส…ไ^๕๒gีอM•{vn2ษ ถํตูj[๖cŸิถ7—ฟณœ๏•?ผ๏ฏีm-๏ดJ-wˆ;๙๖7ฟจiฑ4W็ฏ/vj5อุป=•M–ถ๚o{'|ˆH~ศ_พ=ะn9๐๏๛VO•B-(žLฟ"ฟธฌฌิด*+I%š‹หRฤดO9ํv/อฒ!๏ˆ+ Eฟ%PŠคœSqIู๊2Saaq–†c,ฮOTฤeไ—”–fลKPฅ—e%j3VๅฤหใR๓ ๓ ฒ%_็๒9บmC>–ใBn‡‡‹๘ Wซวz]A†๑†@ญ–C‡X–aX–aX&D‡{s<žB))bžฯMนiUฬfsบYฯYBrฏ๏@UลงLˆOcL—yฺj**zX}Fข ข๐ล2!ล—ศๆไ_‰๑ŽุพiN&Nฬ+--)1ๆfฤK'"โ„ไXOWฯแ‹ก†ข๘อŒวก]=ฃp[ซสหห๗๗G~vB๐ ฑฯ;v‚wอ ฯx่๕m็๊๘ฤณpๅm|๖ต๒ขฤคึ๑ซห๓๛_ป๘œซ฿jsืพ๔ำ“~ท๑ห^าW›ฺp?™z?Iƒ๘+|ฝฒ~็#๏qๆœ๛ศ“ื'าPฏป๎ฬก>จe“Oฟ๓้ใญ:ๅฺปo1์/ท‰งsำ™Q:'‰“๏ูy๗Yช๊ง6฿๚่[ีฒœ6Jšย5ฟฑํ˜ฏธ๚†W:ฒฏyaว ้9Pบ๎ม฿l:Yผ๏w>๗qซ๏จ!„ะฦนีU๛šบ]…,ย3ฑ‹xƒ๖tื5†Sฑ€ฆฃv>ใ“uก๎ฺชสŠบ^Ÿ฿ึะb'%ึjy}ชช‡E)‰ชpKA& X:าd=ัำnตR<ล_H‘๎~%“K7@  r1‰Y้q0่kiงMฅ%%eyjGฃe$|CกVกˆrฟำตไFใOฏb6ณ˜ำu ใ—ฤ‰ซส8nธตbb๋ฒ๛หห๒HKคAG—‡`F†œ R>xB|mอA ใYjเ.?ž๚š>žX“–•๏h่ _“ขใz๋‡iะMฝ๙๘ร žfEqช"`kจํŽถฆฤPP–ษ๙๚š›N๔1qiE&%8ํcฏ~)stู๓g”˜ิะ0!&๘Ÿ๋9M0ะiํ๒ษ‹.9Uไ?ญแŸ>yb‹๕‰ ฎ-Vฦฤภ่G[.hโu|ื<’s๑%9ษษIแ˜ฃŸ>ต๕๙o$ฝ'฿`>SŸ ‚็ฎฟi7wiส๚็ืh4*{„)•R@K•b๏7ปŸเต๏;O3ญศ$‡ั฿๏ซฏฅ ีN_ณบD๚[Aคภ๚•น}วฏ๘J่:๙ๆ้งฮ!„ AP>1Gฟล1ฏ9‘ByœVซ’„ฺข>8ฆfผ@P2™รWK฿`๗€— V! w)ปN–Q2cNGˆ‰c’๏ž6ป4MษŽู›:I’วฉ\ฮใq~–$Iเวฅ%ฃ- mBขKKO๔ิwyN/Qหclผbwefฆ]1›Aฬ้;ผq๑นIๅๅ พฉ๔76Aย๘์‚XHใ๗ั€ตŸ่ิล@35“9}Y:๏C ๔{๕ @Hn0ˆํ-อDผศ๋V[ร{๓^;ศฆTnŠึ๎Xwmอค@–›“ุTk(8๎ก ข Dำ  #ว$‚Ž›๏ฦว+|ฮ๎o~เ๏k' …B`{ใโ์%^`S /r้Yj_0FLรq รIŒw2๙‡†<Bš‚ˆr_ ํyๆ๎w๎ปpหหงlแz๚ฆŸํจ‰˜ฆ@ภP]๚ฺ๓hศ@*‘Fไ๓)šfŽžัา๋^F-'K—(%5/Aศ๚]#ถฮฮ!฿<ตๆ)Œy™ส€ฝ ตหแ Mีpษา Š’&เฒv8'รน๏?,‡vB4ฬ`S๙ A‰5iYp e˜eY‚ ˜แ–สa*ž`Y€งŒS๙[]> ะ7œ˜ฏ‘wyฏร)ฮึ‡z๋CdB๏สL*fณ9‡ทŽVั”M๙๋ม8Ž๓๗7ึ๕๚<ฑJ%e#ฎ;b นร“จcฅŒkุ้g„q้ฉ‚&[ธห`ข#V*Baj๘6rณฌงถผoห3ฌ}เ๖s฿บบ%Ršม``t๗]g>Y1พ‹ฮ!H‰˜ฮฒnDŸขฆส่/ั๚ฒB่x`ผ–‚+๔้™iZื9{%๕ คJ์ชj<๊K‹ญQ1Z_ู|"฿เIbี”๎ G๛F]กTฅ †GƒAx ‚`0@$p-*8’oRเ๒ Cฃ~ˆ]ฐ8+fต=>8ข^7EฬY˜ฟ๕งพ1AฌRิื๏‰.ี@ดฺ€ช๔’อ›ํ#•ปmจญuม๚ณoูึ’ฃธะ `ซญ‹4|>ด๑"gWˆcŽฎ}฿V๗D์ู&y BeBrฆนดXแ ฤ˜ฏน๙ิึฏ'_y๋59๚ ซz๊fา/฿ฐ๓ใK‡v}T: 4 เฯ๐4-5ี.๘‰้ŒSsว|ฆk๏^/๙๋ึฯTE l้้aแคsnนNwZแQ3Bก"ึฅลณCฃ  าpะCนEQฮเhH‚เ $แ็&zO ’ธTฝฤืุใกI‘J!๑{เMำ'ศGm^žBGŒดŒภุX(Q+t  IœJ26๊›xฯนบธ`‰ฝ โZ1;ผ^=ๆlฬ_๛ถ[ญฒ๔“"˜€รึ>ฦF ๙ฝZภŒ๙O˜*ไ๑ฆL+อึ†_๔Zaึ3ุTaq@ศ็๑ำ|ฦ๋ฟ่ฐ#=VejZ~ Ÿd‚žK๛เฬžฌฺ,ยด๔U B"ไฑ[ฺํ!_S"ZhNogM}_$ษ…ๆdเ˜ ฯmo๏tฯ.rYl>พƒ๖”ทŸํ/|๙nล?๔ด่ก+ฏVย๎๏ํฯWGูผiื๏sล/๎z๎ฬ๑๏กถื่ษ}Ÿ๚—_ฌธใ†—Ÿฎ๕‹‹ึ~ฐ๕ญ็ว~ @จ‹ฏพว _๛ง๓โ>€‚ižฉ๎3ฎฟ๘ฮ “UP๓๎ว๎|์?Lx๓รำ„/บ๚Q๊มk|uฝะืื๐๗_T้ƒ`ฤภŸ{iCฦฆUkVํบWต็<vิŒBh!…<^")%;Yฬ'Bc#๛\ฬฉแCฉษ6k&ใ ท”ทFz!๖^฿ช‚ฒp2ว\ถึ–^ฯ”j `†ป;UYEzŠ`C>go{ฟ˜ak›$=5฿$เ[kฏภ>˜ž’[œNqก1GWวภฃyˆๅ2ส๋๐z DM f6›qเZดฆ~พo6oXพgr๚ฯ?๊žธ]7^๔lMD9ทแอ–;ณ~๚ฮtG๖ฬวRq‹f๙น”ิิดะฅ@อฑE~C!ี™%Zgี๘ุ Rœ”›CYซญ'ฮนใDจNNRัvซอฏ0TŒjs1G t1วฒ๙ขuX งKEh‰ฺ้๓ๆG ฺ฿|๙฿๗ฟqๆุง=ณ_ @ก๋ข ‹M&“ษd*ฬVlvผ!ฬ=žTฅั(ลPu๘รQm๓ฅ๛ะ’h1ร„–%ผก xลั;๑9Z sL›/Z‡ีมๆ๏„B!„–<Ž ยต๛ษG <ฆอ— ฟ„B!„š.l? „B!„ฆ !„Bก้šป๗(™!{ฅื๚ฒ”<)=5^.เ›ลา๏e@คษสN–“ม!Kฃี1eQB!„–ป#*Qค(6%อ+ดฯaณด๗{qฌ™'ๆ็DCอีK=ศฒSžึูTู๎เ€Œอ*ษtื4๔ฐศ3sd5{๖1งmN๚Dฺ๔•๙Fa๐เƒNช™*_G}u๕งฯL”ˆิ:๑pcuวXœVI… !„:aEฌD ใำSร-๛*+๗ต:EC,ฮw33|mŠžœ\7โAž\)Bฎ/ฑ i„j๖ฌcฮภœœ!๏จฝำ62ฆฬVK&ๅj๕ุ@•+ศ † YjIื pAAuJf} ห…Mj„B-Bต1-9NฦgฮพKŸ{๖ƒ)"Uขศนฬm฿?F€ปซพbชํ)ERฆQ+แSI‚ฤX๏พปฤXœjณ‰SŒ*ํ์niใT้eฟ•U'๒ํ’ไคg[}ทg^)^0ค")Iท"ซ0Y00L'dฏะ;ฑ๑€Bกฅง1ฆห#Q6iFฌDQ|Ž”$d—–š๒า5Sฌ-&ŒOึ…บkซ*+๊z}~[C‹=œ”Xซๅ๕จชjฅ$ชยห„KงCšฌ'zฺํ VŠ็ ๘‹‘8!9ึำีใพq้ ํpฐ ฅ@ฌ๛ฎ%ี”ŠTอžmฬ™˜ท’$9Ž#Rน\ฬใ8–$I€ภp{}อพๆ!QB"ีืd๓,ต้nB!tยKคAว‡.82ไไKฅyสˆR.ใz๗ืTืตปฅฉFMิŒhไฺ%“M6 |ƒ^šcฝN+†ซŒn‡“eXfฬ้1,CKjลใiใkRt\o็๐tบ†NOก‰U0็าzžฑš=ห˜31oใ้X–%‚nฉ โ –ๅ€ชR2“จ๎Aน!ืd ุ;Zบ๘"5š.ณู<ลฏธz:Bก๙D„0>ป –’ว๘=๓U็€s๖{ihgฐฏ@&…AGไจ๗˜,ญ (™a.k‡๓ $&?,ฯvBdค`[šำiyNqถ>ิ["ใ็ฝls(r5{v1gbฺt0€@ €Rงei}ฌดnUขณตึฃ7ล+{œCKชว-$l! „Z8ว๙๛๋z๓œM๚l•ใขU•ZฃbดพฒtŒ+ก0oต~ป,๋ฉญํ‰๒rž‘!ฏ04๊‡ุใVฤนฉš=Ž'QวJืฐำฯ%ๆ,ฬ฿๛ฎัั4}‚|ิๆๅ)๔qฤHหะ~๋Q†แ@ วฑ,วžPMb„B-e~฿˜ V)๊๋๗ƒD—j Zmž๙๗ยบ^ฃV'u ๘x1บX‘หๆ“$พ@@~nชVฦ ฤo>7฿ IDATUSศืญ,’๖}?kDœซ๛€ –ฺป ชูab]F–AุdgงŒ9sำ~Pฆ•fkyฐยฌfฐฉยโถถIาS๓Mฮ๏ฐต๖z€eยํcศ€ENฑ64d้ยs!„BKmทZe้9&E0‡ญ}l.+QํVqZVกโ{›e(ฺXoฟฝืทช , 8&เฒตถ๔zๆ TหL„ƒใ๕sG‹9„H$šb6›q|Zดฆ~พo6oภ3_ูููMMM ] „ะ[ไ7RYขuV5 2ค8)7‡ฒV[ ]ฎๅFจNNRัvซอฏ0TŒjs1๓ธhV[bซe „Bก0ึ3— l? „B!วว—ู˜0?KŽ_B!„BMถB!„Bำ…ํ„B!„ะta๛กฅGsาmฟGeSGGใwปฝ๙‡z>@มถฝ6[ํc'-tัBh‹1็'ˆŽo๖x2Šโาฒาโ‚œd•เxdนœP2C^YYบj2€ลฆฎ,,)++5ญสิIIฅ˜ฬฅ้J€Œอ*3็้… Uc'Nฬ_m>xODล$dญ2•–•š ฒ œd‹ํ„–ู}ตบO_๙^Eเwฝ.nก‹„Bh.‰tฉIฤภชŠส:ห˜2ร \R“{.(‘6}eAพQ (ŒOO ท์ซฌื๊ ฑใ๓๑ไJr…|Iึˆ๙ฺ=/œ2NLRฆž๋oฌฉฌชowลคีผ9ศxI-„Nhลลr๓ซ;๙ฤ๖.Ÿาkํ›M๙ร๛ZึR๑ฮMซฑๆ›w๎ฉlฒด5|๗แ3—ๅˆ€wฮNื๗ๆLlpึ‹ํถŠ‡ ฃdw๒ํo~Qำbiฎฯ__ธํิ2ฺๆ‚ซ^ฌบนฃฃฉrฯฮM&ภd—ศ๚ณ๛คถฝนํŸๅเ|oกฅจำ๒KสJ 2ตโ๙หล็่ถ ๙XŽ นN,Šิ˜R$ๅ˜ŠKสV—™ ‹ณ4ผp?Iข".#ฟคดค0+^B€*ฝ,+Q›ฑช('^—šW˜o-หFIศ;j๏ll์r4*#—นํc4ห†]๕M๖๐OHกศ1~o |์HER’xจณ฿?U$พD"p}4ห†<๖‘ \.‹ฌ็ „ะ๑ิฺีEOผ~฿งคละรร“ *ื}‹aน…L<ๅž›ฮค@xฦCฏo;W฿ว'ž‡+oใณฏ–วXญฝ ื๋%k๐7ไษu:1X;ญ3"Nพg็gฉชŸฺ|๋ฃoUห๒sbุ(›ว_๑๘ใ๋•๕;y|3็Gžผฮ8‘†zug}๔A-›|๚›OŸ‹‡!ดDhธฅฎถอ%MIœทnHwฟ‹‚’ษฅŒวŠSŸฌ uืVUVิ๕๚ถ†{x*PฑVห๋;PUี8,JIT…ห),iฒž่iทƒZ9ํŸ…รxG์฿ก๓กRŸ#% YลฅฅฆผtอฤZmดรม*”ฑB๎wบธ(์ฌˆ’c=]=๎ฉ N‚ฌTฉค€*b>.žๅa๛กฅf๘ฝปn๘ํ—๖๘sn}๚ฏ๗}๊uน’๑_{Ÿปฆํwฝ๖-_ฃQAZ‘I Žฯ~๛ุซ;|; Œ%&u‡ี bฝ'_PvฦZs‘NฎNซ#bF”J) คJฑทq๗ำืoฺั y๓ัถ\ฐแช;ž}ใี็?jHNNšHc๔ำงถ>ฟ๓W๏์๊ฆ ‰BKAภms๚ƒวˆ DSt ฬO›m6ฏ6ฅ lM]ั๋ˆดrํ‚’ษ&›พม๎/อฑ^ง‡ ร/PธN–a™1ง#ฤฐ A.ห‡ˆ ๅ2ฎwMu]ป[šjิŒแNOก‰U0'ปฐ%œ1พ&Eว๕vmู9ฮัำแŽษ,.+).0ŠCฃDŸ&l? ดไ0=Ÿ?v™น๐ค‹๏ุ๑ญ;u#O]ม?4ไ i‚P ัขi …nkว(่sฯศๅ๕๗g“ึศ๙„๖๔)d#ฯศื54:ๅ+‹Xฉ๕yซอfsฑQNjV˜ ’ฦ๛žxตVฃMึ๐๙ฒ8œฯ2,ภ็๓้ะัz,ฆ฿gDh‰แŸฒ๕ใืุ๗ซlUŸzฉœ~ณเ๔Qญตต.X๖-Zršlตuv่๋ฐ$EIo๏บฺ-ื€ีฺๅZ"฿ฐ๓ใK‡v}T: 4 เ๔GœฬขH*’3อฅล O ฦ|อองถ~  8๙ส[ฏษัoX ะS฿yœB-<กˆO๘iพ2VมŽู็๋ฉˆ$.U/๑5๖xhRคRHžh๕[’ ๘I๘นƒjล่0ฌ้5juRื€ฃ‹นl^€๐<ผœซ๛€ –ุป ฎš๒ฎ๐Gพne‘ดoo๛h๘ซX—‘e€๖6ูYRฎK‹“{ผคBวwvy็ l? ดฤ„ส_บ๋ทฒ[.Yฟi-ๅ๎mxw๛ฃ๊‚‚HQ}xxำำข‡ฎผr[ ;ธฝ๛ท?_ ึ.€๘ฺฺŽฺ๊ะ5gwZ;ฃไฤิm๗ื_|็…ษ*nจy๗cw>๖&โๆพถ_๒‹w๐๒ำuป~qัฺถฟพ๕โุฏu๑ี๗Xแk๔ั{^7_ว!„Ž ฿P39eUI๕ป๚[G฿ไ˜0รชŒฌ"=Eฐ!Ÿณทฝ?ฺไ@~{ฏoUAY๘ฅ3Ž ธlญ-ฝžy*ึา L+อึ†ง๋Xaึ3ุTaq ด[ลiY…Š x์m–ก#ž›หe”Wศ็๑ำ|ฦ;ู่๏ฐJำ2 u<6เlณŒฬล&B$๚~ณู\^^>๙UจNNRัvซอฏ0TŒjs1ˆ ๑œย๛f๓†้ลD๓จ`ฟ฿,|ใข‚m฿.tQŽ‡์์์ฆฆฆ….BhŽ-๒ ฉฮ,ั:ซšRœ”›CYซญ๓ีฎ9a็ ฯ"tXlช๗xR•Fฃ@Iิแˆ ˆBก#ฑžแ!*ฑฐุd2™LฆยluภfŸ‹แ)่PXแ9ฬTO  8:b'>0ˆ ๑œย"\„–%์@hYย ‚ใ^แY„ซƒM๕วว็ž€ธ!„B +<‡ม๙[B!„Bำ…ํ„B!„ะta๛!„B!4]ธB'้บง~ฯj H’cYpผuฏ๖.tนBh‰้rW%;๖ตนˆภtP2C๖Jฝฏurมฏqโฤ|ƒhจy<œ’'ฅงฦหœ฿aณX๚ฝKm€q ะ็™R^˜{ธฅผu$ฦXœซฃ&–าc์•Wฤ˜มSžึูTู๎เ€Œอ*ษtื4๔Ž็ฬสดฯ*&!อจSˆyLภmทถw;Cs๙์“@-!O๎:ๅศฟs๗ƒ7]๓vฯB!„––ภH—%ศบŽก๑ าฆง้คืsd%•ฏMั๓‚“หY“jcฆสืZ฿ๆ%•ฉ9™‰๎}sฒj๐๒lฎŸ๕”งHอีyวย_|uตฝพฃลค€'Wสภแ&ไ 9 ัึ๘^”ฆ†ฤ$e๊น๎5รBขหฬ4ช๋Zgฟ„Ž_Bจ7ผ๔๙ถ๓Oฝ๛ตŸ๖ง‡ฮŠศฟs๗›? ฏj Ew}๒ฺๅzRสํ/ผ๓ษg{>๚รใ—ฏŠYธ"#„ะqc,6›W›r3“ผcุ<ไตw66vนo{Šค$๑Pgd VฎV ๔บ‚ ใถ Z-‰š(ฅHส)0—”ญ.3gix1ฦโDE\F~IiIaVผ„UzYVข6cUQNผ<.5ฏ0฿ [R+‰cBมqTฌ^ๆ่้ึˆำใ )”b™"ฦ๏‰ถฤ๗โ4ํ3„/‘รvอฒ!}$(—K็ {l? „ฦ‰ KD๏ฒย'-?ธโฌคhฑdgพ-ทแ—๘Mo๚.y่๊œใYD„ZHnkUyy๙cยxG์฿‘ฯ~ล ษฑžฎ77@  r1‰Y้q0ัาฦ'๋BตU•uฝ>ฟญกลN_ฌี๒๚TU5‹RUแ–‚Lฐt:คษzขงjฅ๘ุvcั!•z1`eวฟ‹๓JKKJL…น๑RrŠ˜ดรม*”ฑB๎wบ8XBฆ†ะ +U*) „J…˜ฯŸ‹ฑGุ~@๓๏ณงำวบ›๊ Œห™9๔^–ถ๋๓*evถ๒x–!„–พ&Eว๕vิ)A’$วq„@*—‹yว’dิ๚ํŸ\;€ dฒษ&oฐ{ภKsฌื้a…ยpๅาํpฒ หŒ9!†er‰๗?Lเฉดฑ~ป}|๐’ทงพฆถฎฎฎพกษ๊ฅคฦ ฃล€€ำมShbŒรษยR23„s๔tธc2‹หJŠ Œโะฝ฿qxฤl6ฯMยกฅช๏/wฟ่ฟ๒๙Tย…Oy ”ศo๕ฉBกฃ!ๅƒุาเOฒ,K3R9 @ล,แxภ=&K+(Jf˜€หฺแœ ็พฐLฺ Qr•ย7ฺ5Q1f้``ผ)่๖๊%€@ฤ˜^‡Sœญ๕ึ‡ศ๘ใYู่šษโททีฺ-<’cX^ส๙\ไx๛กiG‹6n;ŽๅH๘#ษg4Mwํฺr๕[ W.„Z6ฤJ…@(ฬ[ญ.7หzjkฝAx ‚`0ฺccึจญฏl>งg’*ไŒs๒ีa\zช ฟษ~™๘ะถำก1๐Œ y…กQ?ฤฏ๒ฮ :๕ แIิฑRฦ5์๔‡ปT๘ฒ8%้ดปBภ็๓้ะ1Mvฟ„Šฆฟฯ–X๒ร,ul๚š›ฏ=yซ๎v‹ฆศlำ6<๐ฤนฉA!ทซฆ|\•ีลฺ›หk{|เ•hไ|Oคึว##cQ6' ‚/Aหป—!*AŒŒ๏๑Nฮ=โxrF! ’/ำฦJ<o”˜aœซ๛@sาzwขŸ!b]FVZzŽ1vขŠOสuiFฝœO๒„*}฿้š‹™ผpV„P4๖_๙ำ<๔าป—t|๔ไฎฏึn๗žžหป๏นฟLษ๓ู*~ข}&’Fก%!ฦXœซ ?4)4'ƒทณฆ~F (ำJณตแ™›V˜5ภ 6UX‘"2รึ6IzjพIภ๙ถึจU>ฟฝืทช ,<ๅว\ถึ–^ฯ Šดิ2ฉฤ7669z‡้ฑ*Sำ๒K๘$๔ŒXฺƒQb–ฮๅ๕ ๙<~šฯx;่๏ฐJำ2 u<6เlณฬ~๒V D"ัไณูŒใ—ะข5๓๓}ณyžษ่๘สฮฮnjjZ่R „ๆุ"ฟก๊ฬญณชi ลIน9”ตฺ๊^่r-7Bur’Šถ[m~…ม b์V›‹™—ภE๋ฐ:Ž_B!„Z’Xฯ๐•XXl2™L&Saถ:`ณใBss'Ui4J1”D0OKŽ_B!„Zš‚#–†‘….ฤ๒็ณ5ึ r4 l_cฃ้๙ \*ฐ€B!„PT_fc๒ร.8~ !„B!4]ุ~@!„BMถB3Fฦ—\บ้†'p$B!tขมป?BKๆคžx๘ชษŒๅ๚๋?{๋้ง~U฿*O‘šซ๓Ž@LRฆž๋>P3 $บฬLฃบฎu€'Wสภแ&ไ 9 ,๖Œ‰ด้iz้๕ตมi฿gบ6Ž_Bhฉษ(.–ร่ž_๙ห'ถ฿v๑”^๓n๏ถฏ๏อ™ˆrึ‹ํถŠ‡ A{ีหŸU7wt4U๎ูนษ$(ุถืfซ}lู}R\๖ฯrข>F ?~ไ/฿hท๘๗}ซวร ›๗ุlถฎฦo๑ูkืฅOF;๙๖7ฟจiฑ4W็ฏ/vjย!—2gห=ถ–?\?ทG!„–)!Ÿrฺํ^šeCW@xะbฟ‡ใ๋V–ฅkีiซŠKK 2โ„@ีฉ+‹JสJ‹ ฒ“ไแณ#J’ ฬๆƒD ห5›อfs~B๔Œ–Ž วQฑz™ฃง฿ภ—H๎aปfูว>”หฅเ๑„J1€Lใ๗๘ธไ3๒Žฺ;ปG›๖5ฺพฯฮ!7yšฆ…BแคŠš?ญmP]๔ฤ๋๗]qJZ =<์ฦjํฝ^/Y๓๐‡ผ!Oฎำ‰มฺiฟโ๑วื+๋w>๒๘gฮนฟ๓W๏์๊T‘3JY™+ั์๘ีฟๆฝบ๑@oใg๓Ÿ~ศJฅ”PRฅุธ๛้๋7ํhž‰”v๗ง‰[wชui]œBh!‘BนึžSXhไtLYญg]CvดวๅeฑD๖„X60:์$%Aดภe‹งาฦ๚ํ๖1เ=๎˜ฬโฒ’โฃ8๔Ÿ€ำมShbŒร9๏—,ฌจ๛>+‡ดAบปป รŠ+๘|$ะœ2›อSZ^^~Jฒ ˜žฯป์‹Œ'ญป๒Ž๛6ฏ{ไฉ๊;ทถcNษ=xูE็tฦCG‡Xeแe[n;=K-โ‹cฦb" Žใ€aX ‰(ใ๙| €ฆง๑x#ด็™ป฿Iธ๏ย-/Ÿฒ…๓w๋้›~ถฃ&|-.พ๋๙b€šGXฟค–ึDก…ฤS๓2•{@k—รšf6ะ฿ุA„/๓ภqIั—+BฎR๘Fป&kห~{[ญย#9†ๅลฏLO„{Nqถ>ิ["—ํh๛>‡ดX–ํ์์์์์œ‹”B๓ƒJHOiทzฌ฿ผ๛จoลO>พ1))>๊ด‚~อEๅ[Hผ๚งงฤะๅ=ยตฟ}๖Š{ๅŸKฏ๚ใวท&‘ล€P(!`Yvผ|j๊Nบ๙;ืํบ?>{๕y[žydํทŸ๛ึีป ๑/๗_pำiืn^๚๖.ฉy-Bhก*}|ฐซชi๐ผpอƒษfCฤ@8€eึ˜*ไŒณฒื†/‹S’Nป+|>ŸX<#C^ahิฑ Tา9ว“จcฅŒkุ้7;ฃํ๛ฌเ๛ำ-1Sถ~๏ฏ>๑ไ[๏y๎‘Kuเ๖›ะืa H’’์๛v]EฦวCตƒ&y BeBrฆ๙œb…'cพๆๆSu 8๙ส[ฏน~OW๔ิ78"็ิืำร‚๒œ฿๖ิ‹?+”ๆœฝqใฦSำ)eฺ7O ๒ ;ฟ๕๘อV'KฆƒƒWmOซ_จ %]๕เ&ใ2ป=!„ะ<ก(Š ฝž็๗ •ฑ2Š$Jตœ F TŒ2FภˆEๅqกฤศ๘ฏw๒;)ืฅ๕r>ษช๔q|งk๒'ฮี} นiฝ;=%ฑ.#+-=ว;Qลพ๏ณ€๓ท"ดฤ„ส_บ๋ทฒ[.Yฟi-ๅ๎mxw๛ฃ๊่ดvฤืึvิ๖V‡ฎ9ปำฺ พถ_๒‹w๐๒ำuป~qัฺถฟพ๕โุฏเณwqTืย?3ดEคีJซnษฒeYอ›Pž6JH0%˜$4ร๗ „€1-ิยร„G€I!ฆ„Š)/$Tƒ-’lk-Y]Z•UูชmSพ?$หฒ=ป3าฮช๙Z9็žsฯŽฝ็ฬฝs/ฦชห~]]ฐ๕ฝ_๖๛=1, ฝ๙วื-ูฐ|อา^๙Œ๙ฬGฯ0ฎพiหๅ`YปyหZxwใ+Ÿ\ฯทOป๊ยM็็ุกo?ฐ้ะph/ถํO๗๕'ol๘้]็ฝธแอ‘คAdมCi*ฑ›&?ฤ@0”ซฃ]SXT‘)ƒฐo ๅ 7f#=ำi\ฒด"ƒ ฝ{ƒ ช˜ะจUมฑฑร/…๛;ิK*2$Lุ7xฐํุ L‰…6ฃ/จ)1oฒิnzะฑฃอ ั ?Dษ่@่ะ่๙ว>ˆ”8[‚!ศยไ5ป}๑๒.ฤ๔Yq็7๏_ง๘ห+๎rฎ]YT”””8Žน๖A‘มฦ›ru8Cบ์lํ๊pz้ค4ฮ[์v๛ิทLq‚ ‚ ‚ฤDข6˜Lz%R•qC’ 8€,B๐q2๛เ‚,J๐B"—KY*e} “ำ8o9j฿@AA˜ฐt$<žO~HNใBื/!‚ ‚ "ฌAA ึ‚ ‚ ‚Eค๗ตuiAบH"ะ6ใ48(ณสKeํป:|3t@ชษ.9มl๙ฆutข!5ณ /Cง”ะaŸซฃตRm),ศา+ฅltฬํloฤ;˜>ษ”ด‚์4œ ‚ng[k€Pคๅ/ษNSหI–๛:๖xโ๗rLŸำ“ฎŽ 1PŸ๐๛ทญ‚$Y†฿;›ฯŸoๆฺ/A๙&weY†"ิ]_฿+ากc\ูEj^UY†๔ะ ัดซig›7~/ว%œ‰Yฬd๏จ$J“[นฬ์q์luณ@ฆWษปw๏ํ[8‡_Hตถย|‹Vฮ†ฮถถ฿+สฌ๒๒์”กขไ"ีฉ& ๅlp +lๅ…้Š็lF?ล\X`ี‘Tฃฉถ"+ฝ๗p˜PeๅZFh™97W>ฒow_PZ‹ห๒L#๛ขย๛TX sๅCŽ=Žกถ•”dง 9\”สœ๎ฎoŽBŠตdE–ฑ฿ใดyฮ>…K WGxฝๅ”w |ำ›ฏฝ…žนvAdมเ๏u'คๆUˆื'gvม๎ัJ”E g่8“ฝXI”Dซื€GhuZBs3Š™A๓Š ม–ฦƒRŸ_Z”ๅำ๗\i™9ื*‰L Dชผ{ฦ๋b–e˜๑j95ฏ*?zะฉฬอ3ศ)Owsหภ c^ANบFฦ„=}ํm}> Tถๅ6%@™=ฦบ๖48ง๑FฃฎN็ศ˜พฤจ:ิ&Sฉไพ~Wฟk$bีชaฤซI=.W€b#ฐ%%€ป~เ๊“Lีj|ฎ}c๘บwŒทาT”‘ั44อะQ*ๆŒWŸำฎŽ 3มธ๎๑—K>| zฆต6฿็l๚ล‡Gิ+oy๗๚ž Wฝุค๕”nฟvm‰ž๊฿๕า–_lœ้ด!‚ ย]LฉฮV”gVษคR’ Gˆฑ=อ.Gf(ฌ5…:c–lฐีฅสฑฅz6v๛Y~๓๎ะq&{1’(ฟ?ชำ+ม'ีฅ† ซVำcu 0์ส.6ชบc1ฅIอฆ๊่W-)‡oVUFqพIeฤโ IDATMฺ“ลาl–4๏ฏkSุ–•e[FX‰)ฏPใoฺ —-ษ๒ํ๎๔๕ิo๏I`q€\?ฅ Gต^/qS„BฏSส)๘ปLHUJ9เ.b๔)•สXR•YœmีษูเHwk›+ศBธฏน5งธฒf ดฟซฉe$fภี็4$…ซ#ศ IฉจNู|๗Ÿดโ—Ÿn๛๐oSšำoผณl๏ิข๚ฏ;žพ๗ฒ=<4หŽ"‚,ธณ Pf-ซษdYš z๛:bฏธVXr2ขป๋FeVInดญู5พŽๅ˜ 4Š๐žNwๅR๋ะžVWiฑ^ูํrฮธCว™์ลHข(ท›ะ๋ๅCmศใQ่fูD*ไ‰ฐฉYลๆHwg$"ืศb~™สฬœ4ืŸฌX,๛โผ?M* ้’แๆ}ƒŠB›๖Pspฐ{ @ฑLภใg 9(U๊ˆ{ศO๒ศิj™(๖u๗ด๛R‹ชjซซVไ)ฃ‡gซH…ึœ]XZQ‘'่˜LคVร๖๎ฝซกีงฮฯ3ษ@–žŸงmุธท#˜^˜ฅYPว"ศTB{ถm๋ 2>GCSฑคฒ‹Š†พ๚ธ)ภPฎO>ชำ—”`M‹ 2s8ณ‹@Oใ๎๚†††ฦฝŽoJnพ%ๆษTh๒์Bชั(ต›ƒ๘†f่1;J34A.๔”…3t0d/์qKtฆ4ํ๖ฤ{#vA’$หฒ„\ญี*%,หd์Œ^fสอ`{;‡ใฝŸ;]Ž˜ I2'''==]*ๅŸ—˜z รJ นKอ CJˆก๎รๅ{๘ร๘=J„ยRฒ"RB‡|ทฎn็ตฮIศuฐี&!Yš‘XNศิHtyหŠ๔aW@K—;๎ย๋์P,Pžแเ }๚tCpฐลdย}รYๅ&m—฿3อŽ&V”Ž7x๏ D}ธ้ลพ*“I3ฯh๋ ค)!็>๙ฌ9† ฒ๘เส.  Oค{แแ€Uฅˆ๑cุ7ฆ)Xฑ2‡ฆรŽvฯ”~'?,๔:!œก›^ฒp{”%ึhoc”ดฬŽำโภ0 A๔p๓ฮaฉ…8๔๖ภฑฺ์lฅซ๙@@ฤ‡๖Gิ ููู)))แ0ฯKบG'ฌ!Wห^—s,ห†๚›zฉY`!ฦ}lR( ]–iา๕ควๅ€L&ฃขiฐZ"]uŽ๗›%*cšš๖{Bฑ๏3Š:ReY‚$ว}Ÿyธ˜า็t%cƒฉ3’X†%%4&ŸmPี๕สอ—=฿=w~!‚,8ณ Ezaพผ฿แ#6^ 7็้FwXh็‹g่โ${เ (ขฃ!HKŠษ‚ŠD@.—ะ —ห#‘ษฬจฌRฉืษŠeซฌ—ตvMO}}O‚o{1‘––ึููษ[<$@(8&ื๊SHR•Qธ4Ssศ~4–ฆ๊Sๅ2น2E&BLj3 ๒ฌZ)Qฌ้27 •JูH„๋~Rf,).(,อK‹ทœ‹๑yZs†ZJ’ ]FZŠื ฦฦขฉฦ4 „D•nPงำ็4%dv้๏sfUŸ\lL+\s'ชวป[L+ํู Eมบปผด,IซAŽ8ณ‹(+ัšL:9I29Mๅ๗วฺ[‡$™\NA,ึY†˜p†.vฒว ๋ํ aฝ; เU™3ต2‰$ลhM'FFญ9:ซ tํ>A]‡—qุžp๑Gอ?ศๅ๒`0ฉ!ค\šยาสl)A‡ฮึฑC้แžNใ’ฅํํ๋œN ฃ/จ)1K`ฉ๔ cG›ปฟฝC]ฐค"Cย„}ƒFh คฉฤnšTn2 ๚C”Œ„ุธ}ดv( Š+ฒฅlุ๏:ุ6D€ฏทuฐ0ทฌชPสFว]ํ‡<ุงpษX๊’4\๏<๕๗“๎}ๅ‹ฺ฿๚อ+Ÿต|๛ํฒ;~๛๚ีzIะนใ…[c๎C€ ฒศะไU.ห_ดนยž=ํ#9 se#=๚‚๒jIG#mญƒฑ6 นzƒหWิฺ€ฅร^gKsฏ?A— \ก“s'{Iิเ} l•=qPU˜_^)gCngK๏dylV™ ˆ”””ษ?์vปภe0ย%„ำะฌY_(`@Žโ5ป}™]JJJว\{ ˆศฬ๓าXTm๖ิ9iRi++•vฬ4^$ cŽอ@น:œ^šง๑0mfžI2ฺ=๕Xeแ๓ŒฃRM๑๖oEAAfฦ?<”™[Qe?ชšฅฮึธวˆ!3Bข6˜LQงำหืxBฉ7™dแพ#ชแ๓ฌAA&‘‘ถฝ#sํฤโ'่lฺ=ศ๕พ6gใaจก–n‚Šฬฐq~ƒ๕‚ ‚ ‚ฤ„ฅ#แc)q6NŽr\8ฏ™แ–?ณถฺžำฎ๕? ‚ ‚ 2;เ–ก‚ ‚ ‚Eœ๚Anฐๅ็[Stฦ#IฆZ๓๓ณ 1ฯณMP]4CโนดH2oโ‰ฬ!คฅ๚โ ืฌ?1—E"‚ ศ"&^BGช-Eห+kjkซW.[bQ“ ษญดื๊ 2ญธึพฬชฉ&อb1จd‡<’คส`ฑคซcฆ ช‹fH<—I@ๆM<4้๖๋๘7๛[[ฟ|sห๚Tฑไิouโ™๓ฤฑฝโฮoœฮ๚พHๆs๏z๔๛ถv`ื^์†ี™$@๖ฦmNงณซ้ห?๘ำ•…“ฅูฏ}๊ฝo๖ทถ5ํx๗ผ,@^๖“'>ุu ฝฑsำ*5#B™คๆUูํซ*หŠlบx|งWบลาัศา4ซฦำ;ท•๊lฅ+*ซชkWีVVTT›$ฉyUๅYบ๔%ๅี5ีล†ยฺโ,๓’ๅ+K-ฺ๔eๅูš…uโ๒ฑpfชZฃql ืก้ะฐsŒF™ชี๘\cรD}];ฎ๑๊+ง] p “™J%๗ ป‚รDฎ‘ˆVซม|œ๚ม฿p`โผtฉJ)งจ(Pn7ฃำห•:mศใHใTถๅ55%fSy<’RsIMอ๒ฌ˜ 7Tอx.-’€ฬ›x.` z€วํjtฤ`4ฦฏฯปๅ'าฟฟŸถ|๋ฆท–{ๆqเซ/*kชฅšoูห ๏Oพˆ๓|มx๖•k‡zฃžษ9๕็O๘ิŸu๋๕ู๛ถท‘YงvํZ)wŸฤ‰ท=}๋้†]m้/Ÿ฿ฅ)/MeF่ๆอ›Ÿ๙ๆˆอซง๛—ปพ—ีฑ๕7ฟyYฐ๎7O^W `น๔ืฟพพ๑้๛ฝอSzฮฟน2O„ุ!‚ฬพŽบํท๏๋ŠุgŒtkRoอ œฃLLu…%'#ฺ]_ทsGCo0ไ์ฟ_i6K๚๖ืี5 งไfฦ+"ึ้V็X‰žV๕J‡1p…NชC$ยฆfš”‘HD.—Hฅ2–Teฏจชฉฉ\VhRNTN\9ํย€s˜œPแฃึ๋ฅ@(๔:ฅL&ฦสป๘} mบู”–fPE„4๖ธ%Yฆ4 ํ๎f,: ƒ^ท› ˆ<$๖ป’Pฬด'Auั ‰็า" ศผ‰็ขฤ๛ื?๔ๅลตWTฏIOำธ8„_}5 —ึิœฆซVB}๙ฏว›‰}๏กอ~ก๊=๑๛ZkฆB฿๖ชk฿f/ฮฃkL&ผวีงิ ืPjฝ2๐ลฟ๑ง0@ ้ƒญM๐ช๛ฏฎ=lฃ`eฅ/<ซg>%ถ{™ไuJ0๚ึอ็9$ํ_ษMฝ๐ขาœ@‡ˆมBYx“nBb0ง…\๕๑/Qก0=QRF ƒav(สใgtŠ๑ไา็๖0ดž๓ธฃt:Mศ๚p„NN’,หrตV+‘ฐ!†$I €ิjุ๛vทJRmK—ๆ™Mƒœ9ํย€ไ&ฌปงทดจช–ฅ">—7 ขฬœลฉ$บผeE๚ฐซ ฅหˆ.}nฒฤํmŒ’–๑–๐PปcH=Iฺๅp'O]4CโนดH2oโน(ก"Q€ขh ˆณu_n^๚ฺK‰ลฎcw฿ฟ|๑๚dYhš’˜๘_'44ไPLโ๎s–[_สผใ›Ÿ8ๅf6ิ๙ษรื^ไnฮY_นBRภ6พtw#Hณ*~x๓ งSdสT€ฑXใA9Nˆ™nZƒ.8ฺŽซ๖i Vฌฬก้ฐทฃ3ูฮฐXฃๅ ร0Aะรอ;‡ค‚aX`๕ ๖((Opp…F ƒWNป0เ&7!ืมzW›„diFb9!S+†ุ๋—Hƒีฺ้๋่์9๊nศPภ;4zธ@N1––ๆT4<’Cnii)ๆ๛๏ ช‹fH<—I@ๆM<0n@ซี€TงืŒบงU)…พ๚j7@yอนซฟ• ๗/!๕šT*€h4ใ:gŸิ—7ฝฒdๅi—๓p๎ฉwxNŒฅ”‘p`bข4ซ๖ผณืฎฬ”)ฮบํ‘Kหป๐Œ5—><๑!‚,Jbฆ[ ึii'๎kฝrsžnดq็ฎ{๊šฺ‡B jN‚p†ŽŠD@.Ÿศ"ไry$ จ#฿v†œ9ํย€s˜ใHTFณI—2™แห4้&ญŒก@&“QQ1= •JูH„ำ๋ํ๏€ษusdŠFง‹Žจoy$ นZง“๙bฆ™ ช‹fH<—I@ๆM<0Ÿๆษู฿๗@xปแปgศ ๗ณฯb์c$อ_}ัท2 Fศ>qzตw๏{๏4ธ๛ฟฒjฟต๑*=ด๏ฟ:โ[ำ๘ใŸ^^j]ท  งqoฬB…ฃOํบง฿นx่•ทถทŒE๘C .=ใผ•iK ฅ๚๒ณึฏฏ์๚โลฯ๖์๖ภบ3ฎฟซนNฟแฺ“[ื—-‘’ ะgๆูkชtpช๒๋Vทฑณ„kD3 $‚ ศB"Nบ%Oีศ}1vี™€$™\N!vJV|œภ:๏่h5S;๊ Htึtbคy |ž@ž9CํJR3าRผฮภ๘ถ@วได ฮa(3–gซภ ฿8\ ฉอ(HW…›zคฮš.๓ฤฺงiZฤYฟDi*ฑ›&n9Jb"ห๋n๘บ„ถ<’ิ@ำืƒq:JP]4CโนดH2oโน€๑ผs็Uม=?^w]yด฿Kทตe+ธ$ตืlูฒzs๙ถl๙Q๋c๕๏4ธก้ซฏ7^bตB๏?nโฑFซ.๛๙wuมึ๗~y๏๗ท!Ž>้๚พ}ฺUn:?วภx๛M‡†์ี7mนป,k7oY ๏n|ๅ๓ท>ลUฆ๓“K~ทฤื๕้Sฟฺ๒o:จ๘ฏ>^zำ5O<๐ส/.8๋ปผ๙{UiฯYธG„ 2ฟHอซ*ห฿ฦขยžฮ}๑W๑ร•nต*86/ไ๊ ._Qk–{-อฝ]Z(p†Ž๎8จ*ฬ/ฏ”ณ!ทณฅ7hํPWdKูฐ฿uฐm่˜‚X`ซผ8‡  ๚C”ŒLNE…๛;ิK*2$Lุ7xฐ-๑อ[€H™ุ–ภnทo฿พ}ฝ(Œ96ๅ๊pz๙|โ‘”h3๓L’ั๎๎๎ ช‹fH<—I@ๆM<วyอn_7ฃ;yแBๆta•…4๛ŠMŸถ๖ฑุkƒV๙อ๛ื)rมŠ;ฟญO คคฤแpฬต‚ˆฬAaรCาฌŠชสสสสสสŠcุ้cy r$“ษ‰TeœฬR’ัธPgศๅR– Gy '>I‰L!%จH$ฦa ช‹gH4—K@ๆK<ว™็‹E ฮ? ศขP˜’œ0Sฒ”d4ฮ[ŽชฤyŽหา‘ฐฐA๓Iาัธ—Tฯh.-–€ฬ—x"‚ ‚ˆหแไdJ–’Œฦ…‚8๋—AA9ภ๚AAAกซศTk~~–A๋บ`หฯทฆ ่ŒG2AC|๊ขฯฅEyOAA$ฉ{T,Yt w”{ำLฉ&อb‰Žu๗๙ฮ๋‚%4ฤง.š!๑\Z$™7๑DxQŸ๐๛ทญ‚$Y†฿;›ฯŸoๆฺ/A๙Oj^U~d_ƒsึN+Vf•—gง ๘ฆutถL.pไึe•นš) ใ็i)iนูi9Aฮถึฃษญ\f๖8vถบY ำŠซ‹ไป๗&|œวฌAช-…Yzฅ”ŽนํmX–45ณ /Cง”ะaŸซฃตMบฐ๚jญ๗B4ๆ?—PŸฃ~"^เ‘LะŸบh†ฤsi‘dฤแ%๐๎-งผ ๅ›4xํๅ/๔ฬตC‚ 72sฎUม็eำ!:x`ื๐ฤVจ]~YF` –ย\๙c#Dจm%%ูiC€Dซื€GhuZTn!3็ๆสG๖ํ๎ JkqYžid฿w]j+ฒฒ๛w‡ UFQQžฑก%๑#ไ„ี,D€‰นc&CG#lœ๋‚%4ฤง.š!๑\Z$™7๑DfŒqใ/—|๘@๔ผMkmพฯู๔‹Žจ1V๒๎๕=ฎzฑH๋)7~ํฺ=ีฟ๋ฅ-พุˆ!rAศล้๒จปปฅe€็x่D u6›rจฃ_ตDOLชณๅ™U2ฉ”คยbฌwOณK•W•=่Tๆๆไ”งปนe`Œ5ึšBŒ1K6ุ๊RๅุR=ป‹๎๗”ฅฃ‡žAชlVปป%@ฆj5>ืพ1 |]; ๛Q^ >ฉ.5ไฮ‘ว3C!“z\ฎลFผaKJ g Sฉไพ~Wฟk$bีชaฤ›จya๏?Hอ%55หณbฟ*๒ššณ€b„G2AC|๊ขฯฅEyO$R*ชS^พ๛็ฆํ[—žn‹%ฅ9ฦ;ห๖โข๏žณแนเE๗^V:›."‚ฬ1)&ซrดฅกกีซสอ2$๑ฬ/efNšฟซวว“แ+,9ั๎๚บ;zƒ!็fืx๖ฌ4›%}๛๋๊š†S&ิ(ยmnuŽ•่iuQฏLž๗sฉทfฮQคRKช2‹WTีิT.+4:ซrป^ฎิiC๏ย*ฅ วงฆค*ฅœขb-JขยFญืK€P่uJ™LŒณ„ีlุ๏v{C1g;่ ืํ๖‡DžG2AC|๊ขฯฅEyO$B{ถm๋ 2>GCSฑคฒ‹Š†พ๚ธ)ภPฎO>ชำ—”่gำGAน%์๊๊ FBฃ#^VกHฺv2Sn9L๑ RกษณฉF3Yปห<~ๆŸ>ท‡กzฬใŽา M ๊ฤใi"1˜ำB.ืุ๘_Z ปo๗ฎ†VŸ:?ฯ$o{)MGป=|๏gฮ?H…ึœ]XZQ‘'่ˆต๚Šu๗ด๛R‹ชjซซVไ)ฃ"ฝ฿!๐w—ร็zxจ1$จ'ษ ๑ฉ‹fH<—I@ๆM<1่๛วM/๖U™LšyC[ืP M 9๗แnX‚Gฐ,;๙!i๙7ฉอฮVบš„d|ฒa฿˜ฆ`ลสš{;ฺ=‡=a1ื 1 ด]pด๋Pถฬ๋์P,Pžแเ )€€ฃ,ฑF{ฃคe>]ฒ"}ุี?ะาๅDใU?!ืมzW›„diFb9!S+†ya๕ƒฤ[œ!jksq—-)ฆยtชฟนs”๏น0d‚†๘ิE3$žK‹$ ๓&žˆจฐ KJ&&)IrโEQ]ฏ|ู๓s็‚ ศโFฉืษŠeซฌkํšž๚๚Ž๚rsžnดq็œ—?ตNK{๚=“งจ#็q&‹@#CEt4iณ๋`‚ซ%าU็฿ก.XR‘!aยพมƒm‰o DJJสไvป}๛๖ํRmfžI2ฺ=ยฝ ฑย˜c3Pฎง—ฯ'ษ ๑ฉฯภPH—m ใ mnG4๛IŠŸโ็5ป}็Œ Iฃคคฤแpฬต‚ˆฬCR•1ะๆvDณคจ‹gAAŽ๐4ซขชฒฒฒฒฒฒขฤvบฤXž‚‰๐ไ„3\|นฐ๙ศR‚ŠDh๎u#„D.—ฒT8ส;%ย'™ !๕b๘†6ท#š€$วOั 3ฯ!‹œ@E   0ไ„3/[›3Žชึ:t4/๑c้H๋ย%4ฤฃ>C|C›อA@’ข.š!AAqžœp&‹/ทถ~ AAA๋AAA„#ฌ~ Sญ๙๙Y†˜วฬส ถ|kช€ฮx$4ฤง>CrCVกอํˆf? IQฯ‚ ‚ ’Tึ*ƒล’ฎŽ๙ฒ„T“fฑT:ใ‘LะŸ๚ Iี้๑‡6ท#š€$E] “jmKWTีิT./สPใฉฉp‡คš์eตต…†ฃ”Yๅซ์ํšJ{Mกž ำŠkํหฌŠูr\ ฆ{‡L{โฦIัCญ๕^ˆ†b]๕9๊‡ "เษ ๑ฉฯภำ๏จŽ7ดนั์$)๊โBกzใCKท๓ูžษx๖ฮต;‚ ๓’๐HW[„๑r;R2๒mฤภบมD“SZ’ํู๊fIc^‘!ุาx0@๊๓K‹ฒ|{บp[ึcเ ]Šนฐภช#๐1๒2sฎU™zฦ‚Dซื€GhuZTn1;ไุฑ'f^หD#‘h์]ฅ:‰DปN๑H&hˆO}†Xพกอํˆf? IQฯะ๑L๚‰7>๗๑๎ๆถป๓๚c7ฌฮ$าพuทํtดlโี_`‰,–๒ทุ็tพน!@Yฝแังžz์†“}žร๙ๅญ'Hฮ๛ณำ้t::ไe?yโƒ]ฺ;ท=ฝกR3ฅkรw๎๙็žƒพ๚๋ลว๗ผ‚ Ÿิผ*ปJEˆ IDAT}UeY‘M'”@ะํ 2,๕นฌ2EZฃql ืก้ะฐsŒFULuฉฮVบขฒชบvUmeEEUฑIšWUžฅK_R^]S]QlQ`(ฌ-ฮ2/YพฒิขMฯ_VQžญYX'.sภบh`ิีูิิๅ;บภ#u6›rจณJ™เ๗Guz%€F—๒gำ๓„™ฦœcO a๕ƒิ\RSณ<+ฆk*๒ššณ€ไ€G2AC|๊30คสโฺŽh๖’u๑ ฟ'๖๔ญงv=ด๑งฟ|~—ฆผ4•Pฌน๏/wž“๚ู]—]๓T{ษๅ=yMa ๕ึื๏ูผ๙ฯ;#ƒmูผy๓ๆ'ฟ๐r๗ู๊]›ๆ`๖e๓ๆอ›๏zตภr้ฏ}}ใำ๗z›ง๔œ๛seกŽ๕g\{‰z็Wาตwn\S๐‚,h|uทo฿ืฑฯะHwฟ—Bชัชi Uศ!aSณŠ MสH$"—ว|๏Oaษษˆvืืํัะ 9๗6ปฦg๐•fณคo]]ำpJn–aผRะ(ยmnuŽ•่iuQฏqsW่€Œธมc—1(3sา]=พฉO )ท›ั้ๅJ6ไ๑.จG“ำธC€{์ ฺ$ล†nท$s๕ ๔บtX€[<’ โSŸ!:ฤ3ดนั์$)๊โ:~‘๔JญWพx๛แ7(XYฉ…ั7_{๕ณฯี™ป๎ท‡ก๕๔˜วฅำiBถเ็เุะล@fสอ`{‡)ศ˜ฺ๖ธ%Yฆ4 ํ๎f,บค;+ำธCb=!พเ๎rธใ\ต;„e<’ โSŸ‰!พกอํˆๆ ษPฯะqหฒว6Dทmน๕ฅฬ;ฮฟ๙‰SnfCŸ<|ํีO๎–หe†‹ด๏\ ไPซิ‚ืะr๖ษ9มห่+~x๓ งSdสT€1b๒G‰ŽR @”ข€$pรhA่Aว๖ABช4/อร รA7๏Z&ฮเฐoLSฐbeM‡ฝํžษv๖๐‡ลP'ฤโ่ะqN ‘ฺ์lฅซ๙@เจuผทGYb๖6FIหlธ+ย๏ุcOa?็Cnii)ๆk้)ฆยาา\ƒ€ต <’ โSŸ!…ฉ ะๆvDณคจ‹g่ธ`ddภ`4ช๔t%ภะะ0uเๅMgฏ,Yyฺ%๗ผ?œ{๊]7žฃ†H$ 0๚๖-kึฌYsŠฝชช๊š—ง๕๘ŸซO†ฆH™์ะืค8๋ถG.-o{์ย3ึ\๚l3GGRฉขQัBY$HTi&ญ€ฅ‚ฃ่๘ฤo$r๙ฤฑrน<9๖eเ‰‹ๆะฺ/น๖ฒRซบ๊Ž๛น#AฃQฅ็[Uมฆ?Eฆtช?ััkฆvิ่ฌ้ฤH๓X m’ dr9I„XŽู้ลg่ธtํ5Q–qยJu฿7ญฃ ษ`ฝ๛ฝฐะ‰y‡(3–gซภ ฿8\ ฤ{ยซจฆฏ!๖m9ึ๐uOœ๋‚%4ฤง>C= _๗ฦ๋rnG4I†บx†Ž ๒šGT๗ฎ_}้Eิ@รหท฿๑ฤ>ิ๕|๛ดซ.t~Ž:๐๖›๘ ๐๑ฝ—Rzฯ๗<๓}Eฐo๏๛ฟ{k็t๖— 9๛๊ร฿\ฌๅพ .บ็มฎgv<๙ั{ฟ๛ีวKoบๆ‰‡^๙ลgฝq๗Ÿ7ฏ*ํฏฏ=๘xฮ•gŸ|ใ}gE๚๗ฝr๛]5$' ‚ ณDj^UYฦ๘* {:w7๖ลš=iXRผา*%˜hะำฺzธใ ช0ฟผRฮ†ฮ–˜ OCฎเ๒ต6`้ฐืูา๋Oฬฅ…w่@_PSbฮธิnzะฑฃ้ฑภVyลผCขAˆ’ัไNE)))“ุํ๖ํทsHIด™y&ษhw๗๗๒…1วf \N/฿{ญ<’ โSŸก.;@mqŠ๚Žh๖’?ล34ฮkv๛:ฮ;A’FII‰รแ˜k/™yƒB‹ชอž:ว @*meฅาŽ]พน๖kฑ‘`Zศฉฮำ็<ใจAุ๛„Ro2U1'+$jƒษคW จx$4ฤง>CR•‘รโ๕นั์$)๊โBAใฦ?<$อชจชฌฌฌฌฌฌ(1†.ท#š€$C]DCศ1tๅ๒๕nใ๘ง<ๅ›พe|BA 3็Z%พœŽ_Rฬ…V๐‡๙ว96žญ^nกีiIˆuz๕|%ุP฿+๔TX‘๏%A๕KG#,0ฑ7ฬd๘J&hˆW}†8%ง6ฮํˆf? ษPั"ฃฟ๏ป้๛eiฬ@ใ›๔Žุ'ูซส~x๗ญ—ึไค๘ฺทฟ์Sฒ7@ZOนแ๖kื–่ฉ]/my๐ลF<จAD|Hอฆ๊่W-Qล“๊lEyf•L*%ฉp„๋ำ์RๅUๅG:•นy9ๅ้nnc …ตฆPcฬ’ ถบT9ถTฯมฦn‚AF]ฮ‘1}‰Qฟ€3ž~TงW‚OชK ๙…fโ ๗า4:"คสZ^SSbŽ]kจl<%4ฤซ>Cœ’S็vDณdจ‹hแ‡ฌธ๒๖U๛~uษู็]๕ผœ[/)-j๙ฯ~ยผvบs.พ๙้†Œš2 €ๆ๔๏,๛‹‹พ{ฮ†็‚{Y}Adฆ(3sา]=>ž _aษษˆvืืํัะ 9๗6ปฦ็่•fณคo]]ำpJn–al2"ึ้V็X‰žV๕สd!ษะ—;H h๎xRn7ฃำห•:mศใ]pฅ”2kYMMuueEู‹:nB/๐^š‚1:ไuป้plซtG@ d‚†xีg`ˆSrjใŽh๖’ u !ว}๙Ÿ>๙1„?ผ๋ฬฟfฯc—^@เ›=]ท•ฅวึ% R–š–ฆ!zถใม‰scฒ‹Š†พzช)ภ@เ“๊๎Q‰šณ0Aใ™)7ƒํmฆ #พ  ำu!ีh”08พn'8ุ= (Ÿั)ไเs{ZOyQ:&d ๊ฤใฤˆฯฐว-ษ2ฅIhw7cัอ•s3!ะำธปBข4็[{๛Ž]ฑำธ—ฆ ๚!<ิ๎JH@ d‚†ฤrใ.ษฉ๊s;ข9HิE4„C๗sW๕ƒชไปo9ทPFE vฦัํ{ใแ?ไ\w๓ำ?ฒP={๕ท}โใฮ(ศdาฬ๓ฺบ†iJศนOž ‚wฺ์lฅซ๙@@ฦ'๖i Vฌฬก้ฐทฃ3ูฮpี ฤŽgภํQ–XฃฝQา27พอ†Š„ฉ๑แแ€Uฅเฌฆs/ GP 0คำอฃ1[M1ๆงSqJ&hˆW}†ฦŒ’Sี็vDณd๘)ข!„๓ูื_<๖ฬ/ฬฯื=ZY<ูฑo>xร› ำๆV๐็ฟบํ=ืพ>DQTื+7_๖|๗l9Œ rผกิ๋ไ ลฒUึ‰ฟตvMO}}ว }น9O7ฺธ๓*ฦƒ3žญ@€d( ˆŽ† m.œ6Š๔ย|yฟร€ฃJD‰ส˜ฆฆฝรž0{i:ช$ŠT.:ป|%S4๑J&hˆW}†ย\’Sี็vDณdจ‹hแG"•ฆจ•$(า–ŸSmSูlนำaŽ•$rื๒ƒ๐Gฏ้py\./ ภ@wk›i=๛ๅ๎n(Xwหี)o๓๗}ัY‚ ศ"&ะต{{ื๘GYฦ +ี}฿ดฦุ้‚$™\N!€eqy/7œ๑ิไฐ๎^X`๏‚DY‰ึdา ฝ”DmNS๙‡W”KŠณUเ†o.ฆs/MA๕รXOรืฝ็ฎ๋n๘บ'ž€@ษ ๑ชฯฤ—ไT๕นั$ ๊"B๘้{๏ู7Oน๕ldฯ?บeหYฟ๙ใภ†k.zใšเ๏Ÿ_ Ÿ๚แๅ/๔Ž:ZคW๔‘ูi๏มฯž๘ŸwFภทํฑ฿.ปใทฏ_ญ—;^xฐ‹Aน"ไ๊ ._Qk–{-อฝ9vjึะิ”˜%ฐิnzะฑฃออูศฑฐVy1#=๚‚๒jIG#mญƒ‡ถf!JFBIอ•ˆ”””ษ?์v๛๖ํ'Tslสีแ ้ฒณ ดซร้ฅฑ็uใ8ฏูํ๋ฆษ2 ”””8Žน๖A‘™็?(คฑจฺ์ฉs าคาVV*ํุีj‹ฬ,ง1๓ฃj„x=Iิ“Iฏ$@ช2ŽภFlœ็‚ rภ๘‡‡คYU••••••%ฦฐำเWCฆ ฆ1GoศๅR– G™Chlฤฦ๙8ฮ<\„,JpA%๘ƒ‚ภฌง1๓ฃj„x๏?ฐt$<>”ษุˆ๓ปAAD\09 A็O#‚ ‚ ‚ึ‚ ‚ ‚'^ 7ุ๒๓ญฉ$ศ Yใฐ็yใ๑iฉพxร5๋Oฬด๓โฒŽ ‚ ศ/็’jา,ƒŠฉ:}6bใมHuy%9dฏฃm4๖๙mŠuฯท๏š๗Vœ๗ฬเL]จฝื›t;Ÿ๙ณ;ฯ7sโฐ.อ;e*ซq๕ฆปฯห~wcๆีoาฮป๑ใ/o]๚ึ•ูทอิ…๎ฟ„ ‹’ไ ค˜ ฌ:2เ—้ฎCgงๆUD๗ื๗“iyมร%Uvล Š๎๚ถแ(คXKV†๊๖R\’šสeVถ฿๎ก/จ*1‡:w๏ํ ฯ๒f i\ฒ2+าr 7@๊๓Kณ#อ{บbl+\2ำ8กยม`˜fฅฃ‘H”al<๔˜CG4ฮ@’ำะิฦจฯLrาPฒ]โT็ด.\Rx<ล๚Š…๛93uม~.Jux๒w๗n๘Ÿ1ฒสsฯศ„์œNgWำ—~๐ง+ 'ลาOผ๑นw7ทุ๕Ÿืปauๆธษา›?๎q6๕" Ÿไพภ>ง๓อ ส๊ >๕ิc7œlไถNu|๚๒ห/ฟำ0:Uไ‡ฮ/o=@rŸNงำ๑ะษi฿บ๎v:ฺ6~๑๊ฏฐDp๒#ง๓ณฯX๗๛ํkkโฉ๓ณล ‚ ˆ˜H4ึฅๅUตต5•ห‹m†1fพฃQWgSS—š™พTg+]QYU]ปชถฒขขชุ$Hอซ*ฯาฅ/)ฏฎฉฎ(ถจ0ึg™—,_Yjัฆ็/ซ(ฯึ,จ„BSQ†กi€กi†ŽRLlYฟ?ชำ+4บิaีjZฃql ืก้ะฐsŒFUโ’ำ@ะฏสZ^SSbŽฝาYeใ(ษihjใ ิg&9i(ู.qชsZ.฿บ๐F^?9ีใ๛93uแ~.b}N/€ีj…‘?บy๓ๆgพ‰LฝLœxำทžnุ๕ะฦŸ๒๙]š๒าิฉcš.ธ๋ฟO ๊ฝ๗<’Si}žอ›ผ30๘ั–อ›7o~๒ /ทuNš_ฝk๓ƒœฬžฟlผy๓]ฏ6(ึ๗—;ฯI์ฎหฎyชฝไ๒วžผfฒฒwYๅม—฿Gๆ๏ฟP0ฃ !‚$…%/‹ํ฿ฟซnฃ+ืiฤX BF\๎เฑ๛w*ณ–ีิTWWV”-ฑจcงk KNFดปพn็Ž†`ศนทู5•าl–๔ํฏซkNษอ2ŒW Eธญำญฮฑ=ญ.0๊•"ธ?วฅp_s+•UYS]]ปฬ่njabIPn7ฃำห•:mศใ]P!ฅ 9D"ljVqกI‰Dไryย’ำฒ/Dˆyn:;ฐtG@ $งกฉ3PŸ™ไคกdปฤฉฮi]ธd|๋ยyไT๏็ฬิ…๛น˜aY€$I4}ฐต พSuีต‡ฏJ z ฅึ+_ผ๐š2Kjพs๋๛ŽฒๅฑŸ?ำมศbKล@k[๋ผต๗_Yํkxo๋ึ‰ต9\ึนีwผบีeป๒Ž3-Ÿm:ฑ~ฉteฅF฿|ํีฯ>Wg๎บ๓ิ5ซชีh—๗ม;฿˜>๏Š*}j๊ "„ ’tB*—I!4ๆ๎os'ฯL งqw„Di*(ฮทธcญฌกBazข ควๅ‚ƒ €๒๘bภ%Yz~žjดy๏ม0กส((ฬ๒7v๙Y.I€ฐว-ษ2ฅIhw7cัอํhฆI’,หrตV+‘ฐ!†$c•˜ย%งƒ ๚!<ิ๎JH@ $็ีฉ3PŸ™ไa$ปฤ3d>CยœAฃp€$จ.ฯล AEัm[n})๓Ž๓o~โ”›ูP็'_{๕“ปวบT๒hภ๎_ญ‘Š)9kำถrน ภp๑Ÿ๖K\j•๚ะขQpๅย’‰๐ g"‚$›๐@[WJnฒL๒Ž8;;‡‚ษyขลP‘๐ฤzฆppภชRฤxฺ๖i Vฌฬก้ฐทฃ3ูฮฐะ๋„XpE‰าง‚ƒ- ๎ฮ*7iป.ษ(@ภํQ–XฃฝQา2Wร˜ รA7๏Z†‰u# —œ‚j…ฉ ด4ื{–.ลT_@ d‚†xีg`ˆSrjc2Fฤi]ธคp๋ ๚ษฉ฿O^ฤ๚Šช ซภูืใ:uเๅMgฏ,Yyฺ%๗ผ?œ{๊]7žs(/o๚ŸxaๅW)x$ล‡กiR&›ส"‘(ภ่ทฌYณfอ)๖ชชชk^>ฒ"d#ฏืฟเŽโDไ๘€ ดํฏ฿นcWSW@“_`c)Š๔ย’ฬษšใrsžnดq็ฎ{๊šฺ‡Bวำ=g”’๖P๑ฤK’Dœxเ x‡FCณ็ถ(P‘ศๅฟญrน<™,/%*ฃูค›|7'Ždช$ŠTN-}๗’)š๘%4ฤซ>Cœ’S“1"N๋ย%…[OะON๕๘~๒"ึWผ˜ะW]ธ๑g๗={๋idt๗;๔‚บ๔Œ๕๋ืฏ.”่หฯZฟ~Iนhื=้+ฟพnช5P€op๐ะ†ƒฯX}ิ๖“{6ไORœึฅ๙ซืฏ_ฝ #dŸธ~๚sส๕เln๖q๒5lpฦตูmปwyA_yฺ๊ฒฒU?๒ฺkO\Qฑ ๖หCไธF™Qgึ*e$KE"Lyศ/.QVข5™tr’ esšส๏5)K„L.' ‚ Žณ฿ฦQขฦฦขฉฦ4 „D•nPใฦ“๕v๏?ะฟฐ๐ŽŽชฬ™Z™D’bดฆ##c”KŠ K๓าH>ษDˆท๋T1‚ˆฝpB€@ษ ‰ๅฦTNษฉษงuแ’ยญ'่'็ีคz"จŸEถซ(ห๖WผcหวฝT๖ฦm_฿]>E๊9Wœw๎ฦMWปช$วภ๘ฯs๗฿‡ฏ‡๗okycƒแฝkฟฝแ##‡d<๕ขพGN=๙‘๑๗ธญฏฺ๒่๊)ญญ=๙ก}@d‹G๏ป :+%ุ๕ฬ•'?๘5Wm|เž+VŸ`Q๛๖พป›๏xฉ%r๒#Ž—/q=v๊ษ- PqVY”๙ƒ"ีXฒmfฝF)#ขc#ฝmํƒcqv๗ˆพ ฆฤ|xbt์h๓จฬ๙YตŒค#‘๎ถŽแX3 2ใ’ๅล้ใ๓ ,๖:[š{ชผชศพgด๙ีนกฦฦ>Uam๚่7-แ•yแฝ๛FาหNuฬh'ฯ๙ม%™ฮV˜kNM‘ฒั1ทณฝm ภpJjr+mม=Žม๑oPe[Q@;ฮญ2]važ9Uฮ†ฮถถภฤผฝิXฐฌภ@4๏ํ๖ฑq%งลQ5‚ ๚Anฬฮ6ะฎง7†E…1วf โ”Lะฏ๚ …t’Sี“1"N๋ย%“aฦ๗3ูwศ8‹ง~@X? ศขdž ฦขjณงฮ1HJ[YฉดcW‡oฎZlฤOฬDlœทLใ‡Iค*ฃษคWฦž“จ ๑J&hˆW}†8%ง6&cDœึ…K ทž Ÿœ๊๑ไEฌฏAA=ŒxHšUQUYYYYYYQb ;] zJaž?1ฑqก hศๅR– GcีEผ%4$–S.ษฉ๊ษงuแ’I ๏0ใ๛™์;dœyธY”เ‚,J๐พฤLฤฦyหQ5‚ [Y:7^’ ห#ธ$งช'cDœึ…K ทž ŸœWyLฬแ ‚ ‚ˆOb&^ใBAŒ3$AA9>ภ๚AAAกซศTk~~–!ๆ))rƒ-?฿š* 3ษ ๑ฉฯภลaqŠz2Fฤc}F~๒ ^ไใˆัพbAA$ ฌT‹%]๓e ฉ&อb1จtฦ#™ !>๕’ชำ9,NQOฦˆxฌฯศOฤ‹|๑"ฺW|qย๕ฏ~๚้งŸ~๖๙฿.หฎต๒–wt‰uฆ6ำฮโํซฅPพ้ํ็~d›i?{ูsoฌœ_Aไ8@ขฑ.-ฏชฉญฉZQšƒOอ%5ฏสn_uˆ๊-hr+ํ5…๚๑ณoำŠkํหฌ ๊žณeๆ\ซ$อผ )–‰F"Q:ๆหะัH$สธณy$4ฤง>C,งล)๊ษuNI* †ถ“„€๐ชว/ข}ล าzสฝ๔๎๚๋ฏ/Yž ฦณ~๏ู็’โซ_x๋ž5คํ;7๏K๏~๔^}๊ึตูฑO8<ี@ZOน๑ฑ฿่ใw_ผๅช8ึใc;ใLใG๊'ฯ^%าW฿๑{ฟ๗_ž“;๎™๙›ๅฝ?๚็ _Yฉ‡XWn๓ฟ_ฝฤtแŸ๙็Ÿ':• ฒะ บปCA†eฃ>ทŸUฆศbJJuถา•Uีตซj++*ชŠM€ิผช๒,]๚’๒๊š๊Šb‹ŠCamq–yษ๒•ฅmzฒŠ๒lอ๚1 IDAT‚:q ๘Q^  ัฅ†Gื๓ญั86ะ๋ะthุ9Fฃ*ž4ฉณู”Cข•Hย๊ฉนคฆfyVLืTถๅ55%f“<’ โSŸ!U—ล)๊ษu>uแึ๔“S=ˆxmD อ้7Yถ๗}๗œ ฯ/บ๗ฒR€‘๗~7๖’Ÿ•n]wในx ?คžyรํ%๛~sูน฿ฝ๘๎ฏ n้๕t ผด๑๕g}๗โ_kงb[/ผฏม#฿›2๏Yxๆ๒?hšฌๅฒฯบ ๋๎ษO~นkษ ?^%อ้?ปญx๗๋ฯ>๗๊']gwUฃฑํฯ๋O:้าgบqํI'tาI—ฟะ“`0A4ก‘๎~/ „TฃUำ@4–คย’“ํฎฏนฃก7r๎mvฯเ+อfI฿บบฆแ”,รxฅ Q„:๊+ัำ๊ฃ^9+c™'(ณ–ีิTWWV”-ฑจ'า_สํftzนRง yผ ๊ัคT!‡H„Mอ*.4)#‘ˆ\o›23'อ฿ีใoˆยึ/ฑaฟ- ล\}Bฝn7เd‚†๘ิg`ˆqYœขžŒ๑X็Sn=A?9ีใˆัFด๐ศ.*๚๊ฉฆO>ชป๓G%zhr฿ฝ๛ฝ=๔—pl…K\_aฯP ้ี‡๏o#งทZNq‘๋ห'๖zขm}‘ุึป^ฟ๕Šง>๓ z&?Ÿpๆ้แmทดพ่๖ฬ฿ฟ้่O=sตอเส.*r}๙ฤ^wเ‹Ov+ฎ*Jƒ=Cœ3‚ ศโEb.ฉ)ะ3cฎVG{์ฬ …้‰:€j4J @pฐ{ @P?ฃSŒ'—>ท‡ก๕๔˜วฅำiBvฬ?zw๗@H”ฆ‚โ|‹{o@ุใ–d™า$ดป›ฑ่ๆุษ้@’$หฒ„\ญีJ$lˆ!ใd2Sn8LA†h๖พเ๎rธใ\ต;„e<’ โSŸ‰!N‹Sิ“1"๋|๊ยญ'่'ง:ฯˆ๘mD ™LšyC[ืP M 9๗Mศ๒3ืxท]9ฅiฒOšฆฅR้xŸ“EษคฒX‚ ศัะƒŽํƒ„Ti*(^๛›‡cLA„}cš‚+sh:์ํh?”‡=แ๘ฉbมP‘๐ฤt{ธ8`UฉขทGYb๖6FIห\:8]†!‚n9 ตLฬ…฿ค6;[้j>๑๗VX 1ไgH†ฺฺ\aฮ๋)ฆยtชฟนs”๏น0d‚†๘ิg`hฬXPNmqŠzRGค0qYฌžŒ€๐โ”œต;d!CQTื+7_๖|๗QํŠ•—~_ฑฏฃๆา mŸฝ‡—$%OH•AO๘GbLmณ {X๒ะร šฆmไฒ^xๅ ฯ8kJรžวึ๔ๆHซฮ\ํเŠ>NฃRฉ4JE๒S"‘Pซ€a’ภiA$ช4ฃิ็๒F€ฅ‚ฃhพ^รฃ\’rsžnดq็E9//Š๔ย|yฟร9†๑”‚ŠศP@ Aฺœy7จHไr rน<™L‹$*cšš๖{B €Rฏ“+หVฺjQkื๔ิื๗$๘ถ‡ฐ_kBฎึ้R17‡"S4:Z. พๅ‘LะŸ๚ Iฉงจ'uDึซ'# ฟฝ{ nคห๏ซค–ฌ›ญ›%ู’|{์ฯx์๙ผ ค6ชฅx  ถ(–P[•„ŠT%)จ@ธ์ฒแ)ฉโศc’ป@x"E(xHพฯŒํนh|‘eห–mฌปิญพ๐ วใiฉ–d[ฟ'ปuNO–ฮQŸำญY]ตไต!,ฑs=^  ‘๏๚๖ @M|๏Wพฑ๒[ฟ/๘้๐—ฐฟ๓|๓sƒฦ<๒Wๅ|ึV๛<:L๚ยคsp์ง~้g้2‰ร฿โOL:กoย๗พan}๏Gฟ๚ฝO๋ีผ๘ร,}๛'ถไOณŸฤ2{N†d†พ๙“๙อ์i;—าด5บฟ๑ญGา๖vฆีF€ฬั๑ภรoฮนํC#็ #„^Pxิcก ส่ฐq๕zซ…ฏ$A0,KAเU†– euนl,IŒล=ศ•หg๗*RŠ‰ท๏๚kํ4@๑ไ„s[Š2:}CD.W=}มไŸŒŒM‡Oป๘•ฝ—หงVโE9~นใมFฃ๑์—ฅฅฅๅๅe๕rŠาz๚บึ๋บKvจkํ๘๘บzมs[{zDšt ั|Yตไต!?^Z๚N‹3๙6ฃ‚?๕๑/ฤธช%Ÿ๐_ขuย๗;๛๗~ํๆ˜™_๚ฝ8~๛งฟฟ\*๘Sฟ๒kฟ๐ญ)Sู๒๗อ๗ๅaๆ—๘ฎณm๛๏ฬ๏๏ƒy๎๏ๆo|wŠฺ๙ใ฿ฯฆ_้Ÿน?<๓รŸแ?[๗ุ้ณ่๘มฯ47ชDoีPใทีสŸอ๔'ๅณM3๏โwพ9้1 /๔[?W…ำ#๚'ฟ๘““v้x๛๛ฟ๓UฎีFf์ฏฦo7‚lๅลฟปฟ๚?Žz”ๆ^™ššŠFฃ7 „P—ะ มyฦวv#MศZแh'vXnq…qŽ?˜jNxU$พ˜8(sก'aแอZฒึ๐ยh}}{:t๒ี&?๚8ฤฟ~“šนฯฤ5๎๙ywœ;๖;ฬ ) ๅ\"ฯึห่| ๖*šjE ฬEค่๋ร™ภุ‚c!๗ซิ๓ษX์จrz‚ะฮศlฤ!oผN\\5รx๏?6~ตญz%Kร…1‚พ๑eนจ“D"ง~ใXƒs$เำ๑dQ๋๚™FษiUฟB บ-tHmญงGฤ:{ฝ[ํ<_]ตไต!M}:~่–o๐?๙?ฮ?฿}uซ์žร๑Bwา-@! ๎ยJ4%ฆภฬ4/tป๎ีnแ6ชv4ปšทม…1‚ฮ๙K&ปหๅไZ.– ฬ—หnาqๅLฃd‡ดช_!อ9ZOจืัปีฮ๓ีUK^‚zฯ๖ฟ๐ษŸแเ!„nœ\ฮfhฃ'๓๓๓๓๓๓ฆœ|25นคpญTป…Wุจนฯ~กsลhB„ฯํ"(–ฅ‘ohœดJvHฃ๚ษZ‡ึำ#าL์๕'D3jษk;Cšn๙ืE่Nย๋I๘‚ Eท๐ UปFš]อเยA็๗ธRƒowPŠ$ด}]ษiTฟJ ญC๋้i&๖ขU]ตไต!!„Bฅฺ-ผสFญ}๖ ผ["B!„BH/? „B!„๔า7~ |แฐ฿มถzuยa฿€Ži”์0V๕ฎ๊^“๎HBฮUW-ym๙D!„B=ฅsภ9<ž!sหลดeะใqp:vฆQฒร@Zีปจ{Mบ# 9W]ตไตๅ!„บ;L‡_,=st;๚ศ@่ษาา,DšOX%ƒแ๛ž>]œ0แ5“`_ZณไเไำฅYŸแ&~Yด5po๎ษb๓€ฺ=u•ž|0ฟ๘tq~n*hcบ\W))ณฝZ„Fห6ึฃซt,ะ(ูa ญ๊] ิฝ&‘„œซฎZ๒ฺ๒‰BŒ{ิG ZOpBีkซŸl/—6ป Jดm ^ฎตูมํcu:ซว+EAศ&3มI'ทWฉชd8Ž-ฅk"”ำ9มg5Cฎุix}๓—h๗ิโโห๓— ถ›7๘ˆํ48ํฆ^ร 1๙gๆอŒ{ฬ$ะ4ฃ๐ไ“ลล๙ู1ื‡gต‰๙ผlณณ&›ต^(๖ีPŠ6ฐ ส€rฬee[ญ yA6ํ4ปอฤ0˜ฎ๓๚_ฮ็ฉzหซRญ˜ฯKผŽฬk”์0V๕ฎ๊^“๎HBฮUW-ym๙D!„๎ฦ5๊Uึณ"x๋ผt: h‹ลฉๆ‘Z*q\ฤBYถšหRพ KvฉZศ7ค!‰`๚๊‰วzU๖ื_@P&Wd2์ษฟ>T ญๅํ›—ิ@เฝ+.ภ๒”฿5HI๙„์ฑpห/ƒ$IEQึlตR”R—Iฒี%ฟฟSบ7๑ไฉ" ฅt‘‡vK%tำน!ฟอทyฯ์D3บ๖คQฒร@Zีปจ{Mบ# 9W]ตไตๅ!„๊{ค54ฅ7๓šห]๙Rี™{<"I|1พS8ฎ|แNŽZ‘E›?๒GูŠใ* (…ิQET@,eks3คD€Jพ`š๒5ึค็&[}Yฒ,!e7žgh!ท™ู]OoญฆcฉH2ๅน?lํF|}๓—(ว่๔tฤีrYบั56==๊ะ1ขั(ูa ญ๊] ิฝ&‘„œซฎZ๒ฺ๒‰B๕ฤioœ่aฏdทฑ฿์KKKOBVาuoi. >ูˆu‡l'๋ฯ_ผ|ตบ๖n'S๏ซI8ฝ`›6๘ํt์$Šโ'…ๅ4O”s™J1sาWkง@`ูำฮหฒ‚pถ‡โœn—อxึรg,C.+#Kฒภ0Œุ?฿ฅ้ป@ฐf›)ต์‘F‹อึศ้๘Oา(ูa ญ๊] ิฝ&‘„œซฎZ๒ฺ๒‰B๕ ฯ๓F‡รœ›ฯ๏  WKn+{/—๗š?2๛อ‡_mŸจ—$ ‚aY’จ+็zล_g …ฒบ\ถLญ(Rf๗ WฮTไRกr{อลใ5เ4“#(ลฤ"๔ZโษIฤ7l=IV(›oˆศm|XM—ขo ฟ๛2ญOหjbํห6ฏ๋.ูa ญ๊] ิฝ&‘„œซฎZ๒ฺ๒‰B๕ŒฺK:&๎?๖ึŽc‡9๗๐Mท ž>จ=˜{Eโ‹ษอƒ๒ 7๊&ษนธ=yธภ’PฮลถS๐วqSd๒QV๘rz+–๙์;xขฯfyIู๘7~8ฯ*๕|r๓เlPะจ•๋"#Uฮ.E๑G;qsd‘—’๙Rj+ึ๙อ[€0gฟ,---//ซ”ขฌร!u’Hไ:ฝ ฑม9pˆ้xฒจฺzญ@V๏Z ๎5้Ž$ไึไณ้วKK฿Q=“๊™ฉฉฉh4zำญ@uู-@! ๎ยJ4%ฆภฬ4/tป๎šณฮI :คf/ฅoญ c}๋“ๅrr]ธแevธ\vSหู):ฌต@kาIศญษ'B!๔๕!—ณฺ่ษฃ)'ŸLwcz ๚ิY็„ๆœgฝ”^l์๚ฎ?ลhBฉำy#ลฒด"๒C,@V๏^ ฎ5้ฎ$ไถไณ้–]„๎$ผ€ะ„(ฮuNไsฝ”^lผต.Œt~+5๘๎”" m๗คจร๊ ิต&•„–|"„Buืวฮษน^J/6๖ }๓—B!„Bว!„B!๔ศ_8์wฐวcpุ7ะ*ฌV ซw-P๗štGrk๒‰B!„zJ฿๚’sx 3๏[>‹๐Rมu•’2ซEhtแแ๕ร่j„Vวจจร๊] ิฝ&‘„š|"„Bฝล็๖b‚\์ฮเ€qŽฒน7/k„ษ79rๅ7R๏_dO๏็Iูย3JตNพžTSg๔†ฤ๑๋•TฒŒLO‹ฯท๓ ิkซNYํศ—ซอJB_๕-HghยQ\฿ช๖๐๔„ฟ๔ชsฅ๗จบ๖ซพ๑ƒ"7ไ.<๔W–‚าzOZ:ฌต@kRซK|ํโสmlg๗!„B=3z2ใe บ๗*WiteŸ†.คำQจไŠผวh(I_คqŸ%Ÿุlทฅm‰›chšyจผฺHsก'แฦVา4rฐb!ฑฑy\UcO]๕ธ์๔3ฉํ47(lญ'ส}yช–บิ๒‰Rฆ&+ —๒e%hdZu›หๅ†อn‚mจ—๕๕—n ซำY=^) @6™ N:นฝ6ƒLา˜2๑#nœ๋Nx}๋h๗ิโโbr‹‹S๎Vรญ@V๏Z ๎5ฉที๕ป5ํ์ฺŸ!„๊ฒR|eyy๙อQwFMๅฤฺ๛TณƒKs&Vฯ๏œด๛ผฤq๒ค๕ไ_ƒgฤHฌฎ<ถvPซ'_oค›“Mพ]Yy—5Ž๚อkอ›G|ฤvœvSใ&จฆฎžK% h‹ี,•? ๓Lูลล……๙G3ใ๓i๗Wฬ็e›5ูฌ๕Bฑฏ†RดAP“c.“ ,neจixdฐผท_๊!๊ผภ—๓yช…›ำJตb>/๑-ฟ]ึิa๕ฎ๊^“z[]ฟ[ำฮฎ‰Bก@ฌCnืเ ƒkoŸปิ@9ƒ๕๔jปษKb—Nวmฑ˜ ีœม_K%Ž+"€X(ห6CณsYสdษ.U ๙†4$L_=๑Xz๊(๗ิbฤ.Wำั’•๕—‡”ษ™ {๒ฏ๘Bž๒ป))Ÿ=ถ;Šห#IRQ‚5[ญฅิe’l}E€qz•ƒ๕ฌฎลืน!ฟอw%Ÿู‰fฎจร๊] ิฝ&๕ถบ~ทฆ]๛#„B}€ฒ…f'์|๚่xs/_iœฟา@Xถฺษ^๛%ฝ|ฉj‰ฬ=‘$พ฿)œmW>pฦ ชZฆNJE—SmrE&วแํFถ!‹บ`…?สV|ะจไ ฆ)_ใ`ฝAznไฎH–e‚ ค์ฦ๓,ํ!ไ–3ปIk0hJoผ็˜๎ลื7‰rŒNOG\†ฮใ]cำำฃ๊Š4ช๋ืฝ@ฝ=ข~Iศญษ'B!ิOH‡ฯ#์ฝŽ๎ๅ><€ูf• …ถหzYwศvฒลหWซk๏v2๕พš„ำ!ีิQ หส(bํคุpุ-†กฑฉa๓‡z็T”s™J1sาWkง@`ูำฮหฒ‚p6สค8งe3~่แ›์6ึเ›bii้IศJบ๎-อ:Ÿธฆ๏๚มšm6ฆิy/HฃลfkไZ„ตiTืฏ{z{D’[“O„BจŸะ4ญ‚๊อœุ S>l{W ‚aY’จ+Š๒u=ดJ7๖qตw๛e‘4:l\ฝ\h(”ีๅฒejE‘2ปนrฆะœำฅo‹ะokAŠ''฿ฐ๕$Yกlพ!"ท๑a’›ษ;>ไ _Eำ2T๖^.๏5_bผ๗›ฏ๑ญโ๑ป/SะำฒšX๛rฟ๕žดiTืฏ{z{D’[“O„Bจgฮ๎ฟ๐hi*ป/ื;~`คkjษu๖๛ูฃ‹™ซUซํ?๑๊้ƒฺƒนงP$พ˜8(wุค~กšบlbื1>๙ุGrฃV8ุ>ช@n?nG.0ค$”sฑํ”๐a๐q_5หKสฦทธฑ๐รyVฉ็“›gรฬFญ\ฉาKQ„ัh<๛eiiiyyYฅeนจ“D"ื้c ฮ‘€CLว“EีฐZ4ช๋ื/Gtkrmํ์0Pำ—–พฃz&#ิ3SSSัh๔ฆ[๊ฒ[B:'…•hJ M™i:"^บ้v5g“บ-tHอ^Šjฅร’ทึ…1‚พ๕„ษ๎r9นฮ๏ ”ูแrูM-gงhาจฎ_ฟัญIศตตณร@!„ะื‡\ฮfhฃ'๓๓๓๓๓๓ฆœ|2~ยบŠณฮ อ9ฯz)ช=–K๖ }ื€b 4! ‚ิ้ล‚bYZ๙F‹!–F ญ๊๚๕ห–„\[;; ิtหฟ.Bw^@่Nย็:'๒น^Šjฅร’ทึ…1‚ฮ๏qฅ฿ƒR$กํž4iUืฏ_Ž่ถ$ไฺฺูa „Bก๎๚ุ99ืKQํฑtXฒ_่›ฟ„Bจญุํ7„B่:เ๘!„B!คืuXG ๖ ด K๘ยaฟƒm๑ฒVuด้ื#บ5 นถvv!„B๕Tปi๖L<˜_|๚tแ๑์ธว,j ฯJ8จจZbm๕ vกeต[ _"ฌ6+ }ีท ก Gms}ซBฺรำาซฝ7๎ี_ฒ‰โl6้H#|›๑ƒก ้tE”*น"๏1’ุI’@’dฉ!ส็*ธวรฦใwo=B–‚rซ{o*rCZฟฌU]?ญ@๚i‘ฤื.žญ—ฉ~[rmํ”Eพv๑Y๔—„Buั…›๒S฿xdุf$ลZ!ตฟ—<ฉห๊๕๔kTNาปษ\ี>ๅไฺoTG!7วะ4)๒Q=xต‘ๆBOยญคi4ไ`ลBbc๓ธช8ฦžบ๊qู้gRin$0PุZO”๛๚๓ดe–H[ `สฤธ๑๖ู+—6ป Jดm ^nื[ป}ฌNg๕xฅ(Hูd&8้ไ๖*ีK^B› %ๅฤฺ๛TsไFs&Vภnl‹๙ล……งณฮปX๎ร ษ๙'สfฒึ๖Tไงญ†-ด{jq๑ฟๅ_[ฃบ~Z๔๋ฐI’~igSQ†พบ ‰B่๖q ๙ฦ๙)Oศฏฝ}ฑ๒*š(ฒ6‹ๆ\คJ.ฏI:6ช2xFผฤ๊ส๓gkตz๒๕FบYหไvS‡oWVeฃ~Gsd1๐ฑผyฤG์oงมi7uก๙7ฉU–Lร#ƒๅฝา'=R“vqqaaัฬูœ|๓yูfgM6kฝP์ซกm`A”ไ˜ห$หถZชฟไฅโท}•4X‡ฎมAื8:ฎ3q'ฏทx‚๓Fฦๅ๕ฝฒ\`’ซํฏe„ถ๛jล|^โ[~อ—๓yช๒Fฃบ~Z๔๋ฐI’~igำIง.๚ฏ๏หๅŽC"„๚: ˜Ll์f2Ÿl%šehจW๓Gฑ ต์b—Nวmฑ˜ ีœฬSK%Ž+"€X(ห6CณหXสdษ.U ๙†4$L_=๑X7ฦ5๊Uึณ"xฯถU๖ื_@P&Wd2์ษฟ>เ yส๏คค|B๖ุnชลW@’คข(kถZ)Jฉห$ูrแจ๎’—ัf@ูBณv>}tผน—ฏ4dส>ไจฅ6‹5€?ฬ๚บฌ{ๅT๏ำ๖Hุ›y{ToืIไ3;ัL๋—ฅ^ดฟฃFuด้ืa“๚%!าฮฆ?J$พ ฺฝ{6ฆๅR~„บ๎วKK7„PืE๑ฯ2™฿=ท?ŽํGรณรน^ฬ%ww3ํg]\พTตDๆH_Œ๏ฮถ+ธ›ใuค54ฅ7๓็zฒ(๐ง“ฃ๙ฃlลวq €Jพ`š๒5ึค็&š{Uฒ,!e7žgh!ทœูญปคa(2๎ๅ Yึใณvไrr3žS]ำz@:|ao%š:? IP>œ’ ($๙แœTj‡[ ์D ๔&Qi=ะ่ ‰Gป'ช฿ SŽัI/•‰ลา๊ †4ช๋งHฟ›tGrหฺ)ศ๒๏๎๎~๚ฆBuJชววฺd๓MDล7วZ3/z‹u‡l'๋ฯ฿๗๓‹{ฦd1ษ ลIDATทฑร์พำ฿ญK–ีh}8ฬE“อuร็T”s™ŠกqR‡ม›hํ•‰‚,KHภฒฌ œu‹(ฮ9h–ŠูBsmN›’Ÿโ3วฮ™q' ภY>ฝq >x€v๋hšVแยJVฑZm 8 $7ไเชีsซM๘ิvผ๎šฑต™H-6›™m5&Xณอ6`hน๊๚iาฏร&‘„๔K;Bกซ3y#!ทีฤŠุ์"๘ี’ –% ‚ พNWZซ์ฝ\>ต/ส้๗หซ๛ต†BY].K$cqrๅ๒ูˆ”bโํ๛ฃZ; P<9แรV†ขŒN฿‘ห}Xm๒ŽOFฦฆCƒคVษฯ๐™ญ่nQhไwลNZNต%Hืิ’๋์๗์ฦ๒fฎtฐy2F+j~o็๘“AL#ถ= ืทZŒXช‰ต/๗Ai๕&ฟ๛2ี๚eญ๊๚iาฏร&‘„๔K;Bกซk”+D`tjฤฤjn7–nมาฯYœr7ฟปทไ)}หซnTฉ\Oิฬ= €"๑ลไๆฦมืf้Ÿ,ษนธ=yธภ’PฮลถSภงหˆ‰>›ๅ%eใ[X๘แ<ซิ๓ษอƒณQฃVฎ‹ŒT9[Nะฒค นz๘=3”โฉถ๋ฃัx๖หาาา๒๒rgวฃมเ 8ฤt<ฉ~“Wส:rQ'‰DNr Fuด้ืa“๎HB๚ฅ!„ะB:'…•hJ M™i:"^บ้v5g˜บ-tHอL/6ZฦXƒ}”ูแrูM-ง๋˜์.—“kyUDฃบ~Z๔๋ฐIw$!าN„B่‘หู ํ๔d~~~~~ั”“Oฆ> ]ษY7†ๆœg™^l์ื} X–VDพัbˆE1šARฟhขU]?@๚uุคป’~i'B!„ะๅœucไs™^lผต.Œฎ๛{\E๘v้‘m_ึชฎŸF :lา]IHฟด!„B่r>vcฮ๕gzฑฑ_\๗%„๚š[R{L„wOฟ{ฟดณC7{˜}ไ~i'บn๖\าว!„B!ฝp€B!„า ๏cƒB}„q๘]าqฒ(jีม2๚xฦหAิซซWz‚’ษpšูัwฟHฃ+โ•โู+=ๆŒ™a็ีfF๋เ)ห๐Xฤg7’be?๚ๆฐๅร’4YGฆฬ™่ๅvp™„่ฆุฏฅIฌoๆ—j๛ไโ ฉz‚uแฌSืY–>ำณv"tYด50๖XYฅžOฦbG•OWK0ž™‡ๆฑยูeL‡ƒฦฬ๛ฏถOBOfผ๔‡'gI้wฯcEา88 ZXBฌๅ“ฑํฃŠ|ฉuแจB]j 85แ7+vโอปƒ๊ฅ์ี•w_~น ก'‘ฮ๗ฅลูlาัUk๓นฝ˜ ๋9‘ษฌญ๑@e‰6r†[q™^๗ฑ฿ฐ‹ํT=มzvึu9Kื฿P+ค34แจmฎoUH{xzย_zตwฝ†!—!ป๗q๐Œ{ิG ็“UKฌ]?ˆขh0xj—–Bi0 †J฿D๓ํ—uŽM‡lgoูŒ#2nผŽๅี๚}Oศฏฝy‘ูAฏBิe \ก1K๙หwส96;๎/ฝ-ซ‡R-I…"ๆ๒๛ตhYๆ|๗ฆGOgช๛ซห๛=™ฎsQ)พฒ‡ะ“๐งMn7ต๑v%fฬฮ๘ฉอœp๘z๙๖L?ฑน™;;ขกะ˜น๘n5Z%mก๛โสN๑bˆnPOHหฬ“V}ปฒgŸ|ไ2fภbเ_ํๆ็๏๙2ฏถำำ“vSขฌ๛ุk b+mฎFซไ`d6โ;yนWพl“.‡ดŽ„m๙ํตผญF]งzzซF7xFผฤห•œl๒O6b้ๆฌ}ฉปDt„z‰6ฐ ส€า-$vตฐgใฮๅ"3OXำ๐ศ`y๏U‰™<ท “vqXQ$ฑV<ŒวŽ+2M3 ษ O}6Vฉๅฑtญอsต>ไ๚ไยl:…B‹ฅำCE!๔“ษ411‘ษd>I๓ํท‘฿Y}๖์ูณทGB=๙๚ูณgฯืw‹-๏N4หะ V๓Gฑxฆ`โฬB>S–@r™c63-›ฉVาศqยIบ(ศฒX>ฺูJUoลฃRkฉฤqETไJก, lซb&ฮ,œdห YๆOฒ’ใZ–l"นแ{ใฎ– บค–™—‹™tMฑ\ฌศงŸฦฅ|A–dฉZศ7$Y"ศ6Yุ‹๑ีทฅ†,๑๙Raค“ก ย๒ฑยต฿ธ^ๅ๔V%ึฯnชOะ‹้ร๖NRง?:B]B’คข(kถZM”ขศ$yฎ๓n’ำ™ณัใ๕*ปู๓฿,U๖ื_ฎฎญญญฟŽฦ‹ฦัฐวV‹r๐ๆๅ‹ตํ’9j๓†ง๚ษ๕ษ๕‡D" ๏ปว0z฿D!tJลL&ณปป๛๙KšoฟŠ,I’ข(ฒ,Iํ๚lqlฯ8ž6ศ๕b.นป›ฉ)@„ม357(II๕rหฎฉjI‚ ”ณ๕wี“ฯฮถeŠŒ{9H–5ภ๘ฌ]นœŒ็ฮ๚^Wพูน๒๑‡6]ํ๓W…$ฺ~ Cใ๗\|์Jฯ๐Jํิฬ<๔๎5€แr๛์ุ)‹w<์ๆHYฺ…ซ7Iื฿‡ฦ๏ีฤห๎ดขซž-Š–ช–ศใIโ‹๑้ uั๑จ๛dY&Bสn<ฯะB–?žsCCb๚อ‡• ค54ฅ7๓็>HdQเOวQถโใ8€ŠJ!uT Gฺูœล ฉว:็ฯdีOฎOฦฒ,๏๎๎ช~ถ!„๊๎พJ•ใุใA›lพฑ‰ˆป๘ๆXPฅ~๔nํ@{}‚jIEQเCท› ฤ†ค( @ปพ;Ÿ98vฮŒ;Yฮย๐้ƒƒ‡ๅๅๅK฿e}า๘sc 5ิPhฬษ*าไcAJฉไ%๙YB๔gพ3ฌkิ+%^ฝ:‘ฦ{๑นKY—j’ฮร”3[oมษ 3ต•๋โBOtตำ[ญู๋NึŸฟืn^๋ิ]*z๏ฯd๔ต$ ฐ, หฒ‚๐aข+as ๒้ตณyฏ&ป5fฟ๐n]ฒ์ฏF๋รa๖(šl.น>3‹โงs_?yWิs&฿ŠK „๊“7r[M ฉˆ‚ B๓๋ึzญสZํF€ไผc๗†--฿UKึkUƒch€! สไž˜›๚๐ํSƒ็้๛หฐ&#ำrมgถขปอใ4๒;๏b'ื:ํฃ^ซ์ƒš$YปำชTซชอ&)—HลฺQ๔ี‹/Vžฟบ๔ย€ฯข?๓!‚ข(B!™ทอ 3#u:ฉ7MRส๛ฑœ%ฒS]= Mชงท’ –% ‚hมฉ]๊ฎกฎ)žœp๎a+CQFงoˆศๅNง+‘v—ฃšฮ~|7ญ์ฝ\>ต/ส้๗หซ๛ต†BY].K$cqrๅr@.*VทืL“คมๆ4K•ม[ภ๛/!„P?Q”ถ_Ÿ4ส"0:5bbˆF5ทK7@Lวใ–ฑ้๙ MH|>น]•ภšŸ๕6'{ฯ-OoฮฃZRLวcๆศุKˆต~sŸRvื9~๏‘—ŠปฏฃฉV+ภๅ๊แ๛๗ฬTPŠoค๊—ํs]เัาศ‡ป*้&ฆใ;–ฑ‰Gร ๐ฅใอญถ‹งๅj๒&{ุq๔>u•Qฮg Qอง~บO'Ž‘ว‹กF้0q›‚๕7‡|๗›๔\JฤNŽฺึbIตช'˜๊FQUOoต่๕๔Aํมำ(_LnnจีSW๒ฉดS5:B=%eใ[X๘แ<ซิ๓ษอƒำฎ>iwู+้ญSPฮํวํแศร†”„r.ถ€?Ž›"“‚ดย—ำ[ฑห>4…0W9„B่ฮ"ะฆกtN,ธ +ั”@š3ำtผว7 C่๚PC๗;3/6ฒ7r0ผ€B]€ƒ‡พ'—ณ™แัGOอฟฅ"–“—œขะํEบ๒G›7u๛`ผ€B!„า ืO#„B!„๔ย๑B!„BHฏ์คFผIENDฎB`‚aristocratos-btop-d43a485/Img/tty.png000066400000000000000000004311121517514752700176110ustar00rootroot00000000000000‰PNG  IHDR’†t sBITแOเtEXtSoftwaremate-screenshotศ–๐J IDATxœ์w\๗๐wD aŠH‹ ถŽโยƒR‹ฃขXิบซTฉฃขข (Z+ิฃ”Z•Z*ฎjฤEŠ ˆ(†!„$ฟ? ~Q#& ๘{=๙#๗ฮ็sŸ๗i<๏ปฯƒรแ€˜ชNZ ิ (ิ จ&ซt9๚๑;tะณiช5ภ;f4h้ม๓ื๏=ฬHฝ~6hqฝใบ}ใ๓r๓ใW7พKื่่ดุ้ๅค๔ด›‚=†ตc1:Œ๑>๒ฯญŒ์๗n_<ฒม้C๖;€C๎NUฎR‰` ิ๕Ks‰กษ9=jYฌ š {วžฅ#ณC|ทž*0w\ธlƒŒ†, 8ตถ—ฐ๖M]5ฝc๎แŸvF?๋ใŽ)ฦDœัkๆฺ๑ฒ๛o?Shj7๛‡o6วฆจžช]ฅโม&ม`๗เpบ6]9า๕S}ˆ†๔—'ป/†๕๛-๘๙ฬ•ิ™iืNL๋ฦ!ขW'ๆ็๑7ฺ๗๔iWอฑb?๖'"‰๛๒๓sฯ4l‚ฌ^aร๋P`n8Gง]’™ั—ใ|x\Gˆ๔๛/ ŒHผ—•~7๎่ฆ๑–jหsdฟeGofฟuปžœๆห ™ด๏hX๑(๕๐O>ฟฒ`‘žต1ตฑปโ—ๅ;๎Š_niๆŸwฒาฏ์๚ย nู๊‹q]7ฟ฿๔๓^!ว9Ž0๙ฯ}?oู๖หฉ๐sIOHฦ/4๗fจ†ช]ฅยAห๙™gฯ<|็Fเ—gKN>6๛#"2่~ ๚fzVฺอหวw,าพ๑#z–ึVMFSmhSิbมธข_k^<๛ 1{ฟ็ฆB~ุr"ฟใฤvปYีข็๘๕ศ'งบ#`๘ชร›๗ฬ ƒcห–ˆุZktู…Rๆ€6œ6#ึํ_นv์š๓~ุๅ๋ป็Y›งำฒ้์KgS%ฦฟ›?RญY๓hƒงhฟ1žิL†์J$*)๛็๑พ—\Jkฆอ@;CN›๗ญ฿Mššš’,OะรŸpwผ<ขLฉ๘๒./๏`ีWฏฤ์Wบ็ซ [n7๓Vจˆช]ฅโA"jcgแ‰ศฤัsN๛ขr๎€แถm=~๙~๏ๆ–๎‚oดํaฅ-mึ }gืฅ~ิณ—.๑ํรธR!แ#–F'eg~\พ-พMภy์Mฺ๓จ่]ฅ ‡ฌ๚จ@ิNทmNชŽ๎"๖G={้Pูษว‰ีjหs๘ˆพ}ดv฿#"*?ป๙-—5'ฮ์3ย@ŸK›1O€ๆม1ณŸฝิ}ฮธฦ์าซ?V๙๚ฆา๘?wGq?FŸจ?ฌกฎFR‰TCื€งMตb" ๕๚|qธฯฌ‡>žถฦ}๏ŽวŸM~ˆห[ ีRืชหiำ SU๚ร3‰ฦฏ๎Tํๅํ*ๅ๎?ๅลD5 วoถ[06'tGโฌ๙ใีิุl.ท-QmฎfU฿ํฝ6y5ญี:Cฝ=‘n[= *|ฦ฿#|M๒ {ก~ตS‰โ%jqฃ็.ิ5ิ‰ฤb1ษ๎^[๗ฟอวDD2™Œˆ$ 1o8“ขTJ)Ou5"ไ ”ฑตค–ˆดฺิCjkjคDตตตD๔ฆ4› O€ๆ๑ฟฝ"ๆปฟNฌ๘Xฝ่๚_?x8V่q~๑๙พ>฿`นF,&&K๘๗ซSd4๓QMMM'ฯ^‰xHU}็„ธฬšุ%ุ๏^]ปJh-ทซdi|ัถญNƒRฤ|๙๕ƒช]ฅโAนฤ‘~+Bฏฟlฯเeฒ๊Gฮ{K(ฏ%[s†Žv]๒š:s5)ERผ~๘ฯG/Ÿxรั๖ฟ<^จ†จญš‘ฉญำ':o]พีเs6›Mu†L&ซ_d4žฎฒศณFLT๖๗Š‘?\ฏžR'y-฿ežอใ…ฝโงSๆ|ฌUrไkป๏ขซ่k0x้ๆ…ฝ…ั[=~ฝ-$ข|b˜ด3&*ค๖&ํ‰็ๅi8ฆ๏s{รง_๒Lƒˆ๑โ0ุU@ห๗ยฎR๘คหร' u“ปS•ทซT"h$wคฺ๛กหxwํ;vู>Ÿญ๎๓เGๅํศ๋’g๋Fš้ๅ—dฯฌ|๙Wขvไ฿$ื/ฉิmcIj]ˆˆฅแฌซ๛จฆ๊ทฌท4q๔ย5้–4jัB;Nศิnทสˆˆtบ.๚ฺสdข-Q๎d>•””™ึทfFทั5E>สศบuณœฦ๗1ิๆ™ฐืฬใ4O,w๕“๛ฉj๓hrzzzD๚ŸN_`YจL:๙{gไ1–L‹.jDบŸLZ๐mj๘ห9DLป้K3ศ:๛_o_%ขด๐ำ}3๋Jfผ๎็SMkฎD”ˆ(๎†ฤัv–๏Jึuฝฯฺฦอ‡*H€ๆ"wงzEฮฎ’ŠN—7ฮ„_N;?9๒๗•Œ2ช•Uฟ:iํjš๚aขžžS[gžงผขๆท'็ืฯใ5ํซีkXc~๖๐ป$ฉป~‰กื{ฦj]aึ™ +w&ขใ~ฟใซCฬ~r฿ม:บ)RR˜่ผ๗Œlฏฏฝ‚œ4„ษgwžบ.$+y- Tš'@“c0ˆศd„ฺ๕ย_oง7aองบ{[๐ฬ[; ฯ{๛/็Iำฎ$<๑‰๐ŸkYuญ%ษ?อ๚Ž๛ฃป๋๗}ฤนืf{Q@D!K:n‹ฏWุIŸdœฒั๗|ณฏ 2๒wช‰๒v•r๗Ÿr‚]ๅ$I ๛{๘์IK&|ภ“=นท๏R฿หo;ฅA) ‡๓|aิNฉโg1ห9่W'ž]จฑาวž ๖๘5Q๗8ภPํฮ ปJhŸ์ฌ๓‘๛GMๅฟUฎ;›lojึ ้เ(๊?ฮ€0#ิญำธฯไ9sง4k ฌ/@ะ:]ฝอวฯืนc๒็{๒๓sพn๚ุส๏i๖Mฤ -o๙ุพฆป ๎D}์=73๓๓มkFšโธRF‡1Gน•‘เํ‹G68}๘†โฯp๒มิVศ๘๑zฯŸ๒ #๕ฺ™@ทพ<"น-;?๗"ขa[3ŸฟPพด…fธ๒3๏^cำร3๋rบOX8ส\ 4า]z๋ภฒเ$""ชNฯ"โห๋๚uพ]วมwฟ็Xfาั}'*{นฬ\ธ‡™9ภ๕pIoskวฝ&`ฎ่๊>KZŽ‹ฆฬแ่S฿_~msgkGjหdฤhdmG๘๐ฯบ็/'ี†อา3จ<น๗๗MŸ๚kก~h๑ฬพ‰ธบฆ๗1ฬ>Q]NDฤ0w _ฤลบ฿ศ:dO\ฝzEฤ/*โ‹คD๔D^๗ข๛r‚๊รไth7ˆKน?ฏq฿|“ฬ*{_]3hX?๖แฐฺw๕Gะ:้“—Ÿqnๅnf.Sบ3ส)๑ฺ^ปq……D™:ฆ‘uv:LŸr๖Zถๅ&ใ๔cแฌล๊zuŸฐuŒอฬสษPซพะ›vx๐จ ถ ๕@‹Wu/2ไ ๋ๅ#ง~h๛น๋\zผ๛ฯธZ"๊2๙วEvm|œถแ‡˜จ ๓rxDฤา๎6ลc๑eฮL:P"งปu>‘ืIƒ1d์;ฆ฿๊๗Eqธฯฌ‡>žถฦ}๏ŽวŸM~({ต ปข-3M๏ด8Fึ~ƒˆี†gคห)Tฟฺ–Qvกใึ๘m#ˆจOืฎDD…a๋W•Cf์]:ˆˆจ&3:$“Hณืช“› หcVอ™ึ›ƒ๚ ๙ŒurTผqุฉ๐77โ uฆIนgO฿‘๕bยxŸงf๎๘!23๎tค‰ำ^ณ†L5๐ข9ๅฎS˜%ง{ร๚ดŒอ 5ซŸๆVH”฿ฬ๗ฯKqฯ^‰xHU}็„ธฬšุ%ุ๏i่™๊ี”ื๖ุ™ฅF฿}ปn*ƒ๖œใท;-้๔Uhี+k—ีMUวํš็[๛ƒ็hฆDZฉสŠˆH!ัษZ3Lฦm๛m‘Uำ็|ุ ฺฟฃ7~๋P?4+…ช…มฝ Pง๒ธ๘ไบๅVvmฟ๒ฅ6ง=I๖ท}‡8๏/ &ƒA$‹ๅw—”฿ฝŒ/ โ๑xDูิม๕@Z๋p7‹นง”ฬ๗Oรฟ8 งภ๔]cnoเ๔Kƒษ`1๊ฯh1ๆ ซImช฿g๖ำˆžž๕๙*S—ˆˆlๆญ*8้ฑ—หี๒(++#โ๑x’k้_m'ส.(x]2œK๖๔y›kพ“W_zuๆลซGŠ|๋P?ดxZ]G;๕ิ๏bม&โ๖๘l๊ิ^ใว>’ัG}zs‰โ๏$I^฿ป๚nสcฮfฏsg\ำwญE‚3ื๊oฒ$ท๛KA๙“โหง;ธ๘๘ /T๕q้Aขุ˜DLž~‰(1๎†ฤัv–๏Jึuฝฯฺฦอ‡DDdิฝง ‹ˆeqWuJซกš[s๋:I>ฏ%z๖๘ฺลคBน+ฝsน์๋qSึ(Œื์๓6ฒŒˆศ,2•ืRc ฯ%=4๒ย/๐{Or้Mฒ์˜ร๑นoปQจZ<ฝกK๊๏ฟdfถค่๖A๗UปR%๒๋ญ,ฺ1ˆL=ถ:INฬj‚๚มแpž/Œฺ)ZŒ'ผ+cฟ~ฉ๕^ิช“Kญeๅๆ)7๘R€j…๚…๚…๙ำ-Qซธ†uZu๒ iูสyเwใ.”‡^U‰‰สvyK๙๏็@Qจ@QจTฦ ๏‚ฝงใ๏ffปq>xอHS&ัศmู๙น๙๙น๙๙ำo_8ดvL‡ƒxุ š๙=(@ณทม”ฟบฌพc™G dรฬ๑ว“gฮG/ทใช:ปท`นะ2-zหฐบ%†นc๛CัVw๎ZsาlZท๚ฃ|๕N“Eลž }ตฝ ฃ>f>jeะ‘ศธ‹็ฯ๎฿8ีZKษa1@Et|๗{Že&wขฒ—หฬ…{˜™\Ÿ= ฺs‘ม่Y3์˜ึ๛kย๋ไu้bฌั0R]t™ทเbQใ›m†ํ0m{ธํด˜ีE฿yง‰•cN…D๓(w‡ไ)๚nฌ%ŽŽฎด\ ์ƒTKŸทr&3๙3๛L๕ทฌV๛kf๚์G ›ลๆฟน๋œžห/#๖ i ตย]GŸา™ดyŠu๔ถข๖ฮ>ห>8ฟฤe๑I‡ฯ}‚|พพ๕ๅ๎4%F "ํq)๗็5๎›o’Ye๏ซk ๋ว>FDฤฟql๏บฮs85วฦฦ‚โ^ง:ทฝ๙mF*DYิŠƒoY?่qฺT]๙K$”%•ฅXvดฆ;2bฑู,“คRb]พafอynฝ]กาฌ˜,ย u๎ะ™ˆˆ4zkuฟ^ๆ’.‘๔ห์)#Q[ฏ:๛~Nี3๕นพ\""๕๎ฝlnŸœZ*&ส8q4ฦmVocJ+Rb่wฐ9 KTZZJD”{๘‡ฯพ๘1แ…โ1‘šบšJฒ{Oฤ‘ฆฅ‹Aฤjฏั’ญฅGy‘!I|}ื๎xdีŒ][ว๎pkUล1- VŽ๚<{ž4—วซqf๏๎”pห*ๆ˜ฉำGuื*U๒๙3 MNGs>_@DฤๅrE•โบnฒ_ว๙!J„๓-‚ŒŸ}‡OD๔ซญI{๓F|jD”๚ฟkT@y’ŠKบ_ํ่บฆVR~ฃ์Qฉ3ˆ ขืOๆXŒ๕0ฃp๗ฒฅq%RUงฉ๖8}Qเƒ๐2r7ฤ`f฿6โ้Yรพg๖๙๎รธe%Tผgฬฺ฿"f‹ณ/n๗H!"bฃมช$"กDูั›bเ-i›jV?อ!""๓ู˜MD$ฬ๚sแGิS&{ฑต์ๅผึำ“น;ฮSWงšjฆmฐแ‡2"bตฒxำ|ใปย๚ธ†ญ( ๗]ฑ'ฑBี™*†ำฯศข์;ทš†‡๒2IโKO‘HH,ศ ocEe%D5กหง‡6์^eS=“)“*W=แ๚%)ใ ˆx<Qื๑ฑ—7 ฏ๛mธเิฺำฟš๘™]๏ก฿G=ญฟศ‰งงว jc` I๔ไษ•ฆŠฐMxๆ๚ฒšjปญAํณ2า๎้?้‰uwญ&๕H๔tYโ<นซ๙YาNฤฬ 4ฅ[zzW/[ๆ๘ภnแ‹4๘O#ิสj_ำ]P^ฎัVปš8ฦ@๏ศ ฉฦJ฿j 7ษ ๑ๅำ\|„ช๚ธ๔ QlLb- %ขgู‰็ขSื๒•7ฦ{๏ญนชc?”!หJธZ"2ฉD"yแPR"•ษจๅoงโ˜งต๏ัตๆเก๚@FUQฉT.:็’P(%s&CR#ฎ‹‰ษdผyU-Cฒ฿ฮ~uoูฎ‡:w฿—๊q‘ศด๊๎jฝiึU‡2๛Lืเ๚“ิืt%L[2ีๆ๚แฬZS‡‰C*๎)Vj|ิ*"[=งฃฤำลaซ๑ฅ@๏Uะ0y-ซข7ฬ๛ฉทหะฏ&ี%…ฎ๔“๒šใ๊Šฬ˜ำ™ฏ†[u๐ํิ\๕*0d๖+Sœ๛์ๆ’ิJ" ‰ˆ่q๔‰J#|w‹›zเๆ•๗tี&—่ห o๑ฟ๗ไ๓_2ิk›™็บะน†,A๖•_ฝผ๎ป๔ ‡๓|aิNiิb\ั๐ฎŒur ;ฎ๊,@QZถถอ3PUbb๓ ิ8น฿ฯ—jT  (ิ (ิ (ฬŸhน๚7˜žิธ„๊๊wš ด๚๚zฏต-Zำณ•_’Xฅ๊เ8ŠBŠB 2}์=73๓๓มkFš2‰ˆž๓v{๎tศ†ษVmTc+ืN^z7Ÿ/็1ฤ0s๑ไ™๓Qมหํธชฮ๏-X.ดLKทR๗ฤ&๑้าาl๊^‰ดฺ๊จwš์(*๖\๘๏ซํM๊‘งn>jeะ‘ศธ‹็ฯ๎฿8ีZKษaQ?จˆŽƒ๏~O'K…}?ฯโฺ/ณลูˆ3dลป?M=~แAฑ๋ณฌpผ๖6Jส|฿ฏ๎5:๏^™0?Lํ'šGน;lฬ๘lB_6GGW]ี‰*KŸทr&3ฟ A$ฃศั*ลส*ลส*ลvmฌ๖ i ตยgvZqอf๑k""j๏์ณ์ƒุu.๖c&,>ญ=ฯ็k+ๅฦ๗@Eบ โRnศ๗อ~žKƒ’Hsะฐ~l๊5|๘ร๛o”TU>Ž ‰ฺIีyถjiUกธผP\^(ๆ8๊wธ\œ๘ˆd2bฑู,“คRb๕ุ0หFCี™*…ู฿ศ"ฌ0$ง๑fmyผ๊์๛9Uฯ2ไry\""๕๎ฝlnŸ I-Š'Žฦ่๕๎mฌิะธ€Š๐x\ขวฅฅDDน‡ฟqˆืญฬ'];#YIฑ่ใูNล‹Š mŒˆ๎ซ:ี๗€z[ป้Œ๋ฎ5Dy‘!IพวF฿U5cืึ๎WถธLiM๗จbZฌ#๔Œะ jat†D*+อช<่“GŠ”จ’ฯ็˜Y˜hฆ๊˜›๐๙"".—+ชฌืu‘%๘:^ •๕@ ใg฿แkhิึึชu้๓qqŽX]ฃu0Riุ๓ฌ—ํJ'"ข‚่๕Sฃ9cฝ7ฬ(ฝli\‰Tลู)‡=ฮC_๘ ผŒ\Ÿว๎O๑”ID,ฆล$ำฝหŸไRmL๐ž1k‹˜-ฮพธ#…ˆˆAŒซ’ˆ„eG๛ €ทฆelnจY4งบฆ†ลbU[1ไ‘๖—lฑจFีฉฝ‡i?9Wฤฏ_dตฒxำ|ใปย๚ธ†ญ( ๗]ฑ'ฑBฅ*Œำฯศข์;ทšๅk$y๕•@^0?uฆf'ข\ขšŒะๅำCv—‘ฌมƒษ”I•ซž0@Eส๘"GDิม๕@|์ๅ ร‚’b–a=q Š‹‹T™ใ๛Bณc_IVB})ฆ3ำา๙๋๎ZM๊‘่้ผณฤyrV๓ณบฅถ‰™AhJท๔๔ฎ^ถฬ๑ยiดw๊4Wณพ…์ๅณ สห5ฺjซี-0zGMUn๊INˆ/'3ฟๅKึ๛อ๎Aข+1‰ตฒ—/w?ใ}ญถf๖.cุ—.eจ:ฯ๗€‰ฆ™ก0/ญ~ฉN8๘oiญฺ๋‰ีฝMปีEโ—Eยบ)รฃOไ๎ˆ˜Pแป[ฺญ๐\ฑฯเ๖รบiH ’สฝV•ผฎi^จื63ฯuกs Y‚์+ฟzH‘ฝฎฉ\ ‡๓|aิNiิbœ‘h)๚7๘็ูธ„๊๊wš 4•ฑNŽaงย฿๚๕๕๕^ j[ดฆ{ ฝ$;ฑJ…ฃkฺู6ฯ@U‰‰อ3Pใไ~?_ชP-€ขP?€ขP?€ข0 ๅaง๐‡hฬขV>ีZœEก~Eก~Pƒพ ๖žŽฟ›™y๏ฦ๙เ5#M=4c่t[|!ฦg Jณ{O๐ฺฯ‰ถZ“lใ฿iฺขถšD 3วOž9ผŽซ๊์‚ๅBหดt๋-รˆˆจทI|zทด4›บWโ†๚'˜ซwš์(*๖\๘๏ซํM๊‘งn>jeะ‘ศธ‹็ฯ๎฿8ีZKษaQ?จˆŽƒ๏~O'K…}?ฯโฺ/ณลูจร๋๗9พฤคธHี๙ฝ8ฝ—่๐ส๘ก{สV—R๖C]2ตŸhๅ๎ฐ1ใณ }ูDD]uU็ฉ,}ส™ฬ†O‰ห(rดJฑฒJฑฒJฑ][๗ิ ๖ i ตยgvZqอf๑k""j๏์ณ์ƒุu.๖c&,>ญ=ฯ็k+ๅF "ํq)7d๛f?ฯฅAIค9hX?6๑3 1ฯ=เVนช๓{?Hž•ษฤ•าZ‰+คตตฯjH&#›อb1I*%–๑Pณl4TจR˜,ย Croึ–วซฮพŸS๕,ใA.—ว%"R๏หๆ๖ษิRกHqโhŒ^๏ฦJ ๛/จว%z\ZJD”{๘‡xส|ขสด่3Dd4@ลูฝ/ฤ ฿ๆฺีูำมx๖,zvNช(2$ษ฿๗ุˆขใปชf์ฺฺสทƒ)ญ้ฦUL ƒ•c„~ฃŸ๑D-ŒŽ฿0HeฅY•}๒H‘U๒๙3 อTs>_@DฤๅrE•โบ.ฒ_วซbกRƒฃ~hd์;|U'๑^bw๓21Šฮ <+fwัw๚ม(o|aNA๔๚ฉั‹ฑf๎^ถ4ฎDช๊,•ย็ก/ |^Fฎฯcw‹'Žxส$"ำb’i€ๅ‰Orฉ6&xฯ˜ตฟEฬg_๎‘BDฤ FƒUIDB‰ฒฃฟภ[ำ267ิฌ~šSXก์๑4FKปงฝ่ฦwUO$DนO’ฟฑคOaNซล›ๆ๋฿ึว-0lEQธ๏Š=‰ชฮU1œ~F๎e฿นีผp(_#)ศซๆไ๓Sgjv"ส%ชษ]>=ดawษ,1˜L™Tน๊ ๓TคŒ/ โ๑xDD\ฤว^0œ๑ฆN 5‹ž!หd&[ƒt†{๚Ozโ?]ซI==w–8O๎฿j~Vทดำ613M้–žีห–9>ฐ[๘"๖N‚ๆjึทฝ|–ก!AyนF[mตบฦ@๏ศ ฉ˜ะ*$'ฤ—Owp๑๑^จ๊ใาƒDฑ1‰ตชN๊}รฏ.*5ฒ๙L=๓l ซทkื๊{Td๋œKBก”ฬ™ IธF,&&ณีTnษ~๗;๛ี+๏T IDATฝeป๊}_ชวEาŒูo"wภ฿ขkฆณn็$~ฺkบ‹’nฆ-๏jspfญฉรฤ!wŽ+5>๊„ญžำQโ้โฐภU๘R ๗ช? ˆจฟ๗นใฺ‘฿ตฑTyrษฐ๕WT›ik๖,ๆ๛าqซ?๚~SZ&zฐ5Z ๋ฆ ?Ž>‘ป# bBi„๏nฑjำ|Kยsล>ƒo ๋jค!-H*๗ZUV๐บฆyก^ฬ<ื…ฮ5d ฒฏ๊u E๖บฆr18ฮ๓…Q;ฅQ‹qE@Kฑฦ^ั‡ฺlŒฦ”;€ึaฌ“cุฉ๐wท~s[eŸึาe'Vฉpt-[ๆจ*1ฑyjœ๏็K5ชP๊P๊PๆOฟ•มqˆˆˆbฒช฿i&๐‡ง=๏ี /พuะไp…๚…๚@e ๚.ุ{:nfๆฝ็ƒืŒ4eqบNุr๊โ•K็ฯ์๐eguU'ูส่ดฑ?jฝf‹๖"<ญaVดZ๖—Y?&1ฬ Žiตฦฌszม้~• aิžIฆ๖อฃ6f|6ก/›ˆˆฃฃ๊ส4}ส™ฬ‚ฦƒ์Aำj…ฯํดโšอโ)ึDDิูgูฑ๋\์วLX|Z{žฯืVส Œ๚@Eบ โRnศ๗อ~žKƒ’Hsะฐ~l2ัo{ใฬ฿๗หkjสาน^ะมฬTีyถ’ยKeำณฃnHตฌGV_ชชจ”< rGชcี…d2bฑู,“คRb๕ุ0หFCeiฬ๎Fa…!9๒xีู๗sชže<ศๅ๒ธDD๊{ู>’Z* 2Nั๋Xฉกq%แ๑ธDKK‰ˆrใฏ[™O๔dฯไ๏๋>g่ZX R๙ชฬฑU‘ไG๐‰HgPƒWMGV[.j3dท^น_Ayกšฉ1ๅE†$๙๛Qt|WีŒ][ป_ูโv0Eคชฌฆ…มส1Bฟัฯx+๙|Ž™…‰fชŽน Ÿ/ "โrนขสŠ๚34ฒ_วซbกRƒฃ~hd์;ฯ u“OวŒ๛~ไเž๕๙๋‘*๓j๕8 ตZ™TMอฤถW๖TฬPใDฏŸอฑ๋ฝaFแ๎eKใJคชNS)์q๚ขภแeไ๚†`mL๐ž1k‹˜-ฮพธ#…ˆˆAŒซ’ˆ„ Oึ(4๚OšŒ–ฑนกf๕ำœBูง๛6ูๅž๚ใ„g@\ฺ๑›ปB#DฒZ6ƒY)8ฉ€ˆeซ&ซซล›ๆ๋฿ึว-0lEQธ๏Š=‰ชฮU1œ~F๎e฿นี4<”—$ขšŒะๅำCFd$kฐฤ`2eRๅช'ิ*Rฦ๑x<ขl๊เz ~ญuธ›ล"ัไIE;†/;Uฎ๊๔|q9‹ญ–จ’ˆิดล‚Bา๎้?แแฆ๙*œฮJ๔tNv Ÿ—ฤจZU'ซK;m3ตะ”็ีv๋แก!'่ ็ข,AyนF[m5"11zGฮธ๏:7คH๑๑Q?จHrB|๙t?แ…ช>.=H“Xซ3XทฆคลCS‘U;o:`ŽVzPต๚ ฌ๒ะ๛Tžตuฮ%กPJๆL†คF\#“ษx๓บZ†dฟ๛๊ฒ]u๎พ/ีใ"ษ ส!Jบ™ถdผซอ๕ร™ตฆ‡T9Rฌิ๘จTDถzNG‰ง‹ร7V๙ใKซ, }bh~ถ๓ึgฯ[๛พ๊hfูšt๒ตš6‰EDD๚Œง๊ฃู›<+S6ๆถ-–-ษฎgqAพ”H$ฌ›28๚D๎Ž€ˆ ฅพป฿\(–๊ตอฬs]่\C– ๛สฏ^Rdo๎ิ๊•)Š9ฯa็‹กะ™=C_ำ ร3อห๓ๅ ฌค2zN†L๚๐ไา/Nพ๛ผ•ฺCฎฉŠe๕}ึ๗ฟŠ็?€ขP?€ขP?€ขZำs[ญWƒณuTฐ๛ลๅฆ–+bุ"#[ฒไ๐jีซมŽ}ๅlฆโล:AUิๅ}มถสki?ม๒ี o] „/ํK฿ฑผ‹ผO๐ซEม?Xxoเ( ๕( ๕€ส๔]ฐ๗tฬฬ{7ฮฏiส$"า๊1ี๏ศ้หW.Džุพhฐขื4B=6๖Gญืlัn$ศ0s๑ไ™๓Qมหํธ*ศฐฉX.ดLKท2ฌฑ zงษ‡ขbฯ…พฺคy๊ๆฃV‰Œปx์Sญ•ฝจ๕€Š่8๘๎๗tฒไ_ุ๗๓๑,ฎย=[œ ‰LWอR;พpฬภัS6<ธ้›8^S”zฏ:.>kย-74ตŸhๅ๎ฐ1ใณ }ูDD]๕ๆN๖m้๓Vฮdๆ4dšถP+|๖hงืlOฑ&"ข๖ฮ>ห>ˆ]็b?fยโำฺ๓|พถRn`|Tคป .ๅ†ฌq฿์็น4(‰4 ๋ว&FvLเำ…qูญ„ปRณ Tgซ!)ผT1=;๊†ค๑ LF,6›ลb’TJ,ใก;fูh4พoู฿ศ"ฌ0$ง๑`[ฏ:๛~NีณŒน\—ˆHฝ{/›'CRK…"Aฦ‰ฃ1zฝ{+5tkบภ{…วใ=.-%"ส=Cผne>ั“‹{1ิธ๚tฉผwฆTตYถ"’>้ zC0/2$ษ฿๗ุˆขใปชf์ฺฺสทƒ)ขๆอ๕ญ0- VŽ๚~ฦ h๋๛_ลP๊P๊P๊P๊P๊P๊•1่ป`๏้๘ป™™๗nœ^3าดมก๓ฃ™!7b|ช.ป๗B;y้|ผœวรฬ๑ว“gฮG/ทใช:ฟท`นะ2-zห0""๊mŸ--อฆ๎•ธAซฎzงษ‡ขbฯ…พฺคy๊ๆฃV‰Œปx์Sญต”ฯP฿žc™IG๗จ์ๅ2sแfๆืร%DDฤ๛|ฉK›"g๘()๛cpyำใHณํ็‡๕๒ำศิ~ขy”ปC๒”ˆ }ทวFึGGWZ.จQmฆJา็ญœษฬ/hษ(rt,y๑iƒ์Aำj…ปŽ>ฅ3;h๓๋่m)Dํ}–}p~‰หโ’Ÿ๛๙|}๋หiJ Œ๓*าn—rCึธo๖๓\”Dšƒ†๕ซ๛q—c;oG‘G๓Uœแ{@"ญ*—Šห ลG—‹‘LF,6›ลb’TJ,ใก;fูhจ:Sฅ0๛ปY„†ไ4ฌ-W}?ง๊Yฦƒ\.KDคฝ—อํ“!ฉฅB‘ ใฤัฝฝ•็T„วใ=.-%"ส=Cผne>ำu้ฐไSn๓6ฉ6ม๗Šz[ป้Œ๋ฎ5Dy‘!IพวF฿U5cืึ๎WถธLฉ:A%0- VŽ๚~ฦ hต0:~ร@"••fU๔ษ#EJTษ็sฬ,L4SuฬM๘|—หUVˆ๋บศ|ฏŠ…J Ž๚ ๑ณ๏๐๋๊}ํ”šเ‘|šขฺœ+๖<๋วeปา‰ˆจ zิhŽลX๏ 3 w/[W"Uqvสa๓ะ>/#ื็ฑปลGna+Šย}W์IฌPi† ใ๔3rท(๛ฮญๆ…C๙IA^}%ฬOฉู‰(—จ&#t๙๔ะ†e$kฐฤ`2eRๅช'ฬP‘2พ€ˆวใup={yรp†E฿~ํL]ฦ\ป•แัSsฌ฿ตcsฬUœ่{@ณc_IVB iแž“ž๘ฯ_wืjRDO็%ฮ“๛ทšŸี-ํดMฬ BSบฅงw๕ฒeŽ์พHฃฝS‡ นš๕-d/ŸehHP^ฎัV[ญn1ะ;2h*ๆ?ด ษ ๑ๅำ\|„ช๚ธ๔ QlLbmjม=๗ิ}ฎ?eฯ_ึ ๖ŠSmš๏M3Caฟw*:็’P(%s&CR#ฎ‹‰ษ|๑v‹“์wฟณ_[ถ๋กฮ๗ฅz\$อฯ˜&r-บ&`ฺ8๋vNโฟ๎–Jขค›iKฦปฺ\?œYk๊0qHล#ลJ๚@Eaซ็t”xบ8,pc•?พ่ฝ๊ฯ‚7๗ๅฑบทi๗ บH๏ฒHX7e๘q๔‰J#|w‹_ป5ž+๖~cXW# iARนืชฒื~•๒Bฝถ™yฎ kศd_๙ี๋@Š์uMๅB 2Eฑ;็9์|งO/œูผฟ$Q9>Qrโา‡'—~qฒูำi2ต‡\S๋฿Šซฎฬ:ชP/QึY฿ูg}๋ ˜ŠBŠBŠjM๓ฒซ^ zuNnLž{xUNJrษM-[*๎]ฌTeุ"ฃWƒฟน>|5ุช[u๒o้b€r๗มPส็\ะ$p…๚…๚@e ๚.ุ{:nfๆฝ็ƒืŒ4eัว+ขฎˆซ]๒๘TีIถ2:m์ZฏูขHaๆ๘ใษ3็ฃ‚—qUaSฑ\h™–nฝe๕6‰O๏––fS๗J UืFฝำdCQฑ็ย_moRˆหะ ผ\ฃญถZc wdะTๅๆ? ~P‘ไ„๘r2s๑๑[พdฝ฿์$บ“Xหk}๚นc_CŽš†~w'๛Nฉ)้ชฮ๓ฝSทuฮโ฿S*ˆษdHjฤ5b11™ญฆNK๖ป฿นsr็ฮษ;฿๓I”5?ู1@T&f๖›ศ`ฬTใฐ?qึํœ๔์uทT%L๋9ีFOSCวาiโŠ;wŠ•ฟีZ๏Aุ๊9%ž. Xๅ/zฏ๚ณ€jŸะo๕ฺ฿ฃ 5ช‹RฯotขPีyถ|ญฆMbั‡>ใฉ๚h๖&ฯJนมบ)รฃOไ๎ˆ˜Pแป[ฺตถยsล>ƒo ๋jค!-H*๗ZUV๐บฆyก^ฬ<ื…ฮ5d ฒฏ๊u E๖บฆr18ฮ๓…Q;ฅQ‹qFB ๆถŠ>p#;ฑ๊f๏ฅa‹Œ ๆ๚๐ี พu-ะX'วฐSแ๏nŠœดช๏LหึถyชJLlž'๗๛๙R€j…๚…๚…๙ำoื—ร;50ญๆี`อยWƒ๘*@๓ภ๙P๊P๊•1่ป`๏้๘ป™™๗nœ^3า”IDคแศ•ฟ‹Nธ|)๒เฆ)VชNฒ•kใ฿m}šอบบWb๛ˆfŽ?ž*xนWี้ฝห…–i้ึ[†5T๏4ูPT์น๐฿W›ิ?"O|ิส #‘qฯŸฟqชตฒwE ":พ๛=,๙๖|<‹kฟpฯgC"“I>‹ #VŒ2rผGโ‡‹ๆŒlอ‡ธ-ƒ่‚cส:ซ”uV)๋l๓ณˆLํ'šGน;lฬ๘lB_6GGW]ีI*KŸทr&3ฟ ๑ {ะด…ZแณG;ญธfณxŠ5ตw๖Y๖A์:๛1Ÿึž็๓ต•rฃ~P‘๎vƒธ”ฒฦ}ณŸ็า $า4ฌ[ฝGo๋คำ'ฒ*jjสn๏qต[všฏ๊<฿;2ฑุl‹IR)ฑŒ‡z์ ˜eำบฮ๓0๛ปY„†ไ4lหใUg฿ฯฉz–๑ —หใฉw๏es๛dHjฉP$ศ8q4Fฏwocฅ†ฦ—T„วใ=.-%"ส=Cผne>qGpkูงฐ`ฺง†โGwญ฿t๚Qญช3mๅ4†ท(!qฉ(๋`Aุยผศ$฿c#ŠŽ๏ชšฑkk๗+[ฆˆTฅ˜+วF?ใ4ฌไ๓9f&šฉ:ๆ&|พ€ˆˆหๅŠ*+ฤuŸห|ฏŠ…J Ž๚ ๑ณ๏๐‰ˆŒ‰ม้e#vฎใ๚6=็o๛i๙็ ‹N>Uuzญ˜๐ยฤ๔8&‘†o\@๛>—ฤ็FฏŸอฑ๋ฝaFแ๎eKใJคชฮR)์q๚ขภแeไ๚†`mL๐ž1k‹˜-ฮพธ#…ˆˆAŒซ’ˆ„eG๏‰@“ั267ิฌ~š#%™๔ฺฉร๗$‰xxจ[:ฏ๊์Z1™ฐ ฆ๖ผงIฉ&ˆrYํ†,4_๗๘ฎฐ>na+Šย}W์IฌPmขŠโ๔3rท(๛ฮญฆแกผ ีd„.Ÿฺ0"#Yƒ%“)“*W=a€Š”๑D<ˆจƒ๋๘ุห†3๘ŒโI$ส> ต็N20iaฮpOIO็ฏปk5ฉGขง๓ฮ็ษ[อฯ๊–vฺ&fก)าำปzู2วv _ค!7(ทป ผ\ฃญถZc wdะTฬh’โหง;ธ๘๘ /T๕q้Aขุ˜ฤฺบ‘๊๎ไา๙๚๑อžฮcฬ๎ธง๊<[ต2™F?^ฯ‚'ื$6<›ฮยปiT^บuฮ%กPJๆL†คF\#“ษx๓บZ†dฟ๛๊ฒ]u๎พ/ีใ"ษ ส!Jบ™ถdผซอ๕ร™ตฆ‡T9Rฌิ๘จTDถzNG‰ง‹ร7V๙ใKซ, ข#;?๔ฺtMORt๗Œ็ๆ(ช๓lี„ๅ|ฺ~ฑัารˆ!.ฆxๅ]+ "aMฃOไ๎ˆ˜Pแป[ฌฺ<›O^จื63ฯuกs Y‚์+ฟzH‘ฝนS ‡๓|aิNiิb\ัะRฌฑW๔Ž฿ฃqo?€ึaฌ“cุฉ๐wท~s[eŸึาe'Vฉpt-[ๆจ*1ฑyjœ๏็K5ชP๊P๊PๆOด\1YีชNเ8ŠBŠB 2}์=73๓๓มkFš2‰Œ'๏ฟ•pญมk“ฝชณlๅ4{L๙ซห๊;ึ฿Ÿ๙pฤ@61ฬ{ดำŠk6‹งXQ{gŸeฤฎsฑ3a๑iํy>_[)70๊้n7ˆKน!k7๛y. J"อAร๚ฑฅยฒขโโขโโขํQฮc๗หQužญšงAีฟDB‘ด2ฉ,ญ@ซฃ5ษdฤbณY,&Iฅฤ2๊ฑ3`–†ช3U ณฟป‘EXaHNใมถ<^u๖œชgrน<.‘z๗^6ทO†ค– E‚ŒGc๔z๗6Vjh @Ex<.ัใาR"ขร฿8ฤ๋Vๆ๏S๕พฎS5NฬGจช๔ฑ@คiiวJ‹‘0kwดd‹๕(/2$ษ฿๗ุˆขใปชf์ฺฺสทƒ)"Ugชฆ…มส1Bฟัฯx+๙|Ž™…‰fชŽน Ÿ/ "โrนขส q็ฒ_วซbๅพbจZ?๛ฟa อฐฑ#ržœกช„’ŠKบ_ํ่บฆVR~ฃ์Qฉ3ˆ ขืOๆXŒ๕0ฃp๗ฒฅq%RUงฉ๖8}Qเƒ๐2r}Cฐ6&xฯ˜ตฟEฬg_๎‘BDฤ FƒUIDB‰ฒฃ๗ฤ ษh›jV?อ)ฌฑ>ิัลŸ ิ ่้ษ็ฉซSM5ำ6ุ๐Cฑฺ Yผiพ๎๑]a}รV…๛ฎุ“Xก๊Lร้gไnQ๖[MรCyนA"ชษ]>=ดaDFฒK &S&Uฎzย)ใ ˆx<Qื๑ฑ—7 ๗ทaซ>}สฏ%b๊รc›:๑ฬ๕e5ี2"v[ƒฺgeค3ำา๙๋๎ZM๊‘่้ผณฤyrV๓ณบฅถ‰™AhJท๔๔ฎ^ถฬ๑ยiศ สํ.(/ืhซญVทภ่4๓Z…ไ„๘๒้.>~ย U}\z(6&ฑถ๎ฃvบคย—šณใด๖=บึ!Tจ฿รจ**•สล[็\ ฅdฮdHjฤ5b11™Œ7ฏชeH๖ป฿ูฏ๎-๕P็๎๛R=.‘ ขค›iKฦปฺ\?œYk๊0qHล#ลJ๚@Eaซ็t”xบ8,pc•?พ่ฝ๊ฯ๚๋•ุ6ึffˆU›฿๛กๆชW้&ณ๏\™โg7—ไฆV‘ฐnส๐ใ่น;"&”F๘๎๓‡๊ตตรฒ˜ IDATอฬs]่\C– ๛สฏ^Rdo๎ิƒรแ<_ตSตW4ดƒ?โผนลdUฟำL ฉŒur ;๎ึonซ์ำภZบ์ฤ*Žฎek<U%&6ฯ@“๛|ฉF@ตŠBŠBŠยi€– ณ@Yช-๐i!ำZœEก~Eก~P){โ|7ลšzญบด฿ต}ฃM &ํปuมgh“‡ตฟ๐Kุ7‰๗๏‡อ#าณƒˆี~๐’=‡#โ.^8ปoxK๕ฆHN.ท็ผDฤž;ฒaฒU›7ถg~43ไFBŒฯ@""ใษ๛o%\k๐ฺdฏ๊”่ใั Woฤีฟ.y|ฺ)žาkGg่t[|แ฿$›ๆ?ฟ =ฐŸvฺฃ?a^บ&%ชˆKH๖์kซy4RHDzถ}Mฎ฿‘‘ัDŸUb—M]๖@f1ี/pล๘„yก…๏"ฮ์xO[}_ำn้๎g%9ํJ“6าž๗๙R—6๙E๕K%/sฑพาด]ฑหด&xV๗ฅDD”๕หฤฏ๖eฟ}&-ฅWG๏๐ลzฯiิ๏)zM—็Zf‡แฟ;Ÿp!๒„OนuA ๗†Eล&D๛M_ฝ[ถฒ<๐ศน๘‹ั'=์๐sนz฿$์ ษดํ฿ต.๐4!>ซ—m/&Q›OmปˆO“๚'z&#ตT(*K>ถ7เJฟฟ6๋ŽX}๒าูE=YMณ•ฝ†xb’ชสว‘!ากC;5ึšc;oG‘G๓๋—ฅยฒขโโขโโขํQฮc๗หQuJ๏„r)ฝ‚Ÿ๑OุŽy๎ทส›0'ิ-J[‡ๅซบX๗ๅPวฏท—8nž“Aฤ์9ืป_๒ฺษ#ํg๎ฏปzบu}หžึท}& 5~ษัฌฺFืส์9ะ๊V|bโ•ยพ>ช ๅวว=ตํkMDฌ>ถ=“ฏ\yFฤๅqE•โบื๖On ๔>ฒ2ีๅvฒ๚€ำ$[ฉkd$+)}<฿kฌyqQ‘ก‘Q#ษ›ป.–ผc฿ํšW>R๏๋:UใD๐?ย‘’๙ฌC็.ฦDž9๕หz็.šอœ’œั+ำขฯฤ>ฌ|๛Dย๕K-สปวmO.ล\ธม™ำล€n•๒ฟ€QUUCeWn>Z€ˆˆ>์าต$n{2_L๔0+ีc๋๗$๕สfฉ 'พzใภvฟfQz\‚ฺ*[3Jึ๏็Q>>1ˆADDmฟุู้—˜ฬ‚ƒsพuˆ†z//่๔์๖ๅฆนA,GCฃถถVอจKŸ่ˆsฤ๊ฏmซ๗๙ทSj‚gD๒iสหต6vDฮ฿“3ZBJฉ?ป~๙;“ˆ˜Zๆ_ฌ๕๗˜7๋ผfK้ŒจZ555Iญค๎}mmญ[ˆฺXO๖^5Bญถ–กmLW๋>eณูฯ[พA็˜p๑๊:bฐุท๚๋—€Hv'!ม๘๋c๏ฎรขx๚€ฏธฃKDPฑPป;ะWล๎ขฤมย์ูE)JI ‚ "ˆฤŠด\ฝŠฐ‡‡ก~?ฯ#77ป3ณ7ป3ณ;ปซง๐LAฏ4d+€|(vต0p+ทญส‹P˜์๏ž,ฒR–•—S(”oหaา3จ์2Aใzฟ•ซ4ฌถf(ึŽาศภOพง3[D–ุ…Y™•๓„˜w<ใ็v้ะภผ๐YjŒิภ๙K!„B- ‡รกP*o2 P(@y๒†๙฿œMfNŸ:{ู๙ุช˜\.๗{L2™Tว:UฐN5ะj ฟูฃ๓@Š›%xQAa๚Oช'\q ฟ  €.%]yc2]YY6++งrาƒ ว๊ถอ๔%(๘œCiฅ$Y๑AIฉuNฮ๗[|ฅ:˜6Iฏ]ี“Ÿ:้้ทi;J@xTˆง•Ž๘dง๐{K5*ฟำาี- )‚[D%• ;ฯฏผท๘|>ิ๕ƒˆ|P4ถปœCy๐ˆพœ>P(TqIq2ะ[๕4าkอjีNMZŒ ฬด4ฝ];Œ\ณะ@J๐*R|Sq6š๗6&พ๏ C„๒ฐ 7–˜ด }Wณ,*,บ๗ิ=”ฤลz›ฬ๊< จโ9v‡w๏:e=๖ื5•ฟฟๆิ…}%ฅิFฯO๕๓ซšƒิa๎ฮถ6วฌฦV?{สHg`uŽ฿ลr3๏?ใ|JลWmz๔l+‚'/‰"K๙lษ“ ๕”4บbOใัšฑ๏7a–#upB!„Ps›ธ/|bลŸ‰'Œ\I+๔8ฐฏ็ฮหq3cZG๐˜ฯfํแc๖%๊–ฝ๙^ฃ}—Žย‚ล7p‡๗ฑ)#Kง๐ษPhำˆ]ก ฬ‰ม๘qj์1ำ๕xE!„BจฑL66ts๑h๎\ DŒฐ~ึ#เh!„B!$,? „B!„„…ใ„B!„ฐp€B!„ŽB!„Bยย๑B!„BHXM…žใถใW~bง…>y๓€"พOŸฮJา4(+สN|Rศ๛i)ล^ดJ_$}ฐV1ลฎ:ฺํ[‰๓Šs’^ฟ๙Xภ”!ขิ๋ฑ8B!„BŽฆ\Qย๓€ฤโ๊!t๕žZŒฬgE$™Žkซg…ค” ฟBJ›ž:ญ‹ข^R”ต๖ื๚,ฎ€O˜!Aฉ น8B!„B๚ŽzŽืf~(j—zŽื.L–า๎†Qž."*ต„ห5 Aง~IK-`๓๒ณsY’ฅ@’hฃญำญญ<X,•›,pqE•ขO^นฅ€Œคt-]™ธ‚ฑลT{ ้ญฬI‰ ˆหๅ N!„B!T›จฎ?Hฉต#…๚ฤHj6่ฌ”#p!ีeุธN|>ทผ๘Kาป˜\ศ‹๗‹จRLZš^ž_ดถ={ษๅ†๛†๐%ี๛ k'0e1†8”–r4จ•ฦฦ–ฒr €ย„*R•9I ไr€8u‹#„B!๔/ี๘ก8-!ฝˆP›]%้‚Nแ็ว๛๛&‘€D•R๋= G๛์ ไo@oีถฝšชj้ฒ”ืŸŠ@RVถ4๛]^9 จ่[w …ฬใ๓ษ ูV T1~ Lกิ‘'ฟ&รษอโXEํิ.ŽB!„ะฟLd๗?ธภ'“>ี‰วfฑุ~Kษ(่(#๐ชิห _๋oฉษŸ^ลๅ”V;M&“๙|afAqy<2‰ฤaFŸD"U๊H$2วซmuz1’C“ *ื$ (wะ(}žสฎ•ว๛EBUสKKI € ฃด”% ก 4)ee๎ื์/5Sฏcq„Bกps๑h๎, ิ ๕}๋7 %:Cบญถฆ๒ัMR†A&‘ส*Šœ‚A๗—๑ฉญฺฉ)1(d ]^MU&?ฏ€&&ฦ+-eืˆส๚V,กค"KงKฉhuj]ื0'7+KF]SNฅJชvhKสส,HuะะOg`oีสUฆ.xq„B!„e๕ฝPš›ฆ฿ภQ‹>ฝNษR๏XNSา6ืส-๙’๑ๆซ ฅนY o”z๕2ŽAแฒ๒™ั1ŸXโ”vzฦ?๎f†{ผb–ฅล'ต้ง?ชSQRDRถ†ฆเ,q2cขd๚๖6Žม/ฮ๙[ภ”|c38UทTSธ8B!„B2ƒม๘a์1ำ๕ฟ๑F๊๊uE!„B=jŒ~cด€B!„๚G‰ไ๙K_฿xŠb=!„Bก ฏ? „B!„„…ใ„B!„ฐp€B!„ŽB!„Bยย๑B!„BHX8~@!„B ว!„B!aแ๘!„B!$,? „B!„„U๓ำc๑š%!„Bก–ฤ`0š;!„Bก?ฮ_B!„B ว!„B!aแ๘!„B!$,? „B!„„…ใ„B!„ฐp€B!„ŽB!„Bยย๑B!„BHX*ตๆ+จ๚G•ugอ5์-9.ญ฿ปŽB ๔งT›7ŸสVBอๅจ!ขนะZ\J[ต 85ี๓r ‘ฌ!QฃK)gv่๐@†R๑ฑ๕d๋รv;œfuจk™iW™้L—ฅญ›$‡จeกษธถoVชฅ_ง•5pฮHg[kW…ดฒ๙สณˆ๘‰ฑOฮญจ 8&ฝƒฑใ=˜๗q‘ฯฏZhC“ิnŽ;Q‰)I๑ฏ}๏ุทง \งฐz[ฟdฆG; ฌ๕…ฦFŸtfฺฉ๑๕]!ชฺฦถ2;ดํF๊ *จw’ิต2UdjฝkๆSrึ f:ณโ฿9cจ#Pถ•jiด|ขฦ%๐XW กOฟภdฆ฿7U๚t้ฒ7ฺศ ๘ๅ+‰โโIJIn,”žZ(.%ทPพuNiชuฉVŒPฃสบl:(TœŸ9A-๛›ร๎ทา{ ๕ฐMถ๋็hJsชR‡Xฺ<†zฺแฉธ๑ฆ…[ฮไD๔ถ๙0” &ฉ๋†‹'ศœ:tKnาบ ฆ๋ฯOดNฦธmว— . ปpะOาpœ%{ื๚ธXฤลDฐ?ๅ Z3Ÿe/Ooฺ์ข0|ณญ‘ฺ๗H„‘z5Z>QsiˆLำ'7Dฟ(ฮซQhญy์wลyป v–Pดล(ฺVฬG–˜Š~uf†ม’{o฿[าฎ>ใ๙2>๙› ปŽS;ำลDHTิ$๏ตkŸฌั_žQดา“™ฮL}๔ษ…ล?๊[+ƒ —}"฿'วE๚฿?บ~˜๊O๛Yห์i:3สฌึฟŠ‰ G๕™ิต–^ํวฅด7s?86)!ฦช™b๓eฏŠ„ึะ~EgอพaW Tํ T๔)๖ึ!ป๓gw] Pะ๎ฎLSหhJWRไ วำฮ–odา ฆLhES†๕๖ๆ…ำ๛Ÿu๑๐Ž๙ผฉื›ˆํ.ฏ?ฤ…\1ํBฒ7ž๙ยฒ;ล่"3ษŒ7@Q๕Yฯ—๑ษ๏฿†9)ท๏vษซพ a`}ดbศ]nซžจั>ชส19qUิ๔ะบฮ>เ๛)#ษLKOOg˜+)ฆOlคrCถ~kUO1A5„ค6aืเทIษoถ๊}_RT{ว๏E…โ/=}๔ืR QGŠ‹@> 1x@ป/e*†6KUณ ๅ Aต๓’๕$้ฎ8ฑ๋ขฃ'—wโ˜"ศB@–ัZฦ€\vๆkžป๊D๒Wฟรๆๆ็^–WI2ฐ:k1V>r฿ช ๖W_I๕า’ฎ~Yi๚ถ•9ฏŽ์ธ›๓‹˜่oPj๚Qๅcๆ%n๕@™ivN=Bึ ัึ™ธ;kฦ)3}RseฏJส้ฉƒ]x๛๓฿ิซ Œ 4•‘xลฤ1ถm Œ‚^=6(fdดkื–8fŽ‰ํ;ฎสZ‡…\˜๒๕ิผi๛^ Hฝžไฦญž+๙*$…ฺ~ฬึUร)๐6๓ฝžL^๔%s s๓m๗ะG๎ธh=I%ฺ้žCO {˜<ทพGๅโ †‹ฦ|qyอSนuีHJIก*ๅล6_๒žp ์า—/ๆ_r๏–j  ๑ยพn?zG๎0yๅิŽDญ6แAŒอPžฤr•n\1†ส๓งศฝ9g็่Y ehทืT@ภ๏.8K๕B‘ฒ•ใ”ๅo/ๆรJY~นl_ฮg๛ย2)11iะ๔PGmฺ?ทWึล™ใ]P}โƒ6ธฑ@ศMGฉ?„D‹ตj๏B“ษm‡ZฎC%ฎ!’ท_b }ฦฐ{"ซ2๐ท๖Ž"Eด*uดฌ’ปZป Rิฏฅy‡Jxๅ!๗ฮผสnะํฃa้4ตฃN_ศ |p/ะ๗ฒ[Pต๕t%‰cŠ&[Pลบ“ ๏[มพยBงโช]ฒ$๋ฦอ~I?Mป สษIP%ไฤKโ\.Yz:แ๛Wdฉ–#ฤญฯง๐๋Œ‰fตต3Ÿ=z•[๚-=„กญbo‹aจ^sุํe๐๙ูj_รr+&ŽFฃหฃหถ’—€.Fฏcญ9v‹—m<ูnต๓ัyD3x*zพฅ•ลน‰vํไ!; ๗˜|งภ7oธž ะQงฏไ{9;œ;ฝb(4t๛V^~ฯ{ผ฿๐นทย่*ช๒"ษา฿[zฏจ$†œ€ขขŠŠรน‚hศ๖ุcsฬ)๗RาRDญ6แA Ÿ์Yป๏คใแิVŠr็bfืหฐฝœ,oซnjvjจฟ๔“๏มีหœฃ*Žโฬ๗ˆrธ๖†#0fีIฌดฎj‡5Bb4‡Sy\gณ941ฑ฿๎๑ณา‹าzœลฬ`ิ๕5U{ใร–ฝลฒ#๎~๎ฒ{\ก ๊_ฮf™ยr]ชๅญM]สห๋:-๛ํcจ็G๐,ั[zc๎โ้]ฏ:ลืYP‰jdžหf๓ุ6Iฦ$bt16› U1้๔สqŸฯ.—[c๑zmฯฤ/ชM tลฆg^žูํฉฌคฦ๚ฅห)/็T์9$Oฎฯณ๕#54qi€o p$Jœฅ’Š/…ฌ`@—?B(๛zต\ˆV@hฟNํภ—"U)๓ึ*ๆภฤส[•]E˜RyG&kฅC๘[VAZ๐๙ํ็ฃซพ๙MWg#…{G3ชQ?Kฟ|) ‰ ัhิชj๐C{G-d}…6'%ธv…ึิŸา๙ํฆงๆ@ไWอgฅŸZJ†๔2:๙sq๖เฯ฿eผRy9 ฯีrฬˆส€‚6๋~‘–YB=ื 2ฟS?๙|Dฺ/N˜rn›ฑQ๎ฆ7ูlฟD๋“ฎ.t€ธ๋งฒŒWXธJ๏ขmXqฬป?ช?Vฺ?‘6‡CกTฮ‘กR)๖ฯ๓ง~V๓‹๎]•_๎๛ฯYฺ[๒๓Eƒ7๚โ˜ฬd2คาF TUTR32#าฯผ?1ต ใณ$2‰@ุึPปD‚2_๑$qvๅๅrนdP1ฌผœ EฃU‹ษผธภิ>/JKทฺ๐+&˜3Mิ@ผDyIกfะ'Zœืำw‹ั\oฉื\ื8…Nปื‘%ก*XyัIฎไq™UŒBRQ!~•:?ก๘หฤโ\e1†‘\+;I…’E ‹‰f \ํดŠPงใล์_\ผ้j๛E#๕/์-ะoŽx<Fตj—ๅ[MfฌภAU ฦ0ใ๗Ž!ขธAก(d’้ d+KU\VI39*ฒฆ๖5\๛ซฏฉๅ๑ๆ๓Ÿˆ  ฦๅค ’ฃ ฉ,^57Cฒ8cลฎจrฝ&š˜๔M บ๕"o๊Y๗Y_๎ธ†&ๆ‡ P”“Sตท8g{ฬภืfม๖%&J‘ž&0&๚›}Œ‹Sk็ฺษฦเ‰9qฒ›;G 1fล๘ฮไN]iฒ}fฎZ9 ึใ’”‚@ฆbซ:WD*Žyt-ˆA๓…‡{าบ•+l!หN2i[v๓3๑:_ฝโX์ฐ…ก0q‚ไฟŠHำ?ญ^ัŸปzกVปRฃc๒ ๓๛b่9xนร*ๅt๘ไโ์]Sฦญถy฿Mvš3:ๆsลโฒ๓ื-าR™> อ|Qnฺฟ๗=›t๑ญdฐแSIมSขฺ)X่๕T‰"’)T2ะๅTk๊๋๖“-.“ึ_ดfXโIฌฺฟ;q–XDkŒW~.—=ธญยB™‹ฬ‚„๙ฬะ>K_Uพจ 21‘(|๛ฤ=Vž 0F่:F–:ง*๕ฅจ$ค๒พ;^—Gผ•JY,h?ฬdFAj9Ÿ[–Ÿ™Nุขoบ3ฉj็3e$6R$ย’™žฮƒAใ78Ll3ขweฬzํ์’K,™}bๅr c๙ภjpNE6JEBn{ีฅฮฌยฒ๙„‘สžํXธ›บ}ั๖sฦtVๆ'ว\"XbCD•„ˆpKๆKu–M+1- LP’Pพษi[/Pcๆ4ง4๐8โตเ๕ฒฏfg+ซดN-?T š{HŒj—-๊5?คifh4YBจๅk๕ณฆŽ~[ธึฯzMD๙#ๆๆS”™๏m๒ษj๚ฅ™ฝmB„L๏๓๗Uแ5zkชิ;m๐ ดRบณrๆมจr`hญฟrั$ูผห[ฟ˜|ุ_e๘S4๓–'SZ๑น_~>ํ๕ว|ะB!„P๓H๕ผโbธyโqฟY4pY9 Ov8น6เปx/ข[ŽBขจ:6w&j(vยUco4w.ช|!!B!„BHXฟyBMoฒฑก›‹Gs็ก†jเ}‡GE„PำจัHแ๕„B!„ฐp€šYYw๖าe&jxฯ ๚ฃaMF!๔ซ฿๘a€]“™ำ?ฯ5jฃkl๔Igฆ_๗J%g๘พถsฦ๕สชY‡เŒtfฐตvลgต•ž?šQv,)|L๙~หNzฟKJŒ |fž|Ux๋ษึ‡ํv89ฬ๊P๑yฬแ”Šตe|Lˆ๒พดN๏—๏mยUฺ?š๒์KQ!แี9Ž`t›ถ็†‹oจ฿ณว์gt่ปี๏๊ยŠ=œกฝ๎#ว1Šอ˜๑:ดฒ๙สณˆ๘‰ฑOฮญจ 8Piะบs^กqษI๑Q>Wฬ†ศ ^g๓ึdzcว{1๏ใ"Ÿ_ตั†RŸ˜ŠcvyEHIพบธ[ "Tƒา u็ŸพŒ˜๒่ศช!*•ฏ„จุ|วฯ๏ปaีฟHปอาป Oฟภdฆ฿7Ujšไสhฅ ญ๔WŸy›”๐&๘“Iw‰ŸbŒ;–ภ|พQณ๚โฉใBŽฬ๎า์งFT"๑9ืำ™๋5ชย _3ใ4›ฦ~dใ๛ืฯฏŽoืˆ'๊›ณวRฟj’๊uฤ>S :Mฺbา'/เฬฯฺะ~–ฝ<ฝiณ‹ย๐อถF‚‡"จaZdป~ŽฆDqญื†๐ข.›]ญxiS้๛ไบึ!TLฉQv—wLฅผพy๖m„้ ›s…o๛Y๘ณ ๋ฒ้ PurF|๕Esผ๎๑,ิ[l=g๋พeรฦV้@4)E๚o๙‘ะ4ถ IDAT๙ฌฯฎ›ว๛Vv ฤX^š—ŠฦkŸญ2^๔‘าi๎‹›ŒV๛๑ค7ู!ึป‡ํZ่ด๙uˆีฉอcHกงžŠoZธๅLNDo›—ƒ ฿Œณ;o5ฑ่้ม/›Xฬ4;aฺokัหtšท&“บnธxbLภฉCทไ&ญp๑hบ์฿uM๓‹ัฮaVณ>ฎz4sคสล๘ y=“ \ทxsช‹ิx๛‹Vหฃn]xPาบ๏X รG็3›;W๕‘๛โ)฿สค8&สr‰ล{๛jตŽูืˆ,žเpัz2/โ๚YWน๑‹Mœ/Hj๊๛ฑNbŒ๑RัG$hTnบ\ล&+gํณ ๑๚฿ํf}•{ƒJฤjŸ‘]deซพ•“f&ณiK๛โ)฿|๕q‹ฎ:น;ฎ฿ข{อบ=G†EYAืO;{ฤฑ๒ย๏8;Ÿvพบ@Q๕Yฯ—๑ษ๏฿†Bาom7ทƒูฎk7ฝฒฤ*/_คพ ~๚ไยโŽีฃล>ฝ}๓ย ทD€๖๊"8ภ9Ÿฮ ด7่๓w9OS ฌŸ๕จด4ฅฉG\=}+นXˆ๐Xyู99ู99ูŸฅวฮ๊๙โยฝ4PQ”z๕ุ5กฐผM9aฬึ/™้ัแ็๓ญ 6\๖‰|Ÿ้่๚aชU=‘6๚ล‰๎๎๎๎๎๎๗g ่]eพ2ŸSฦ9ธG'ล…^_ชEA๙Tธ๚Œ็ห๘ไ๗o‚๎:NํL ฉMุu7๘mR๒[ฟญzีkŠnฬ'ฟs?wฬn‡็Bฏ!Cๅเำญ–๛W;yฑI๊ร†v๘ฑˆฬ„c/๏=Jญ ศuฯู๙ฤ๎=>ตcGตฆห|#”ˆษd‚ฌฌฌ๊2fŠ๓$YYYddd4m‰๒_sv>บีแaะตต;ื:A=–ฺฌฒ~Žั7ป๙!!๊FF]=–ฆ)ฆ(.ซะG๎ธh=I%ฺ้žCO {˜<ทพภ๛๛ฬ๗z2xั—ฬ-ฬอท{ <ฯัqŠ›svŽžZ†v{M5๊ฬ›ถม`%†„๚PฝN"ศๅฟ-ๅ๔ิA‹.ผ-ญ eด}pp๐ซุ๗‘7๊Jิพž1พ~J’jพ$ิ๙๘ษป‘…๐ี๏ฐน…๙น—ๅตข“h I้6=ปถ^bbW?๊ก๑ยพn?zG๎0yๅิŽฤ๕S๘J๛gcฟไST๕!ํฮี็ี{‘bz๓M่ฎฒžšm๑่3IถS'ฅ‚ชำ%ด. ๗-gณ๏ฃhy฿Rฏ.d0zw0ะTFtเ*((P:ฯป๚>1่1๓aJใ‡ๆญษmถ~FAฏƒ32ฺตk+|ฬฬ‡k๚k๕ัั๎ฝ่ี๘[อ๛ฐeถ•S@9ช’–๔ก ไg8\j2ดฃ'7ท๊ำ” $Xต+นoี๛ซฏคziIWึฮ†6๚ํMฏ†……„……„…™$จ‘Q0\4ๆ‹หรhž๚ศญซFRˆ๓Iต๓’๕$้ฎ8ฑ๋ขฃ'—wœธ๘๑่3๖‡ซŸfiพnŒผœ,@A~p๒๒Šไฬึle4}9ไžห“๒Te5๕:Cz+ไW[XL่1™L’“ฺ๋นPปvี‘“…ฏฅอP"v9€&Fซซ๗[ณวBTม@มุlี๏I,Wyเฦch‚๗ธ&*ฆ(ฆนuิ้+๙ืฮHšsxคn_ธ~๏ฦ็v‹ทŒWxใฆgEL13ใ8สวะ„ฏ๊า3gjฉซทHธ^^๐อ“Oๅ๚ฐ|ผA.Q-_žฺ/O“Št9V๋‡™Yอ๚oๆๅฯ ŠI"U/ax ๘๐((ผ9ฟ›™ŸืxัืnYอ&:ฎvI\ _ถm<Ÿ$ขre{์ฑ9ฆm™ฑi?9i)โ๚ษบาแพ๙^ฝ›ชุ†-3๓„~*+##ิฅK?yฺทoป P”๛~๙ก้JD‘jฅขชก>ชk€Xf&ไฝุ๛ญcฉ]มโ Ÿ์Yปฯ_|๖SQญๅ€pkยbŠb F`ณูภๆฐ€Nะิ๑ไ๚ฬ1[?RSA—๘ค:Wœ๓l๏ขg"ศ "ฦJrฏธ\.I$โ|Š‰ัไgŸ{7™bR )!4€ร!ธDป1๊ำf๔/บ๊q๕'Ynปo+l`{ฺt…KUซะ3OจF‰˜L&๔๏฿_%ึ[Yk€Ž,0™•WZšฌDK{ต€•|๓๐ญOภ๋(p—ฉีc!จ`ภ)/็UU3Rป\ำSใ‡๒r6€T*ุ์Šฝˆหๅi4 €>ั๒เผžพ[ŒๆzK-ธๆบฎ/Vj่ๆ=ซ๛ฑ|XB'^ษฦงbŽ~ํ0lึฅL “HUี@|ไ€+๓U8ฑNG‰ซ+f-yyy๒๒๒๔pฯ๗๓Žคdึu])๓หะw/Iม็™๖๋ ^ี็_ฝ)ฉฺ ๒’ยr๕S่J๛ผ›)ษ•Gหๅ˜W^›i้๊†฿Jซฤ<{f๖ั‘f.ตฮลs>ด9ก{y฿าื ฮฦ—ทศ 2ะ~ioษฯw ่S๒=ฐ‚ภผผ< …d …PVVF\ขAR“W๎"Xง[ีฎ~๕ˆ&&“ $•6สY ชข ZyฌๆพIณหบ๋Gz๛.6หZ4•}{ฑหุKgq=$ช+|่๏DUํิ๎kRJqJะm{V—ฉ๎+ฺตSHญOS^3fE—œJฅ””พOฦๆ$63ผcฃMoฒู~ป‰ึ']]xทšคัe?คชE`็๓m9 ฯีrฬˆŠ๘ๅนะ‰ว ัh@ฃาชฏญูบ1๙…222@••“ศชš“ช9}zฏbฯCOบ%ช$9๐เๅถณ L็˜Ž:ธังดy3OH๘1™L~๛:เบแy„}ƒษน72*ฏq5Y‰2]lทO.๒)๎mJ>่Fฟ๊cฉYม4ฅSk€ฆ*ฆ(ฦ)1ั…0ej›๗dง้0ฃc*ฮLgพ_ =/wXฅœŸ\œ_Pจd หฉถืิืํ'[\&ญฟhอฐฤ3ฉf้ซส๗QตA&&…oŸธวไ/ุd8”S;:L—iŒY1พ3นSW€lŸ™ซVˆ๕ธ๔ๆ]*รHษฮ คpEรq’P๐8ด๎ฉฃB t๏M โสกT`ฬZ๘็-š2g็~Vฐ๔ฤIDOฏd์6ฮXGฑk'*€\ฏ‰&&}Sƒnฝiํ๑&๓จงผ Oiฤ๋l ย๚)tฅ๕nœL5)๎‹+ทณj<~ขMžญโฎ'T}”‘•-œC€~ๆC๛๚W7Gฮ฿๑ญQณ๚{2๛/Xีน" 8ๆั59ขภ˜เ ยE“fmติz๚| ๛Hผฮๆญษq๎I๋Vฎ8ฐ…,;ษคmyุqฯŠ๚Ys฿$Œ๙พ๘#ฮไdณ@‡D‚’œิ\Pศ๘ WT7ฺะอ๎‡$ อ|โ|&GEยิพฃ†kc๕5ตœ"ภ|พำ๛๔t ฟมฑ`b›ฝซๅจIบ1ํ‡/›ุฺI‹ ฿ึชUŸฟFฝๆE`แ g๏p( •Ÿ0–“ดfLืส๓p|^k~'ไ์…ื lฆฎšณฯ็rfSeพ1JTฮL"%ฅ•๐:!?“1บ๛สำ/MXขo)/ฝ}~\ #๏2Dืด +X ADะciขbŠbภzบsฉcวู่๒rb๏YŽฌ๘‚๓t๏๚๓สgฬฒดfฅž w๖~|tทO—MหOˆนปkฦค‡ถ็อ๚)^V^๎t`xลฝๆ99อK:ใ“ภ‹ ๙2ช+0\T7ึรบMถอธข!?hนํ ย›๑—ฬ.mถัฝrฤฺํ#ู9‰ฎŽvvCfgิืฮJŸEULšHณ–ขงถฆปI;NZน„›๚ส†ญ'bน 6|“ำถ^ <ฦฬi xฌบ๛โ@๋ั›œFฑKพf„ดv#งQŠN\?…ฎดม๘ Y๓9Uปปๆว‰฿/I€$>๑Xิฤ๏ผ-Z๛Xฝฝญํ[G.ด}^๛IiอD•QklGUdผ๖’(0่ฑํฒCดํs[๋s?'<ตs๏‹ฺ๗B@sืd๎C‹7สํ฿0฿B—q|‰ี•?`ญ}“8fNล3,฿>8๏7i›‡ฮg๛GFUb‡žฒ8)ฝv–๑า‰ิขŒททmvVฮฎ)?้ŸU;fุร็งืk˜ฺก GInฦpc\G.™นišบมิ…ถdัhYA1{.฿7—w{“ัฐ‰๓vผึูฑq˜$0†YฺN:๔ฟqSW_aฯ฿ฟXK`ลi=nซๆK;“ัใง[ผhgn9ตMี7™'ํ๖\ ญุ๛ฤSS ๔๛™น็ใ…}EPฬจ}ฃ ๔๚ญพ—›xjŠ^?ำซ้ะfฆๆถ~ึ3FNZฐ๗ใวร%กํ่้O7Lุ8qš€!#+๖‹u#„ะ_ขื๒=F_O-7ฤh๙0ๅ%kว)ภป#+ŽŸขNเเ/r„”๐-aฬvFปœ๏฿คR๙>ฦบ%Ÿn ืฯ@ฏŸ๐}แmgm]Lปฟzผมธ9๖IŽ+ีฏรฅhlฑV๑™ฅ๑ะฑ3ฬTฬ6ตjx‰๊&;ฤzืเฐ]๖U5 QZm๙I›็J0๋ค 5›ธD(ัŒ$zฮuบ๓80์นว ‡ฅCVtฤศชรฬฯ๕~แไฮ๙ฝ+ฯw“U‡™Ÿนใ์๋๓ศjpตัฃ์(๋G~Onฌำกˆ$Cจฆโ|viัทr>ฏฌธ„]\/เญป ฏูE1ฺ-นจผ์๋[฿L]ฎะwไศ.ฝ๚\Rœ๊uร“7|ธฆ€ลล๚่๋ฤ<๚/๖+ซ,๏ํ=็ใกL*Tœ› xtvb=ฉฺหp๒B"d•ะESิZY๊ฏGŒญ๗ฅฌœ๐๛^™tปŸ*•B!ๅแVวŽ/ึnค๔BจeกซชดJžล*/Nฟg3วาM๐˜ApS^#ฐทฅฯีลว฿}โ็wำมX\X๛เ#ฆฟํ3;Vด๛rzหNdƒจวขฑ๘บทo€ืc—ณปfuH๗uพU@ขษ๕ิํZŸPฟงฒฝ=5โัg’lงNJ๙๙๕i‹… ด. ๗-gณ๏ce[ู8ญ6Ycๆo^x-่ f™o™%jึฃ5๛๋ ์ฏ3ึโ๑—,/๏=jP7š฿มฯ๊sm_u6_2”ึ”๙$&’็ท’ษdštซVาคŒค ๖A๊]บ~yq<ถ˜ล>Oรํt—‡ุผ๖]ป}:๒6Ÿ ๐1™Yญ}ผฝร๒oฅz+ฮ”NOฅึu~ฒzL‰ Kฏุๅต ัร<"ฟ€‚ขb~~>@ม็J+%I€PRj““ nDฟ}|]Jšภบฒฒlึ{' ช๐หณƒร๗ ๏FฟP็๏›ฃส‚‚บค$€ RRR๙๙๙ 3าๆเดŽ+อบฒ๘ฅอฌทs=f<๛๒iฝO!„ะŸ‡L&๓x<>+-เฬE฿K:ศ ธX@ุ”VGฅRูœ:ฮีึฦh๓ ภร-~sQ#EXแ็.G]1 ีX\eยNkล[๋ฎวT H ญ9zธdด๋ฯ|vQJ`Džล mx t‰ƒgฯฬ>:าฬฅ๚อuไณFS^ฯq>ด9ก{y฿าื ฮฦื=vจjC’ะ3~:้้ทiซr%`~ๅg๐๎fฮ8Ÿ"dๆ[`‰D@qขญEg/๋ํแ?ๆ”๕จ›0GBซ๏&ํํฉ!uไฤ่*ใว๊fลพ+ iฬฒlฌซฎ@cไ|.ไ๐ ๕รฅ~๊tz็;ฏง0ำาT๔FtUT์0rอBƒjทฐhฬฑ;ผ{ื)๋ฑu= ถ‚คy}FUก“ษRšใ†i&}จaw˜ปsฟญอ1ซฑโ•Œพsถšฏ<]\uุ์qJ‘๑WšS๖Q””R=w<ีฯ/Q@BeQaัฝง.่ก$.ฎะdV฿่็ฟ<ฉOWช฿ํk&ณqvฺฒ˜จธ“giสะล•๚Mฃ™…A–ฎฟ๖ฎศdทœ]ฮfืฯ"„ะ_ซอ๔7wฬ่฿NZŒ&ญ1fb’71‚z(„M9a ศจwn-Fฆต<ข/+!K}ฒDฅัๅ[)‰Q(ส๏Œ )ม-Wอ.‡๐mแโ๙lษ“ ๕”4บbOใัšฑ๏p5&ุlžัCš dqต!:ฅงฅืงD2ฒฒๅŸsjน-8Ÿ5›๒z–€Ÿ๙ะภงIŽ›u…่†Vซ{สHงbบภ๑๛ขXnๆ+Bfพ–จมZm5๋เต๓hT้๗ โ@Kd IDATuKT฿๛สN์ึตณน็'ฯษˆธนใz"ภืธ๊2ณรkทข$๚ู็’ Eœz๎8์ฑZžยสฝไ˜X_=N^แx๊ัผค๋Vืgš~_o~JBfกRIB๚ฏG‰่wผนธอลึฌ็NIn~J่ฑ๗ซf–ๆ%วฆๅ+–ฤฆUํ4™ww฿ahถ$‹ํบลมฏXฯ๗ํ์jguรซ'5ไŠลล8:๛๖=*ึ6ืL•)นฑwํvอ€–>งgV\ฐt Y ๑G Mฏ3@sญkศZ>ป$7-๊กมจ†ณ๏Vฟ“ำdฟ'”xยhม•4ๆํํวิm๗>\/ฯษŒvตq|^ ฌŠม~ชฯƒ๔ฃว=ง}๕t8Yฏ“e!๔งสrsบขฒฮิ: NNผ๏y‹3o๘=ฬผฮอฉธ'๕aศสสใ'aSNา6ž๗#มJ}uำา๑5kIw?๗๑าฐeภ–yษฦ๊rŒ }ิFุH lนju9ˆcแ}lJล™Nง๐ษPhำˆ]ก‹ณฯ์ีทถฝ๖T‰^š๛lทใƒ,๐=}pุฎร.๓e€๕๕S๘yว[ีg< HโEMเm1ะฺG`‰j5ๅยทฺ฿ๅ๙ฺุ๋พuไB็๊Mีj Ÿ๙?ฉDย4ฮ@ฆ=\ ภzผ~}qบ%"1?žเ:Aฆฺ%„Z–ษฦ†M?ฑMQQก‰SDบžดBxค}QZ:˜ฯŸC๕ำ,GEz[๚˜e›.ธ’๖; ‹ถ๗™6qญ{1h—9!wlโื"ฮ#B่wีhคD๒%„Bก฿Tึืkั๚ฯVฐ9|เฏ0๖๒๖ธๆฮBH ? „Bจข๗^๐๛Kg=w˜AtนA5ช๐(„B!„ะBเ๕‡D3qCJKk6aB}ืตNxuOdG!„๚ืเ๕„B!„ฐp€B!„–Hฦฝ-}Bย^U๓ณ๊สณ/E…„W๛็8Hj†๛=~๖๔ช๙`9Qค‹P }ท๚]]จV๛๏฿[ีฅ๙ช๕[Fฒ—‰ำwะ็^ŽฌZ๑uั™ท๏†‹oศณ'๗ฎิW$๎ AVk~อ3 ,ภฯ็ฦฑ•บา…_œEu่ฆSท<ƒ|Ÿ?นฐkjgฑ๏_ด›u>ะkฯ™ชฯ}ท๚…„ฝ ๗๕qs6ฉ,ŠbB+ฝUฮ๎มo>|ˆ๕์๊ถ1m๑TBกCTฯ_J>;}…”jŸ]7๗ฅU->ภ๒าŒธh;zบฦำ ฮ๑œฆwไ…2ฒ,,ื๙nT ‰&ืSทkq|ยW€‚ฌฌ2-}}92ญอภๅไๅ‰wผ'œฌ›fvล+๘๙y๙ดฺั—%(P๘ล‰ศษห•UžŠ"n] L€่ฃ๖ืYy7—pŠผ^฿N)๑‰ -ๅๅๅพ~ ~kๅ„‰F๛CผR„BH4Dr!๖๔ืศ@–ิ0ฒ=h5-h๑•฿IŒ˜<*อuv"d๚์2๑atšผร~aึIณอAŸyขHก:‘ษdštซVาคŒค ๖A๊]บ~yq<ถ˜ล>Oรํt—‡ุผ๖]ป}:๒6Ÿ ๐1™Yํฬ๔ว;ฬ35ฟฝ๖/๙UbาS<฿ฎWž่ฑs๕พ(„žw|spฟ›?ท0'สuˆ“pGh๙1[,:๙ฺ,๒ฮขužตอฮ4ึไฤ6a ๐‹E$ คŒxู่™œye้Œ๑rีyี€ๅ@ก๑“nmุœ$’‚~วฯO‰ฮํ*Bก†ษ๕vaVf&33“™๑!๘Žg|็ฮพE้?dเ'฿€ฬชm†m:e฿๏ล 7นีg\œWจใ๖E„๊‹ฯ็ื€ฬปป3u-.y{?นsศlผ €Fฃฉฮ๗zpdะึสg๏พใฑ๚€žl™EJSฉh ขค"E’J้"}+ณ๘JQ”††๘•J{’Bส๊กddฏ [ฦณ~)ฯ#ข}/xฮsฮน็>๗žs๏น๗sW๙Rบนhฒอ'กถ๓vH\ฤณว่&v}1เBLจซ6o็g…ฝ‘ IฯใS"ยƒผ,5DaeๆปQส(”2 ฅ๐Mฺณ๋ZรQS โ›)”ฒ๓‘r{(eฅ^:?ปPฌ‘F๊น๘Fฝ|“๕โูUนbธฤš 4=ฏ('๊ฦ๑ฝ$D~UยซฎdR(e”›๑ฝDšตร;41ซ ?›~ลrถภ…-g%eไผyํwxูH6€^*‚ศ;w'วc‡ Fถ๎jฝห sศO|v(๒ฒฮ๒ท๗ท๕—?^ษ…Uซฮ๗๑]dƒL|ฅำฟยA;๕อส๐ฒ›=ฮnšb๙ฐvธ๎๛uณˆู้U]๑†i.—ฉaฒL๑dl( 8x๙๕uฌMวว”ัR๗:ศKษ๘‚Wลœ‡ป{`UCฤEฮaใD?‹ูR•S าƒ˜๓ถฯฏqf๑# 3ุป‘เทQหท‚c๒6ฏ3žซ9ลฟ ดะŠ ดฯ9ำฦgEVป0อฌฆd๘zมpโก๛งs=t#ณkพHCซIHอแำ#๔น่ฝญีs_/ฏื* ฐiโD๐}>™"Hฟ1˜๒s๙‚๙็M`vžY )›น8nPหOญH:ถืั?oฌmิ“อd‡Cbšื9›lxn7ธ๋ฎธX คdๆบƒฺX~ZUFศ)๛ngตภ์ใูทVฟ;crRยึIgxํ“=†ฆq๓ศc๗N5ธ๒†o IO๚ถ๑D‹gt€1&ท|ฆ5?ฒZl๘ž]'่.‡yฑ฿ฺๅ<’…ๆ=ถT{่หฌขณŠ๙๏ณฺc‡oaาN'ิŽ^้y~S“[฿็ืDทšรมฅt3THซ—h“Tf๓C๎%ท—rธยข/ i,-aถฎถ˜e)HŒ\k8SSหถ๓ภข"Hn I๚o2ไŸ7๗๘งหQ ™awnฝN^i8qœ”$ภŸุ@7ล‘ฟวด้œ7ฬดต]๒UืjIทถƒ\บฃพšถ๑๙ๆีฎ&ฒภ.@pิ„a|c&H๕6??? ?ึ๘๐งO#B.:่Œภ4f…?Š-l์ฑ<๔ๆKฅCพปฤB›ึ{]Zyj;หฮาW,~d€ฒฏ{ไ& _n๚ธฦ์œ๊n_ื‘๎_if—%ฟkcตCC๊ํK1e๎ฆฉผSจผ`๘๐a}Yแฟ}ฦ„ฉ๒งlxฎu๛ฦšผ=ซlC)ŒA๚๙๏‰คhใฒŠู๋}A_^ฯ๙‚   n๔šห‰orใN[ฉ ำะ๔hทฮ@A‹ะิŸeี๋–&๗’EŠP้nemๅs๐†ภ1„GLnœ0rs z|G@ไ#๙ฯอ่ธค่ธค่ˆช]ก-ฯ63๊ณา^ท คฦŽ{šูศ ฝ K˜ +ภ. ๐Žฃ•ร~3—ะฆ^–Œ ‡ยDชฯfลF^สฺ[-bณ"€ัฒๅ†›ฌ็พniqๅu#›ˆศ๑่ŸLy์0๔šูi2ํS8ื%๓Jsูงฤt ็ึ=——๋kหภฺัฆ~ัqษักง&วป๙็RแqCล%ค็อจ T Rฎา_•qฑe๊ึ;g’cใ;ฃไxก&ๆพoLฤๅ 2เ'*Nะ–เ{๎yะใ๎œJ* ๐ฃไ๘ก6ิ๋๗๖]JŒ๔tมŽ\ซ‚]ํฯœ๓ ~ภอร ู‰ 5ภ5cบ,`g*ฯฤัžEถฯํฮˆฟu6,>6ภ๓ซ^สH"€Ag๘† ๐ @"’๚“ัFพา+ุุ่;๋ 'ฃฑ‚ฟคGL†ฅŸ;อไใภเธD๘8Xcย``ไxŽ@›ญ‡ขZว่์฿ฃห ค™ึวำ|m7›Ž|๖๔:™^ฦ@๕จMูก7oŒฬง๕ˆ:ส, 7'ีK"๗ํบ0X‡„_ ๊? ˜า‹Fj*Šj*Šjs๗ว๖๘ถโถ้ๆหน@ $Vžผใ๋วื฿rF3 H์ พ ๊ahJYฏ๏*a“‘p;งฎฅน"แnHแฤIใุEล‰ฉ๏๖tž๋ฤov.(ภหl&ฯVaซมื 5-›๔'œ|๊ฮแfฬV.Žˆ๎ํ”œ ํ7จญUีฬ}kt*๛ุy^หีTfชช๊^pf๊ำgฃGแํำรVš๏๙ว^สุFฅืธiยฌƒ้x<@[[ืEa’เ0q^|ฏ1qb ๚฿งึู2Tั=Šœไฆ;[.ไวVV‹#LตLK๛Ÿ>€๔&ฟ4OฝŽ๑๓ํฮd@nะ…๛ัฯผฎEถi8iP\พz!7ภ๓ZpะiŸงMผ3—Žeฟดฝ๒{K—ํบ๑Aํเฝ“Kฬ‰Rะ๓ศ฿‰Fฃ•2_๋Sี@เ‘VU’Zฮพ Q[Wว๘4x’Ng๓จฏ†๑e….[ ฎlLถ7ศXผJ๙|rXฯkศทใฃ9gHzPฺ;&ตก(&ตฦzึD‹nnย๔้๕)ทู=๚uuu$nHขข|•oพ๚๖"f[U|Rฎ๋œ๑$ศ„1L{ ฿geีข๙iHฤW—vYพQ>ฯฺฺจ56๓งถวhซ๛ ถƒUาถ6*7x<จิฯwef[S}๛‰>=! ฺ๒3–จ“†—7žu=ป0TอยีlZs๘Q ilR(ภˆ‹‰T‚„ธ@Iy9pjธE_Y+Nห<ถH๓d›˜cw\?9%bฃแfณ8}๊ |vœ <๑‡^8s|x์ด&&n๖;ง๎ญี๙จ`ฑkjjp8`q8 @kk+๐<< @$๖า3่QุkกผNN|Œ‰฿ทฦdš‚ Oฏก๒w*ษห^ "uณธFฏุปำฯ๖ฺซ6–า†N๎fc˜๑ฎsถฒฝึ–Ÿ๐„ ฬHgถ53>ููยd2๔/zFt“ ƒC—ึถ_7ฆp๛นŒ&’ไ์™2e™e_‰M’šuํฬKะJNJ฿ฅo<‰|3Ÿ>ึะ@!=๐PCฏ ห)กฆ4พบยgp€๘X”$๕ d… @$b‹"oLัn?น* ฟจ}…ys&~lV0ฑYสy฿jํc–I‹^ฆืรา…f๖oฦ๓-S คฟ|ภz(`e|BฬT6ศgžu]ลมช๏ึQร€lั iI์ส˜0วถญG๗`ใ๙ kK:๒Dไไลq8ู)ใ‰ีฦ:ๆ›ฦusฯฝญjy š–|hMไ๚๋k+#Gt4์๔ล4€%)/+Xl๗W๑q๕์ตฉŽY>Ÿ๏“ !e:u•ขก‰|‹ด8กL๎ฅฯุฃ" ฟPO^hœ €๒"##…’ธํรx&jญ)ตpก 0โŠ{ฝV๕Bไ๏ิ|๔˜œฃ{ฐ™ฎน<ัว%ท] @mQNEฝpSNซ9VปTu<=bŸ‹฿vAzีซG๖ฎauสŽON/mŸ[่Xสh|ฐ{๎ฤ๖ซh%แ๗หN YVr่,๋ม1U˜D+=‹๘๎S๕ Œ~ศb~๏ุwฌ~ไˆW?เฐ–šซ‹S.ธ๎|ˆ ?QvLa^n/ร‘ช|๗นŠู_3ล}ศ|tเ`เ่6@`‚9dŸา1นN€1ๆ ๆLjำ‡Rฒฟำ๑žภC฿Nื˜#RวลูึงŽ๋โ๗mุ็ญGjฎศx|: ต™8›Uาๆฐ›Žq8ฎ]g?๑6ำืฮมฝ—นณjwฎ‡๒๓แY]กŒฌฤ„๗๓ฆ6วค๔๖*=ใฤฦ]n;ืZOง–ฅž๙ว๖Fว๐DJ\นz๔๘–˜งไถ^bพmŸ๋5ใ…ศลหฟ v~๐sฆGGํ๐ศa๓ ย>รvJ๔w9๖ŽmธaตsดซลโuึŠŒ๊.ฮ!ฝŒ’๋Q็์>ึ1’่|หc๓!ุ๔^์GอวๆQ›ชหoูw๓ซ๗ฎKŽO3สj๓๊>๎˜๏8ถฅืก๒ฃจv๎ขK๔t‚‚nadเบทด]b[ZT9z›฿ Az๚cZEฌด๊สi"Xe Œว๙ง์ฑ6w‡ศฯ.ย_*โฬŸy๙โ …๎? ‚ ๒3qO[็t|!ฉฅ๒eตลู_ด๓€ Hิ@Aไgช๗:ฮ๏gA>C๓ท"‚ ‚ าWl๏? ‘ธ‚ ‚ ]ะ(|i‡๎? ‚ ‚ าWจ€ าXั้ซ6m6R‘DO!‚ งo๊? ]y‘ฬiแ—9เBLจซ6o็็‰ปล%=K&฿๘Gบ๗”Slยฏฎ—"ฐ๏ษjฤ๓๗\๐ OˆŠ ฝโb8ิฯ˜}OŽ“Pํy;$.โูใ‹๔Gz—ใ—]aodBา๓ธฤ”ˆ๐ /K ัฏ#๒ื^u%“B)ฃฤุฐ~~๔R็;Q/r ผJp_?™$ท…Pส(ŸศN3ูฆ˜ถ๙lp๋ฬ”G็ถ+ t†‹,ฑswr๖zฃkŸ]Ÿ_ฟฆ™็แŸ]&ี๛'| IDATA~{฿ะ *ชH%œพ™7Sนใ(ษตเDาyรŽiฬ๖ภภ]“„Tฬผ‚ยbB}ฝถ) ถ;ล&99ฑRqV๛๔c|t๊8Een‰™Jq1X๙อŽJซๆkš๘4,ฑ3–€t7Mๅ๒๎}๕^๋ไ ตd๕ฐ'Vk Kgต^™m'€[ฦA.Q_M๘|๓jW“ฎ๔‚ฃ& ใใ3A๊๏š^ŠŸŸŸ†k|๘๎ำง!tFฐ=~ฐŒูไญ ิ๖ ฉท/ล”มืถ;N@QAฆ(;ทu@ซ€Qฑ=oฝ@เลำฮWŸsOžภร •ƒธธ8ืผฎn™ฤ+&ฦ EลEขk\\–๒ฟ๒vr ฉ› ใtุDบ3A ๓฿๘ง3ค4๖šj]ฬ฿Iัฦeืณ๛‚jzX[[ >y†4Ÿเค้† ตƒำtŽž๙ๆ…ฎ้\l’ TWWcธEF4%z9{๏E=TGบ[Y[y'ท๕ˆŽ!p แ“'Œ\v๗4ไวเจฎฎ(ปฝM{‘ฎ[ยฯ.‚ ฟฝ~๗0S”งf&’u๑๑-ณTฺวฆ4FGฝRPžNเŸฅ(›ฦ`๋›zงี47Q_ฺฟลฐM^ศใzb๑๛๒˜จLII!v้ฅฦŽ{šูศ ฝ K˜ 9xน๐Žฃ•ร~3—ะฆฎ๙o …‰TŸอ:‹ผ”ตทZฬ๎งcณ_ษ€[๗h\Rt\Jฌฏy/ƒ9F›๚Eว%G‡žš๏ๆŸ? 5ญG๔Qfน9ฉ^๚นoื…Aุ•ไ;`ึฅฟLฯ฿sF้—/ฏ#v>๊Mœ3vP@๐Xe‰yห"’๖‡'+๓]๓ฏจŽŠ)ุช8“0Ti\โใT:—์*วฝ๚2 ร# I-ปไtฝใ:g{œ@ HฌBื)(“ษ:X ๆ/ูC~ฉ"*cqฐLณžM~icvYsง H‚รiU๕ํ'GŒ7V)’l+ฯ•ดy9{ “ษ„ๆ‚ธฮ๊ฐVaฃบ‘๔ฉ%z,žกขu<]ั็ฑๅํฐB,ัKมส๏YlฟU)ฝ๑ฤม{'฿ฉcUzฦูำื๕d~๙pG๙CDฅ…9[>”V6ะvQ๙ญ}yฎ๛ธ๋๑ึ``Ab–Jณ‡žฺตrฌโพ'ห•ธC?Tลฤผ3P’:TUŒc+€่’k?z้ญŒj`zส๕ณ\_OŽวใฉ4ถงฆ4ญไ–๙ZŸโ฿๐HซชmI‹N-oฯฯMdDญ:&ภง3๖ำcเ–™ป`ยวไฐคฒ6€ฺ:1Yฒ้HZu$nHขข|•oพ๚ถf[U|Rฎ๋œ๑ค‹__^9w,u๎ฺ‹ŽW\b้ๆดศnืโซ๋ใŠ‹ภ@S“/๕๊ีa๋ืจ๑ะ‹หI‹<Žฏ‘‹ุฃป๚ ท๑ตภรฟฬงฝoJฅR–=ไ7ANY“ว7{๏S๗ภึ๊|T pjธE_Y+Nห<ถH๓dฬ`ช+฿f{:& (}žCฯ๓ๅqอดC๊>€ล`zูฤณ”k่e)!oึœ(ชจ่ฅ`-”ืษ‰ฏ“1๑๛ึ˜LSูv€EžAjmŠฆ๊๊jAA ็ะกœ๏฿ณ{PAzUS[ Pรื^Žw .ณ9เg A฿[?ฃRž%๔สฃ/ณอšAขPขฃZ๗m^ฮ&ึฝ}`‡็ย‰าP9]E‘fฎแ’<ฤ๒†ถฎเuว:9p‹K ส๘U4ฆตผyศ๖Z’—'ผ@E๊fq Œ^ฑw;งŸํตWmา†N๎fc˜๑ฎsถ~์฿สฮฺาŸg๎ิ[=6ีฏ”S@K2rvว7#W๏w3อˆ…9;6ณ‹ษ>๙—ZษI้ป๔'‘oๆำว(ค๊)WภrJจ)ฏฎ๐๐ผหฮ?4x701ทht€†ทo[ ขจจ•K~xษ๕ภธJ‹ P\THรŽลcฤ/1bŒา๔i|ญzLฮั=ุLื\ž่ใ’๙ภcmQNEฝpSNYฯ' hwOุ็โท]^๕๊‘ฝkX]ว5™ฅตBM™ฅญฝลd›ผ‡*฿}ฎโv๖ืLDq28๘ฆุฐุ๎0ฦ<0มœIm๚PJ๖w:N๐Zา_jณr๗2)ๆ๛œภC‡ข่ลE%ข้้…้ๅ/จCsฉƒแcwo๑8๚๒‹.X้NŠภN[oงอื\๐ศyฯ้ด ๙A(q!ไ๊ัใ[bž’๋65สe›๛ะk๕l-[+^฿ถqp'ำ|,์ว6ื|Ÿ๕mn ‹“ำ6—ยLbื/๖ฝ*ํสฮฝ™tœณ๛ุ“@tพๅฑ๙lz/๖#€ˆๆ๎c๓จMีๅ‰ทlป๙ี{n_ำ๎ผๅ—ใ๊9kVาช^ูc๏๙_BพI]ฆ‘t๛ีฺฆq๕%‘็๗๊ํN‚ H_`88>MDจอm‚Z–่้|฿ัDS์’›‘|VNฑG๓“ ฿ห–6ถฅE•ใ๏šธ๏*"‚@ƒz%‚ ‚ ‚ }…^#ƒ า]fJธ์B ‚ ‚าะAAA๚ ๕AA้+ิ@AAคฏPAAAพฬv”ษอ็ ัN*ํ‡L6:v๗aTโณะ๛'wจ‰FRวํมฃงaWญT๙qนาIaoไี๕’=ถฌ|ึJ|Kสฯ+Vbี… ่ค่ศ๐›งทM็Aa`8ฦ/sฝ‘๙๔ัE็c‰์c๖l‚€W~อ‘› O๛฿ฆ$„aŸ'กถ๓vH\ฤณว่ด แbB]?ฝCZaodBา๓ธฤ”ˆ๐ /K ัฏ"‚ ๑อJYˆ๙Hน= ”ฒR/Ÿ](ไปบ;n&ฆุ„ณ9~ู‚ Bžา›ฏ[O๙ฦ2#ฟงAœI`ฑลj.JU็วa{76j๙VpLๆufs5งอๅาa;ต3 C–)žŒ ฅ/ฃพ๎/{“๒‡๛ข"Œา฿>ฏยcYX n๘ส๗7hJM้{E`26า่BC0ธ‹8X:่bยใDI[ชrŠA๚'ๆผe๕Br!=ksกงฆz q2ซ^ฺญi๊ห๚=๔,š x†–#ซgี}\Nkเzt—๚ ‡ศ&–ษE–;ํkid™ฯ”1:vฮF?aหJจˆ:๋๔ถ9ต๛ r=—_)ล ฬฒ๐9ด>โ™ –Y"ศO"งฉ!โq‘wžฦ๚ฯ. ๒H,า–xr6ต๗Œณhมœ'๒๗ดวฬ-[G…žธ-ใ8บ=S}.ํaI3šษ ฏ[ฅ†B1px<‡pขsฌœMฺผถธ“Y% ศ แ’[ํไฐNqG}~‚<ฏF—ท`%ิ-อNไงQž฿8t่zztn_('Œy๛ถ•๋ใญฮ๘ๆู]q˜ัฯnr๏G฿กฑถ–ส฿๐ฑษภ66Q๋j€ูŠภะคำฅบ`0wq0๘D~ i)๎๎ ญ๐3Y๗ฤ…ธŸ? ฬฉoศŠIญX!9 €uEO3V(vPA #8ขยh๚8ˆdyฒOœช$๒if5 รื๋ †ณใ๒[๛›ิs=t#ณkพHCซIHอแำ# F ๙…0˜๒s๙‚๙็M`ข๗˜ษ$ต …:ฅ1:?cDๆ:œุณ@ค&ึึA1ƒu 6ล&๒ฝรอ‘;ีD๊“<๖๎ฝW@๏{žฃ7๙๛gภRŒฺs6พR ุแึ๛อLคU}]ฝSjป/hถpmœปญC@ ฿ี _ยJฏต˜›q๊bฺงKจe^๗ศMฟ๔qู9ีPz๓ฅา!฿]b~กM๋=Ž.ญ<ตu๏Ntนอฦmำล๓V{๖ฅธโ$nnmนtG}5mใ๓อซ]Md;ํeำœVช/ะ฿}ฏ ๅมQ†๑๑™ ๕•๗ณจ•ท,ทŒ ผฉgๆัŒ*ย@dxฎฒ~๐ร'##\W[ห.&‹&๊*+['()๑cbส3F๑ ฐIอ/ภ฿ฺุ@mะz๛RLคปi*ฯ฿v๏ห48E™ข์\ด-‘_KfๆeMล๓&็d็์ฒ ฿ฯญEฤะว]}Dฉ%ซ‡=ฑZc๘_๊8ซ๕ส8`฿‚าี็บŽึถg’–g๚“g…๒ส+=s฿6C^y†ผ๑•Rเึถฺ;๎๙st6œ|งใบYพcจ่ศล:xŸ :Z[žดฺ „žภ ฮมลๆ†mWื‡ึ‚แgแ<๚'ŸํSlห ov„Lจ?`ฮ!ณฤัy}ๅYK‹ธwจ๋‰|X,–ภ3t(ฆ5ฃUq˜@ๅ๓”;๎mษŒšV€่gฯ96 ไwPxaAภ›ฏค†B<"!ฟบม่‘ฆm3•:vฏผว7 ปf(จiูค/8แผ@pb๊ป=งลz๑› ๐2›ษ3@ฬ/๏ฮ3 โม3”้ึ>Ož<พ{ยRKš@ $Vžผใ๋วื฿rF3 H€วใ้4–ใ“๊ ข†ฆ”ต๔ถp–aศ,น๙W_•Srฃn>iึี‘T€[ษ๖ฺ}๊ฤฌ๛๖+๕7ŸNf{๛X4AŒ’‡Ž+ีๆ-Xจป|ืฌ&`;œƒ ํ฿4Zซ(ช™๛ึ0่T๖หษ๓Zฎฆ2SUU๗’€ใ)™o[5๙Nˆoโ"? ไ<ญํeยไท†ฒHซัฃขnA]‡3:Žว๗vนธ๋ะษd01˜ฎรoฯ“@ tลคัh<ก็‚z/๒ซŒญ'ฃจ$6LJ๔ฺŽฯ๒)ฒWšDž3$=(ํ“ฺP“Zc=k"$โํ/+tู๊`pecฒฝAฦ๊เUส็“ระc9ศ ihจ็2ค..ฮบบz€Yฮ[ภ+=รh฿ั=KŸoป๗ŽFฃ•2_๋๓ูีk:Žรแฺวbป_™ๆ‘VU’Zฮพ มฒ"๓žศคำ;ZL:ƒA"‘€WU„oลกบjeี) ห€žฯqหฬ]0แcrXRYฯอMPXดภDYคคเ๏@PHจ–ํ๐งบบ:7€ $QQพส7_ฝPฦlซŠOสu3ž๙h ๒๋ _]ฺe๙๒cD๙<รฏวF~u_ดu€Ÿฉ5ฏ,dMฯ๋ธx<žJ๋ๅ}ฯ“ม`~~ศคัh]SGฃ}yx๛ฦ"!ฟŽมธ้ฉ+ฏF๏ธ๚๗€ตผะ\]œrมๅv47@I๘ฒSgB–U‡:‹๚Ÿศเi๖88ษ7R€Vžzห๑z.@uV~ณฅป๙ˆก๘บศ“G>@C๐ัcrŽ๎มfธๆ๒D—6จ>{}ฎ‹็ƒ5๙ืmฏวฌ4้สทถ(งข^ธ)งฌ“ ฟบ๔_€ƒี๙C่ตE‰ง(ะŠ€มoไ`QI?ฐ!ฏ๔!‹'+ฃj ภp.:M^ิ๐ฤZู. ฆ ณดVจ)ณดใไuTq๗ปฌฃ๓ƒUCš)้{ฑ™ผช|๗นŠู_3ล}ศ|tเ`เ่6@`‚9dŸา1นN€1ๆ ๆLjำ‡RฒฟำqrŸVA~ฉcvd๊?พl๋€Suั์ืบO W๐ุ;ูฬ๒J˜8gk้‹;ถ.d&ฐoมX้kžอOฮปk8น=0 6๘่น๏oไงWผ๔ทsNํˆษ3sื…'ฎ\อ%ฯoูธคกูภ~gŽO3สj๓๊>๎๋”ภ๒ƒ-ัำ ูฅ@bูาฦถดจr|e~/๙jเั9โ?็ษ๋๐ๆ_:ฯ)6แ–U&ํ4!ฟŸ/Rh๖,AA฿฿<ษqcฑ๓๐}๒D(่้wAA฿T3ํฟAž้nšฦƒœ%๒๓ ๛‚ ‚ ‚๔๛ฺผ?ฒยz&๙Hฯ๒ณ‹€าŠ’{•%‚ ศ๗…๎? ‚ ‚ าWจ€ ‚ ‚ H_ก๒'™dš<.ฉ๓ฯuมรงุ„'t-:)าvpŒ_ๆz3 "1๒้ฃ‹ฮ+ฦ0’:n= ปjฅส‹๗‡่๙{ฒมzsGฬ฿sม7ฆŒ|vŽ[y ๙c#EGŽ,ฐฅ*งคL`ฮ[Vฏqf๑{๚ฒ}‰iฯอ!พา้_แ ๚fexูอg7อฑ|Xห2ญศrงฝcb-,๓™2Fวฮู่'lนS Qg6งv,'ืsฉ๑•Rผภ, ŸC๋#žนฝ`W"๙>ฤz{ฦcิŒ6{้ี๊บ็‹ะ‹ปิ@|B†žฒa๛๔lต%๋ฃŽ๎ฐ ญภJจ[8š/œศOฃ<ฟq่ะ๕๔`|๓์ฎ8ฬ่gท๎ ™ฟ…‹ q?˜S฿“ZฑBr$0‡วใpX`0':วสูคอk‹;™ล้2ˆฉ0?{–ถSœฃใ๙%คฅธป6ดTภ d`๑{Cฤษำd_™40า<ืช2™์ฮฃˆS•ไ_>0อฌฆd๘zมpโก[s=t#ณkพHCซIHอแำ#ฐ*:‚,ตฯ}ฝNพพZ&•szม’…็ฯ•์!๒{Cใ—ฟวด้œ7ฬดต]๒UืjIทถƒ\บฃพšถ๑๙ๆีฎ&ฒภ.@pิ„a|c&H}ํภาฏ?‰ˆ}p€ม8N€ ฯUึ`๘dd„๋jkก<๔ๆKฅCพปฤB›ึ{]Zyj;หฮย‹฿“ฝ›ƒŸŸŸ†k|๘๎ำง!tFฐฝ‚ย/ภ฿ฺุ@mะz๛RLคปi*ฯ฿v๏ห48E™ข์\ด-‘_RSEE=€ธธ๘ฯ.‚ ฟ=t๙รHs3z= ํฑฑํก-ฯ6dฅฝnแ €ิุq๏cฯd62 1<,ลูXV2kXqดช๓1-ชืI3ทvล5,`‡H๋:ท]ท๑F9ลgh-]ฌ9_mิ‡{Nล~ภ(œCf‰ฃ๓๚สณ–q๏฿๓๙ใ๔=Ybต9h€แP˜H5฿ฌs€K~ซ๛ ซล ;ฐ์ `บGCํ‹ญธฒi…G6›e6๕‹83๖N‹ฏ!‚|L&‹Eื (ิ@0ฅzyกโถ้f +OYHgsE‰] ิD=,๘ฺขฉ๕•ƒโ)wCฒW•(็Vฒฝ่ขZpใพ™ธฌ๗ํดqb๊บlๅ๓๓šพ\MU๐!ฯไ†ฌ๕฿ƒๅ๏ษซอ‘ LFJภํœ::ิ% )ผ>i<ˆg•š ํ#›ญUA6h/ฝ—eๅy-7พRŠ!Šช;\>ebพๆ"๊C ฟ ำั‰@ิ@N4ญไ–๙ZŸโฏดชฺุ–ด่ิ๒ถYŠk๏ทบฝใz6@๛1ชซVVาฐ ่๖ด-ฏ†๑e….[ ฎlLถ7ศXผJ๙|rmึํOฦ๊๗์ภ-3wม„ษaIeml6Gm]เำ้ฮ๎q–บบ:7€ $QQพส7oฟV8f[U|Rฎ๋œ๑$ศGc˜_—˜/@~Eลฯ.‚ ฟ=t๙;•ไๅ OS‘"Fฏุ๏พNŽศ.@ฺะษเOป\ฝdYK2cฑŽข0$$งง9&๓๕^>พถwo??ูญ;บ้฿kฏ‹ละจmT*`ฑ–y2€๖๙˜?,ษ ‰๑ใY ฌ~ฯv#W๏wsฐ?mป€ณ—อั–N1e-ษt2ปIญไค๔)๚ฦ“„99ง(ค?‹๊ ",ง„šา๘๊ ๊< ฟi+Lw:^ฐ™‡ฅฆ= EO#2P่๒wj>zLฮั=ุLื\ž่ใ’ฦ. ถ(งข^ธ)งŒีซšฃฮVฒsธ&Ljฉส|zะๅ~%€(`8&/๊Š๕ฤZู.ผนJย๏—:ฒฌ:ไะYึƒcช0‰V,z?*0/๚!‹ก`?, ห฿ ฆ ณดVจ)ณดใไๅๆ€ŠปŽงG์s๑.Hฏz๕ศ5ฌ=cน IDATŽ’ช|๗นŠู_3ล}ศ|tเ`เ่6@`‚9dŸา1นN€1ๆ ๆLjำ‡RฒฟำqrŸVA~!ีอJ•นQงฑปXˆฦ/!2PŽO3สj๓๊>ฎ๏๚' A>ำตO.ัำ น…A๋าv‰miQํlฅg้‘A>)J๎˜สตŠ‚R€ฦ/!‚ ‚ าwจ€ ‚ ‚ H_ก‚ ‚ ‚ }ล๖๙้žรsA kt;‚๔ฮ๖Ž_Pทษ‚ ?บ€ ‚ ‚ H_ก‚|+:}ีฆอF*’hnc„%ด‡ ‚ น~๗ˆา ๖x฿ ‹x๚ุ็ ‘l?gœb~uฝd—ฉฐ7าgญDS!,`G™|žํคาK ฟ–S7BbŸ<ผ้ผjBว ำ†L6:v๗aTโณะ๛'wจ‰๔’'กถ๓vH\ฤณว่&v}1เBLจ๋งy๖F&$=KL‰๒ฒิเช€๘f ฅ,ฤ|$€žJYฉ—ฮWS‘–_คPสL„?Š,ฑswr‘fภ…-g%eไผyํwxูH6ษg:ฅR>K^F ูt}น‡ฬw/jP^˜C~โณC๑gL}[%:ขbไศŠแใยาYม’ฬD‡ฝ’–ฮ“฿ฺี Ho ศฮ8งฯ฿๙Y1นธดดธœ๒lื่ฯR๖ยiๆ,.‚ ?อ_Z฿‡์:พx๋์า๔[๛N–Rฑ๛Wkj-๛๗!ฯง พKฑ๏C`ฑลj.JUฏq8ิmœU๓Oฌ[จov…บึmใ, 3ุป‘เgฆฅฒะะ9_ลe,ถ;Žศrงฝc’Œ4ต–[วทฒั๋ฆ"๊ฌ“๋•ฤ๎ฯีไz.UQš1ฅkแl‡๕ ^ฝvrš"ฃ็iŒ๘ฆไ•—Mf-ะVี?K$l[O‹๙ขE7 จึูsฮr๋๗G#ƒŒcแg6ซ >~๒Qๅ0ี›๗ึ๙๒๎ปw[์ํ่_ภงปgฟTาซหGN<คˆ)ปšฯfฝแJBO:;tพ™Fx}ฮู๙ ณw\-ฐูC>9พ๊`๐๛Q ๗ูรOแ†๎ใยRoใไโทร6.-)–-{{ซ๋ๅˆe!.ึึัตŸษfŽ”\y๙ฯ)$‚ H,AW`่โื#šึไํถุํX๚—ฤฑS˜_?ศg)์?ๅ&ฆ=ธ™YZ—{^ดเดiข คbๆ›๊๋ตMฑ๓J,VRรึ๛“๘ศgฮkKu- #2ืแ^hLิทฃpํ1%ิญฮ{๛ไ๑รkง๐ภงภปOโ#ยุชr}*฿<ป‘o๎ว `ตN3ทlzๆฅืX …๗}žฟkj, ฝย˜3g `Šขฯ]~XาLงึ^1$ฅ†ฒIMœช$๒มฬ๊ๆึš _ฏ3‰<Lฑ OHI}pmฃ"wฯ4ดš„ิ>Q1า@WLyน|b๓ๆM`vžO )› Iฮ.x๓*๎ž‹hFR๛ภฝ๘Œ‚ŒศฝŠ๑ฺฏX—ผŽ{|qใจฎUšh์๚"ซฐ0+5ไ&n‰‘ย ล™ทO8]8เJ€เDูAธ‚|osฦญ‹;โ~> ๘ษห๗ภฌญa๛iๆ‡คคฤ่ะ€{wษ๏huตภ,Ky๐ ๔U5@mM-๋ณ๎สธ๋^^๓ ฮขิค๕๒๚Ÿ—_Z๋= !3์ฮญ‹Aน#ค๚}‹u`ฐœ‚ะิย่ ™b—L)K?ดtแก‡้๙Y‰ื7Mภภ์ใูe”…หO={๗&ฮk™$€’ู๙ไ์‚7 ๗NhWHษ๔3๓๓ฒRžY7ฉฯ็โyƒGŽ,ๆยqฦŽ.!บ3ฅ—QJ’ฯํV็้5๙x‹JYดฌุฆ๛J…f. €•ิ:x76#'‹~มt:_{\฿ผ“ktฅ็fEŸีึฏr"'ึตƒๅa‚u•aIˆƒ๏œ„d–ดtถค„ฑณ๕ฌ\lช!‹ฅ๗ƒฏxพ0ฮP‰—#FฤsทWUfศา+EtฌdํโSงฑ‰ษฆrq+l๑yš–_”๓"๔œล$v ๊;6๕ๅาY.‹็:(6๕ˆiรDM9พmL>v"ท ๐a^<๘6H,ZE–๛RG 2๔๐%ZQ๔ปwพฌ๙,”ี)‡เ:ฟฯ๎‡{h่F? ฅ์๎๚กรท…PสฒOhฐ91f|ฤ๓>ฒืศม๋D๔๓ทๆ็็oml่ธ˜ฤL8คณ๕f`ๅ7;*e8ฌšฏiโำฐฤฮXxYษพr1าXฐฬ:Aฦ๎฿'ŽRบkGFฺฎ[ํ๐|ดี?jเึถqKwิWำ6>฿ผฺีDฺํeำœVช/ะ฿}ฏ€๖ฉ‚ฃ& ใใ3A M9ั?X้ตs3N]Lk๋5Ÿˆ๓ึ)฿ทD๚mU•ฐˆ”Ex#7`rำว5f็TณIฮ/ะmiHฝ})ฆ า4•gศoป๗eœ€ข‚LQvn๋7ฏ[w™™o”5๕ฯ›œ“คy๛}์๓ฤท~๋ วm8uv‹ ภE๛ฮฃย™~ฮูansGา๊Hw+k+๏ไฯ~!ั5..K๙_y;น„ิMะq:l" %WgฉhŒ‚ธ†สxF]]ใ ”๙ŠทQ๛ฏ๒ู%%F_\Zํนfู‘ดขใ4ใใใŸgพyแฟk:@ำฃz;-BS|–U{ฏ[~˜ŸฅณCCเย#&7N นน\ฉม( b?:~h๚ ‚:ๆฟ๐OgHi์5ํ:ฌ ื[ฏw็มk์ศ%๔GIร๑’b๑kฎ'ย๊'๗wIรัว^wX๑อรG๎SF.?|v{ฟ๎3ำ๊u 'พoฆ7ฝ/,/คxั ู~สp ‰e>_ฝี}bถฤp5ทฬส ห$$†KH,๐(ๅRอ•'ศiŸธูs็ิฮ่œสช\+ๅง[gฯ3[ึ๛ C้๔eํ`y˜h๗E•a รต_TPOฝQ]ใG#,*bNึ•‹ežฝ,ฝฯ898น๊*ง–พฯๆโ[NึUฆ้Yh$๕9ผ’๊๊<แOศlbถ็๙eๅถฮ๙_๚ฅำๅTŽ$Ÿญภ ฝ%๏ึ๕ๅาY.ป\HxZ๋;ๅโญZฦa-@ˆฤsTbxุPnfำ๛e•7ilโฑoYทด฿Œๅ)Gc‚—•ต••ต•๕ษˆwิbจJˆ/P˜1ภญฌ8Z##โ้ฌ3m๓ฎ(›พ‰‡[$jธ˜"‹ นืฯ'1ะฝ๋Bomฆ๋›bššฺ &๑Eฑ\๛ฅiษ1cFป“฿ตผพ๋j? ำัU)>u)ฆ  โีTB Rj์ธ๗ฑg2ะ–โl,+™5#ฦw2ฃ– PX@้vธ.ผใhU1ๆcZšเฐ_›ถ]]Z †ฝฦใ ‘h4Ad๔)\ผิR*‘ิy[€Gไณ}Šmนม๛อŽูีฑฮ=„[๗hจฝ"`ฑW6ญ๐ศf{ดฉ_๔ภ˜๙ทwZไำz๕Pหตฦz'‘์wcX%ฏภ 5๎๛ฦฤ‘ kฬSœ>ไ์+ู‰\Pใ๗?7ŸRฌํ๊โMูก7ณaฎ‚ำๆn1k,๕ฒp…‰9ีR<+WN’P’šX์ดtš(พ:ษํD๊?8oƒ6Ÿฒ๎ฟ^งJญบZศ๊ย๛0็-ฅ€ใ™dh๛ฏบฅญม•ทFZ{[L๓ตTภเภžณง‹t–๛ไ๗yเห=F™ไšภ๛ศv]ค]น/D~7^|zอปhภฯภเฐํืVjนYนวs•ซlQา—่HP์jๆีฐV=“i<0J^jฏ{๒ŽๆฎŸe่ฎ1]A่๒ |P{์A๏hLbCD1Ž08๛o5jโฤชง.i hx่sส|Šค}hN๐ป—žœึฬ‰ฎ*!}๓eํ`y˜hฏศ_T™qซvteAฮ‡#จ Xจmจ;X฿Œia0ธ๑E€a]น2Xๅษz้;วiniผGeด&ท291ภฆสิ? {พ_]…p็1ฯ5ษง“์bฐจ\X,–ภ'*ย‡)ส~vัโY๛’ู& Kgน ย$"=ผฆต พฉ1F˜ าุœDณยu@\Hฑฅดผ6สึŒbู*๔—z!U,O9ฺ๒ยoๆp*์}เ"\ฝ๗ŸำY˜ฤ„X3cบ,„ Už‰ฃ%<‹laŸ/#ซฑzySรb~!GaQ&ญิeภ-๚—‡ภฮว[ฝ‰ณ{ฦJ€๎GZ หd0ธdW9๎ี—!ะhQHj’@ ะhg™Mนัั‰่ดŽMKงำ1l{L‰•'๏,คŽณน"ƒx<พ+ๆ็๊ ข~บพทD๏๋ศ"A!•Lฅƒl๗–๕ตตญ ‡ร5=ฑQภณOmํ์ผ5๘๏š๑€ภ3Bk฿ gฬๆ=$Uฟ|ืาhญ๒ถA{้ิžั:ๅy-7พRŠ!Šช;\>ebพๆํ$Vyw฿๛ๆN พ‰‹ธucแำุZMD"@`•๗๋%4 rภ.. ๐];hoS -ี#ศAเไ๘ภOๅ฿f ฑ*ี๐>๏หณ๊™hWฺw†…‰!…าคธ้ๆ๊หว]=ึA% คUUิทoีๆ‚ธฮ†โaญยFu#้R ธ|๕(B๎qฯkมo ImวีฦKวพฯอnA}W~ฯb๛ญJ้ๅŽ';๙N%หโฑŒอm1ฝgาK๋ีฮ)‡rpŒ Hคทwฐ|๗ฅˆป0L&่t:`1W~จT*P.ฏำฺใ;รจ4*H$ ’บ™ฏn;ผ๊S!Uฟ๏[ˆ‚ิ†หQKi@เ๚XBrธc้C๎Ÿ๛c๎ž5ˆ/๖ฯ/kหรDป/ชฬL#e๚็Hศฬ;u8ฒš@e2€ูึเะ~พ[=๚TนXๆ9~1ซฅw๔๚Yใh•ํC”YW™wกao,ิg`"Dิๅขci์cvำUนJฏุ”qpyh>ŒZไแไ —ฺk๒มh.บ–ฮrAo":\Ÿ .๕Eท‹}Y:ม1€่ํJหVq ป–๖›ฑ<ๅภˆ/uฟดcๅ†๑ึ+…t`>Oคฎัž1Ctผจ3๕้ณ†ฏไม`ˆภ0ปญ๊77 _๖บฝ6Žีแ“ค]Oโๆ!Pฃโบ>gํๆงsvฎ่ฅท2ช!d่(ื•Fฃแpwrฐ\‚ุ†ฌฯ$i4Zษ-๓ต>ล้t๚งไุ๎[„GZUmlKZtjy ๔0—’5S&~%zmวg๙ู‹+W\(n™น &|LK*kจ{๗7TxH{%,,๒๖mฯอ9Cาƒา1ฉ E1ฉ5ึณ&ย~–ฟูีา[LV_^ณXy ฃUถบ{Y“ฐ์rีW’๗ฅ๐=๊{฿ืˆIcRฯW–Ÿfsก๒kK๘ๅฝต ๛ฐ!jซi`{๏‚eซุํ๛O๛“ษ์๘ˆf๗จ([ฌO98&๏๖9ฑ˜+ๅะ*ปศฮ‡Zศ -?c‰๚0ixyใู๛2ฦNๆ8(ภ+ว่๙ถาใ๓1ธ฿p่~?ะ๚๒E–ผฺ‰‚œ$ัzหีาำ฿‡็ย‰าP9]E‘ๆกร%yˆX(อหUี™:”D"ญ็๊H›ํC5%yyยำTคHคั+๖ปฏ“#ฅดT\q๎8!ก‘ืซtซ%m่ไ~๐€ง.v๙!=ez๊ส+ฯWž!ฏฌu„d5ฃฝ๓0r๕~7๛ำถ 8c2ŸGEั_?Uhทคๆj-|dd.]Zbล$,`9%gฯ”)+-cณ VrR๚}ใIยœœ‚SŒ าŸEญG XN 5ฅ๑ี”A A$b‹"o๙&W‰ํ)_ิฟยผ9eื๕๓๓0™J‚Šฒ2๐kํtฑ?|z๓”ŽคCฦ/4Zm4Gภ?y‘‘ัjี,ฟฤˆ1J ง๑5ถ๒(mุฎ.&((@šalบอิt›ฉ้ถu*b์‹„ šึไธ็tด‡๖˜šูญอตฯ_€ˆœผ8€$;e< ๅี๋.ฅ๖๏ธษษ|แจKIษƒฬ—้TmhŸูท]Zœะ@&๗gฐซ=คž‰ZFkM๖˜-FQ๑๗ŸNฃSญ5โ์y\LภŸ;Kำพ๏DoIถ-‘5ูB–์๛๚ZJEษRส‹Hd็ ?o๖ฅ•ะขล’DJJฅ}ีิฬt๏๏ฉ$๗fาf9฿ฯ1sๆ9็<็นฯ9๗ž{66๛ ›„อษ" vuH _๐๗’ev †dผ-&Ÿ๚&ฆค'ฌณ[ฑjืb=€ฌ˜7๙:บค'ฌฑbูืำ'ฯ›฿ฝษ‘6 7#CzศX=U9%MuE$วว+3า๎ฑิอc€๖&๑ัธv&‡[ƒดจิII{yล“Š ๓™yๅ"ฅ…นS$JQeาซ 7/๗๐qyำ’฿€i-=่8o˜ฆ‚ท('งธ†ฦพ๊ๆ7๕]๐qในŒa"Laa!ษฃJR›9Pย)฿‘1&ฏผ\D๎~g•…TนSทŠ})??@fย'วณว—Q,˜แร๘k”๙<๓ฉe@m˜น๙ผษ}ฅษ9Xร.l้หส ~\<ะlžน๙arย#RฉฟvY_H~๔๘uNB๋TีศŠไ”ๆdไฌไฒฉEงน' e^้ชfท๛ฺJzIjไน๗O฿0ด๕ ด,ˆพ๊ธ๕Ÿฉ๛=`ั2O฿ƒ๛{๏ธคภ,~rŸ7eฯจฬ๗ ‹ฮ.W฿u2tvfค‡s">๛ฟ<ฺ๙ฤ๙/\5[Z/]œš]ชP‘ั๔2`„€%วฅหUฤฅื=ผณ๏฿ญํ`ใ้/ฯK‹ธh๕o<P๙ไิ!ร=ฎ^ $๙ำ‹sฮW)_TไนOลึ๎K•่…q๗๗์๕.€~ึงฬ๘งผ#6ภ{7“ฅ—ณ@kƒwฤ‚[Q˜}วแPณVฒRR?Dฬชํ?T?ฺตx/c็’gงฑุูฑŽzฝd็๎a๗V๔ซ}oูY…‰ฎdGmqูั”ฦYบŒ฿ต7žwุ}ห*๗ƒon์™5๙ŽนญSสร@eฬz๛1ตนๆœ{๕ฟฐœV)ข)ฒ=-ึตฯj๊kผ ๑ฝN๘oDฒยข?w๋Q๚(š฿4${Xุiํ]3zรN#n^ขทณƒรรJ€ถn๊ถฯb๒B+=๓GฟรฮŽ~•อศิC*วnqรญ๘œyลz‡็wวฺLvเb[c)v๒}วmGฉV™ณvฏpต`ก X:?|๋i๎๘@ ่0ฤ.t84U•๓ฦวสโ๘vZ๊? ฤ๏EŒ๓U็ŽV๘)AตัZtจ/•Zญ}ซฃ2h๖๚i@ ๑ƒฦˆฆ““ํhฟ……T'ดท;๏™4๗Ÿp*๖Oจขฃ๘ฅแWฉqคtฌ๒ฟดฺ้6@ @ ‚‚๚๑GCS4gลJ๓แjh<@ P€35ญำ๎1cŸงื“ศ G๗ฯ;ฮ๊ฮ฿v_จ๋ธm็nF๙_tž“€ฉ™ธ{Qภฅญาญ’/๑5บ6aฯขยžGG<‹ {ๅฑจ3@+> ไw๋ะZ}y@ฎˆ๘็šš•‘••‘••๒แ๕ให๖;ื5ŠSl]vน8อ๋›Hฌ™็ณฒ2nีะาŒญˆผฺ“๗ย฿&%ฝztiวธNdไ๑Ÿ!/ณjถ๎ใท^ญŸํ๓ฌŒ'6สดีL7ฮ55+#ิฆ7ภ่ƒI๕฿TVษสส๐๐€ฮถˆฌŒ๔“&อˆ_฿Xeฆ$D?๔๘[Oฒm1-ฉ๏rใ๖๘ว$ฅ&„_ZึใปฝšฺยKงgจ6}_ซ49rำฌ6ศ=ฒž6r,หห-Sๅ@ลฬaฃ‚Ÿตฉแ8S›็]^1N:ฉฐษxoโคz aI)tˆ(ข‰?vธภu7 OLฎ7p้ฅ P6sฐ่d;หh๒ขRF8o%†\๑‡R๘๔ฌฃใ‘[ฉrFk๏Qyฮนฐtุxcำฃ‰mœขี4v๒ฐ›ึญ๘๑๙Sท’ฅวฎ;ฑ๖ฏ฿ฑค๙qt๋่๙š rฺัqฏใู0Š3?:cบ1๊๚Cั๓ฺฒuฏoฦ„ํ๛W๖heZ‡–ี๗ASt{ถm๖๖X3#LFoพ๙ ๊ž’ศ ํ๎ญ5ษๅฆ>Mƒ*9๑จ๛ ฅNQ|่ห์ฮj„๚์๕ๆํไ2ง่๕‰–๗Š €ฮ`ะ้4ภq +ฒ9zlY๏–ŸาŽ@4…Pฟ}๘\PRลฮ{qห?{เ mไŠˆ?”โจ›'Oบmwบ“ฌฝ5Am_VFVฺป๐€็—iิIajฦ{n„ว~LŽ ฺฎื0บึา+1ษ"งส77#q่}FVจอ„™n฿%};9C @n่บ3~ฯ฿'ˆธํ2ทง0S{ฮAŸgqŸ23ฒฒา322ฒ<็‰‘G๊ฝศU|JJKฟำ+ˆ@o›เฌค#ห—^‰:=k๘๒›ฑฑ7—k4W๙_ƒาแนcำ>;‹ณo@dฤ่ก 2{’„ยJ$๖„ฺw๐ใ†Zx•”}kณฎ0ดŠ‡Tไ„]>y๒ิI฿x.@ั‹๋'Ož:y๋uYํŸา#ถ฿z•๔ลีต:B@้ษ๚๋N๛=Ÿแmุ gำnLr{R˜N~๘ฆ ฏ>$วฟ พๅถัPต๎ัฌ%๖$M“LO๒ต0๗v'tFK)ำ“จ;^๙b6ั2”ล\ปr' k5สl:า๚^[7งOpบ๓1>๒๒ŠžŒ๚ ซ ธ<๖+๓ฯ•U*ฏ"Šป™ธๅะท0ซœ"+ฅ)‡ฮฎ๏ษแพV๛วษQ*ี*‡ุsฌ๎ๆ`Ršš %ลลาาา•ขฝฤํ๘*M ๗ORำaรmฮX—yตํ&วKQโ}{Jเ?Z`Oา4I๕$-Q soWโโ>่5<ฆoย๛$ .&yหSXLBYG[๐ฤฤไ+FSึw5Y2ฎภ๋N ลh๛Z#๒ูIูwึ๎ู_ทwฟ%Qฏ7?i,œL’ูcํ9ืฉJu?ฑNณŽ^กIฑ0ฎตฆL ฉ žบvฯั[w7I฿8z็˜๐€\•&“อ๗ผ้eทuฒ@vเ๓3-๎w^บXฒฅลลwT ขีภ ั> Cฎˆ๘Cก‹หซจช๋ฌ• ๏=ฏx}ไ5ฺ๊ซท(œ:เqๅๆ›เแWŽ„?๕:q๛ms3โ“๋ปฯ๎ุ้พฤ%ฤACw€4๛Ÿt:{j็ฟ‘€ฉ ผ๗ม2ชสr?ฅฆฐ%tg’อ/วIฃyYN›ตhหaณฎ^ ]บtๆ‹q"nžŽส†šฐknฯ2˜LF3•ล ŠScฤ|,เ‘ฺ( ๒m •=J์ฐธ๓/๒rาญโ!ฟ Uฯ]—ฏiu>€ฉ  S๚ญ'KBQ่ํ›กO.๘Dฃท 1r$5CZZ€!*-R๏}h๙ŠS ตดภžคi’๊IZขๆฎไ„=อ0ดฺ4$๚i8ฟGFUL๒–4ึy%&ผัFั๑ฎ็Zn4า’fŠHT6~S๐รสjˆ)ฉ+ˆTฆ ฑH์)8ธ4•=y^็ึ:๒ซPUPPภช/;Ÿo<™ 3็์ป)<1QQภ%H์Ij:ฎฟ‹๕5ีํฆ–'FZUŸžZท๒d4@@{ฤ7๗8‚ญžh3Y=-ไ฿ณื›˜—ัใยsฬrๆ[บ] ชํ<@qI  jjj@าศ๎Yมกีป฿๖4๋๛n๖ัูs๔ัŽˆถฅคค„%&V;ฌ'..^\\Œ\๑‡’ํeฟxั™“ Žฒ (คยq€ษd“มl๘H‹ณW;บขฟHK2"8ฅฅๅี5ภแp๋2b0ภๅ๒@หZโ่.]ตu f๏ผ—^ไัY“ฌอืIv›=a์ยsพ_vม•(*.‘‘่ผเB๘ำ`G#Œิžำ {ถ†‡|ํษEึcวŽ;rุภƒW]+$ท'น้x ื,Mt{้Ž™ฟ๓AaW#อ“k‡ฒ็็ฯŸdde1Qyy€‚‚๒4ษ๔$/‘เนw<,กทnถl#Sˆ฿_n1ฟฆ*๋๓ศ๋ทร‹Ajเ€Ÿrฎi}o๐]}็๒๛ SPจ]ทา๏‹G๚ญ˜ถ5}ไ฿ฆkผ˜ 6ฯny9[ใ‘IRJŠ“ŸW๚u '&*nำดy_Jั=Q-ๆย{(ญ:ธ"ˆอฦA†ีpธ.hดฆ฿!-ฅ๚Mtฆ)ณตž฿ฮ`๕1งํ‘ฅ\ไŠˆ?‘สิ็฿}๙-ึcย4]9mM€t฿Iๆๆายฎ>อฮศภaุฤMฮ%“”G๗k›fฐh‹ษH zฅw๎๕ณfeDJ๊›˜R˜>a‡R3๔ฒbไฐูะีะ|VI‡จฉ.N‹ •QE›Fgะ€%ญฺUk่ RๅีC—ฌ7ผD™Y3”ˆ/]d<ฯม…ธbะผพP4ไ9/•Mbฯq‚&‰‘ู3๑)™hkxศoEr๔ซR00fT๏J๖€ฅึำEno]pœิžืศL'9ใฬฝูืฝ#‹€WP–—วwyม์™Qผf†้ฎ“œg’cGaDrฤณ|๒4ษ๔t งJ๗WนšBBดิ +ฉŒ๙(’๓u|‰อ ้2a‚,เaŸาE็fBZ฿ก7H _๐๗’ž*3‡dผ-†|ต œ8‹๛Lจ] แยัง๓rู ‹aP‘—Vศ:M \›ค5ฦ0ภD&ŽxQ๗q ูืwอ๋|๋ฑ๏E๋ฟ"์\Jชูl -๐v†๑1?๛~^ฯน฿Iœƒ"^DŸ2“ำฺเ๑"๚าb5ศบถ๓h๘๎๙^ถ๋a็๚ธน"ฒฃถธtY9D@iœฅ‹หมล้Pp๗ฐ๛๓<ั>cตŸ}ู@Œ(จฎL}ั:‹ ูปWธ๘ๅu[hg=Y๎รM•ฎฏ฿8,2ฮสๅุฑฃ๎'N_พฐญ?i฿ž}฿mo`zU๎‹]˜5yวƒšSJQfึฺสw,%>ถ+๛$oผvํ๒ ำฌฎd“S`ชศ์Iพ๙JปyศฏB๕ฃ]‹๗๚”y๖แ%7ผ^ฒISŽิt5o|ผ z™m9p๊˜ๅภ"oงeNมม์Y่ธ๊ฐ฿'ฉQ๓อ๚ย›kึxGงIฆ'uบฟสีฌŸฆวโ๗šWLPปลeฮๅ9‘Wฌwxๆตฝยอ‡ดพ&;pฑํณ.™๗7} }ห๕\ฬg‰พ†jฯžืF/หหeฤ>๔ื฿อ๒พg๎&ตX)LXXธ‡ทฑไิฅMH#ศ”i&>^พํœฉœœl;็ˆ๘ (,ฤฟค-ํำช*ƒญ๑‹ๆ&P…๋kฬEs@ธ็ฦ‹š'oํพเjEG+†@ ?lŸ?Xว๒0๋gัส)3ปŸิ_>็•ฯณ๔†45บIก)฿๘YH๓ป่eb1้Xะl&5์ผ„ป\ผQ็@ ฺ ๎ง0/Š5€๚๘Yเ&xฎ๏ูัZ ฤฯMŒ๓U็ฬฟตฮ@ @ ฟ?”ใฤDใ๖ิ ๓kbใ„6ง้‰์@ ~odบ฿j Š’:r'ศฌฌo…Uีฮ฿@ @ ‚ƒ๚@ BPP๑;1`{ฬ‡F฿,)ชอ‹#cฦ>Oฏ'‘A๎Ÿwœี] Ÿu`ฤณจฐฺOอ`Lอไภ๛.m5a ‘ิฟ฿ำ๋Iฤฃทญ*ว๋k๎r^pไcGฉศ—ฤคuWน็๗๔แ=Oว9=E›H“ฎ:rห‰ซ~aO?8ฟวด›PgŸ ๕฿g,Y๗{ภ๖ ˆgQa‘/ž๚œด4Rj“ึI๖Yw้qˆร๐&iชใทž๓๑ y่ytอ ๊:nน›มA็๖d€าG๗ิCjO๒4ˆถF}ๅ%_ซ~฿—kค๕hK=ฃ"๊รIช y;฿ˆB7 |ฬ‚๚y2DO'|‘บฯ>m%NFSVย” #u&•&๔Žโใ|๚๖P' โฝ{€ั0ฎgิ…ฦL ขŸnไ‚ฺz4UpIมA๛/!ญ…4ซ rึN[’Bืœw๐฿-Sƒึ,€ไ33็ŸO"ืy์L๕€Mฦฑsf่y๊ฯaI)ผด„C’$/ใี|u„F?O‡้Š++h+ฑVๅ&|๕_"0!ฏDgีy๘๑Sd2ปฯwpณแ,๛ ŠNณท/cZ6๑fถp฿5'ญ‰้Ž Z;|ตะ6Aฤภโ๘eoฆนวใคi*ฮtุฎ๕ิา๒#กi๎rฺฺ4bีตศ>๎ว~ู๐‡ฤำ]Lgศ ณ๐pZไ๑ๆ%8ง๎ฑ[8L่}L๎๗5LืษvŸฟ. ˆู์๐ํ%cฏผผSขbๆฐQมg“้บ Fฏ•๎วWŒ๓ณผ—๏m1๑ “Idˆตวฌ๘ ฐ'išmRNข-!ญ2|d&[ฬอช'ซ2ลTํ|‹่4W๏ ฅ฿œำ๖q-๙[5_Ce%ี้ฃ~c)ฝซ}e.D๔ุB”fˆ ืƒ€8 ๋2tจl'•› ฉ‡h.%ภ—˜*ัoก่ŒQ5—ิ@ˆ๊ฬsฐ_จืUธ๔cฤS'.…drhช†ป6L่-อหŠ๚ฯษ้rLิฎŸ ฃ€ๅๅU‹V^ฉKAjŒํE๛•ทl‹ฎกฬGEN<๊พwB) >๔e๖,ตNd๗‚:ƒAงำวฎ4jซใRฮษUฎัdี[Sำฅa†]งƒ Bาช๊]ฤ–U'gรฏ(xAFซป\ฬUŸไ2 ึ๗Iถ๙ mz…ฅ†œ~}/]์่ˆท๘๊.๒ž7ภศ(ๅ๖ธจ OฟuŒาrO KSจP7wืฦ}ๆฤ5่}Qฃ8ผขˆ— R&ส,€7อd'†๚ธ]๙0์กvำๅลล\้ฒJำส+ธๅ%ลกพ{ฝ๑Yš\†ผ>ฑภ€ `๑&Lsีlงgํำฉ์I–&)ฝ‰1z๐žKhHb๏"Aห„(ผHK๚D๔t"ช‡‰™ RPp—๖6กป(CK+ะฒวi—i )maบ฿Ž‘๖!S2U.—๗vธ๛ื†๕"l—ž~:ะฒภ๓/‹M#Šร\m์ฝาpั๑‡Ÿฬz>yีี|ะZ๏}ˆนc๊‘7-อ_Zoๅ^›ฉZฒbRย™๙๔็f[{•“7ชฌvฏ฿[–—}sŸใูลส๓Hขw[q๓ฦ๒ฎง^˜@ข๛ิEำAn๎‰;ฝvsฆูซ•ึ?Gุํ‰i„ษชซy ฑ๖Ž›จริCัคk^Iซ €๐Uซ5_ีี จชŒ ํ|ณ({‡}ฤสzโŠไKUฟูๅะฌw†‘Šฅฯทoฟ‘\Ca๙–jSB๏NtSฦ‡}๘๓pเื%>‘ŽรๆˆคCต6ˆ0{•้ง๎๗ ๑qBBK{\เ–[„หvฦ๒>’E\ฒ9 ๙Kˆ฿ฅ™ึK๐ซk'1xŠ^qqck{˜]ฆ#aฯทดWm ]ฏืf†ใMทHnะจสj๔์$%ญีณK“็วž˜cu7“าิT()ฎmญิ—]~๘$ฤพื™=ณตE2=฿ uบนY๙–ลb๗ƒำsึ“w‚Q’“Ss่PiSYฐ†ดŒ d<9y#บcJ๋ า.Ÿ๐@JQ‘ศฯซ๎ทะฮ)๊yนน ŠŠiJหHW——q๙?ส^^74bŒีฌปๆF!iบŒอิ๗‰mu-หใ๏?M) 0็ŠฅC๙๊AAAžFa๋œŸฐคฅฅyŒ๎‹น่ัฟ๓๖&]ฟz{$คทภœu๛R(จ์I–&˜:ฐฏa…‰ฎt,๖(๖ฎ W )‡iมว01SBŽPๅ%‚0]–ม๒S[bŸ? บŽR–“[DuๆLฤƒฎ๐ืd†ว“‰ซตuษP@exศKm=}qี!CลรBc[žนช้fณ"๗นF›w>9ำc…ตW9eฃบuปvิ๎YฃL–ษ7ูทRฃRž,zานYบ๚f'๓<ื ึีฌป่bž๐ภA"ญ36vhฐ`b€๒๐W=†๒‹ฉฌ7T๊ip Zห<ร‡4๘)CQeh๊ ,Fวบ]฿1&ฏ2Tํ|‹(}ๅ“ฝAืุŠํว ํ๑>#€N›๔r€ฦTSัหหM&ฎyฌfนl€าm~mHฌ„บ)Q์9b๊†ซ}X†๐yi๋†~hGฅ› ‰‡TB—๋M†S!q๒ธอlh๑Cฃั˜๒๒XๆวฐkŽaภ.ต ž‹+วก<0เ…ใข^2WิUปG~ุ‘ุb.@JrVƒืซ)ืvmอึช|ฝsp…TOœ>y์ธ‘…7๎|€ธS f41๕ฉ๖‡lf„-๛/3py ฐๆ”]Ž‹sŽ[Z„ๅ“ฯ Ayฮ๙ํก>ม5ฅyั๗^g‚HxฆG๏ิใ$๚๎^ท?š ฬb๑x<ฆข๖ ~ข’tฎ‹E‘&4ฤง๔ทำ-๛โŠY๎๏)คปญฝฒ ่LโใีM-~ญำrdฦmณา|bทไaณ์Kใฬ฿b€ ่อฐาdจ๎jืร['G}ทฎ#$:zส˜t๏9‰@eOฒ4นไูษ๐™ƒษWๅ๏กfะ๊–Šd๚aๅี™PBข”@~,h๗ hฯ0zOB$+jง=j^?{มfซLŠ /ฌœศfส๑็แงzŸน—\๐แี;|Myฯ+ ~ปEำ;Hl˜ž๊ำkฏฉšญež4|๚ะฬoLIo•ff–kbF“๎ำG ngQ4ช]บk็…‰-ชy%ผB[ขษ•'NYชจพ)l€๘ื๏ช„YPทQ0ำ๋‰่0=ี๋ั8@๊M‹9ฬ†ฑŠ(งษN0—siฑ1ฬญ ขฌ2฿ถ๓m–ไ‚ฅ๒ป[JD๏ๅx็8ฺ'๒7ค—R๎บ฿N((}[ญืI€าm~]ศญ$4„่ยล"_Œlั” ฐฐฌ๚ 04† 6$r@ฎฑ๘O Ž}ผบหpฃจNฦŠ €Nต๕ซเ’อ๕ฟ๑ๅ†}c๏ฑ.[ฌ<–)๑าข=zิ/• L&Sี์ศต < ‹ฐณcYภ`0jxค๓“J“ƒ๏}35ต1โCmฮ;dxw๎XX|ูŠ[š“];S>๋บ฿๛y52้ส†WKr๗ดดuฎฏ“๕‰็e-)๙Ÿ žvo—ู}'กv•ุฌ3‹t๋ ์ฮๆมw™]'๎<์ˆญPอแะ้๔Š‡ึ†$f1ธีT“pเงQ๎m5tm|ถืP<,$œน่b:&คdhมm้†๙็;ถ!6ฬd๔G/๋Wฉ8@ฆ็รๅ—Mt฿ฆฟ๐บšPR%ืR.๗ั†ปแ๔ม#๔?=9•]Ÿฬžคi>Q  ั8oฑŠ‰ P(|‰ก๎C‹ฉo œ`0ŸƒC“W๋๕ล"ไ‡jG>xI9“๔iปš๔\8+๚cO๛+^W”็F๏w~ @จ2™ฬ๚F•วใ1 ำ๚ า่฿%๛ฺ๊•oy!OำW้G —ฆq๏E pKsาK›Œ^kเšต๊>63กม$AZeH๙6[ตฉฦr2 e๒Nv9เkgภฐ฿tบ ‰•J‰n“ˆฬ 46ภทN$›จxCซjR‰ญ!84ใk*Ÿca/0:j8 ๖7!Cญพเ’‚ƒ๚ˆ฿‰ฒฒRQ11wQQ‘’’R€ส๘;Žซ๎SR}ฐ๙ฮƒฆGญน‘ฯใ๑าฎlXเ๑ีซฃšš:ฝv๘“FkุA—P7ูฝ๊uศหฬ†อฮืฬ1หu3ฒ๔jxรR1m+w๕๏ห๏๘ญ9 idwhFŠ๓jืฒู—=ท›;ฯwŽ™็ฟ็,ิ๖@ฆทษ0ึ3฿W +'W\\ ก5v”XŒฯ๋|‚[–๚ฒศjXoอฯฃห+ˆT€‚‚b^ีฺฤ’’–ธ€ ,%%ฉœy฿Sƒเไ†?K7ช >v่|4SˆจฉฉฝCิเ8‹ล(.)!พ6jjพb’ฎดKeโ๘A9q๏J0๕ู๖ำu‘erK๒๒Kqา’’๏ย`u›ตuกŽdฅงซ่ึ–“๛หhโแ &ชฯupป็„ํ๘ฆ๖๛””’โไ็5บฉsลO6ัSfฒไtฆีŠ{๗Jรฎุ๘ฟwe@ฃa5.‡ห๊cปแ\๐@ฏi N*อธ๎ยๆn฿บฐฟ KDีpฮ…W/฿ิจYฬ๊#Ašˆฺˆ!š้DTpฐ–้โrbโjc็Md%R$Y,ฆŸ้ข> ""ฒฬgˆy๒"šˆ๊ศก=>ggu๔b–’IEวŒWaัhโZ ต>&}เฤDล้N›ื]JXDY๖Dต˜่๚ูXส}tไใใพฌ#'ณ'išอDThฐz +ญซ)yoAnศdBAG›ํท@ฒK7E!S`๔vย๛ฺง‡ฌเjฝ•3~x*ฯ˜ &KF^AˆNงำ4]คjzR’าฐ๑ฝค…„• Fเ%%ๅS%J ?;Gฒฟฎฒด‚zg9๊Eฉ!ม5CWš xฮฯ“zcใ,๓น >{(+ฤ˜ชซ?XWฐฎฤัlŸญƒgK%ญ2คํ|[P -BU่t`ฉส*P’I!I~9 Hญ”†…nคlคlค฿„š็X@]็d)Iฌคั!ห8–tKห6๕Ÿ™‘D#Bˆ ":„ŠVTW.1Cผ฿\bภ,‚=ษ–€ฦฟี!๎{9ุ ’แeพผฒ๋r"ภ็๘ฦJKื ]ๅ%‰AG๖{@™๏A]ฎพ๋d่์ฬH็D|๖=~yด๓‰ป๓?^ถนjถด>โิ„์R…Š„ ชู.`"“ŽFOชxhฅo|๚Ÿกถ๖ P`Uๅฦ=ฺ๋|;ุฅงiท3Ž๙อ๘์็tœ|c,&ฉค‚–%ฅ฿K๚V2ไ ˜์๋Nฎฝv9#ฦฮŠ๑ๆTON2ใ๊ต@ุŸ?ฝ8็|5ุ๗๏ึvฐ๑๔—็ฅE\ด๚—b๓VศฝนsŸŠญ–*ั ใ๎๏ู๋] ๖_๐Žุ๏L–^ฮญ nEaz๔‡Cั-(J“่๏zxt:ฟ_๋๒b ”฿2zO$iเฟ;ผ์ทž๑-VSœy๔ภญ,ศพพ๋hืฮทึหึไพฝoท/ n*8ฃw/ญ”คฤ/.Hjฯทdi6นi๘จลP“ฅ‹ืuห฿bฬ‰Dี-ZN๙ƒฒ๙ร}ข์ดจ+ึฮฏ๋Œœ*ตjaฮƒญ๓›q๏lŠวg‰C5•ฏ<์l.ผ!mTK}๎ืูฝ๗๖2้š์7wl_Rพ ภ~xฦีศแภูBeQGmนCœ๗>ไฉ์าY‰{jื๖Sฬ_"ญ2d้‘U%าvพ)k ‚<|€>+1~ม‹ภ_ม’nBฏน๘()จ)‚kด ชี ไ—ฃฅ*pถ`]@"สฮแ๛E:\ค’v “2' F5…Xๆ,ทnz'ซฌ xiPฃ’l ˜ฐ๐—eผ%ง>จญlฤDใVHh1˜฿—)ำL|ผ|;Vขๅ4li๋yZUe ไ^ฟ6DO'ข๊-…๒๕3ขๅ๔ณดฬ]๚e“ข6Bhฌcเ๔g“6+Œฉฑ๒ดป๔ัI^ทmฎ฿มdBสฃฌ ]ฒ=๐Ošส๓S^Ž฿ ™nํด4ข(ฉ#;4YY$ชชต(4บIก๑@ ‚ย‰}โฟdใํGซน<ภKใ.์Œ๏`ฤฦํด}`Q};จฮœ—๑€๚hkฐxป_dขภ/Lฬฑ‹ฺ#ŸœวN ;ตGNS๑ภb่ƒŽVขƒ๘ /โญŸF @ ‚B9P?้@ ๘3กตษrd๛ ท๕K? @ AA@ !(อํ?๔ฑ๔x๖ฌ๎ณo<๊2`’}ึ]zโ0ผIฉ~ึ๕ื๗Yอเั4–zFE4]uไ–Wยž<~p~i7ก๚?:ฯ>๊ฟฯXฒ๎๗€ํAฯขย"_< ๔9iiค๔ฃลjH‡๚งา่ˆ >ฮcิž˜šษป๗\ฺj ~๊.๗˜ฑฯำ๋Idะฃ๛็gK8qN IDATuข–๊:nน›มA็๖dี5"A|๚!%{]{๙w่ีืžLษทต˜ส ค๕ช๘ชjSX “ึ]ๅ๖Ÿ฿ำ‡๗<็๔l๊(E›€ฮhอ…GแcดำŠคดz‰Z-M๙™gm‡ด๎f(_า์ฝ๙>ฟ"ท\k™ฦกŸuเฅลjญชF3๔P_yษืช_+&ฏ8๔๗๎˜ญ‡(tณ๘สษiŠDฯ๘hศ๏;ฝ๎m6˜2กคIลอUธแ|คั…๏จ๊„แQผw/"๚ฦ๕Œ:Hืใต\R`~ ษI;7gฮ™–œ๕„่:Ocทp˜ะ๛˜\„“ฯฬœ>๕p™ษ๓DณšNAqฆรvญง–ๆ– Ms—ำึฆซฎๅ@v๐q‡<๖ห†'ž˜พ่b:Cf˜…‡ำโ'ผธ<ิtœๆ{[L|ยไbํ1+พ๖@฿ฦ๖์]รRS€<#RHฃwZƒซ}คE>ฌ31l |pย๒ฅ DVj>jฦ“ๅ^ใ_wwl๚;|้ๅ,ี™็`ฟPฏซp้วˆ;งN\ ษไPดŠdi’BY0ลั๖‡ทW,z๊jcw๗NจสM=ๆ9+z๕โSi=V]9ฆzlฦ๎ะ2Š6Yอศj็ฺฑฝ่ลป๏AZญู่mลอหปœzaฮWlัลt๒bส _ทwty"็๕ƒvงž}†๏ebรlo์ค;š9FPู่Bสaฑฒžธb๚U&!ห:\ ‹ฐ ~เ“ึ[นืfช–ฌ˜”pEf>ในูึ^šึ–๖žYlฉX๚ฬ}๛๖ษ5#ํCฆdช6\.๏ํp๗ฏ ๋๛Eุ.=๖ื๏~‘A๏NtSฦ‡}T๙„R?H฿UWผยฒMpEUฌากZฤ˜=ˆส6>xฑต!+Qf %›Aซ ˆ $๒฿:cc็ &vqck{˜]ฆ#aฯทดPศj๔์$%ญีณหo|j‡RxiJน`ย๊ห.?|โ฿๋ฬžฺู"0š๚‹ัฑn็_“ฝ%‚ดŒtuy—ฃ์ๅีC3 ๆภXมบkn’ฦกห่ ะL}Ÿุ6>ํ๊ŸBz ฬYท/…ฒk7ถgฆฟ็›กN77+฿๒ฏX์~pzŽzาฮ‚„ุsฌ๎ๆ`Ršš %ลล‚าาา\†๐yi๋†~่0}ชตDฒ9ภ๘ƒฺrฯล็ํ่O๙กUQ|Sุ๑ฏ฿U ณ Kwํ‚งวโสq( xแธจ— ฤ‘ค\ต5[ซ๒u0๋hโN-˜๕?ะฤิงฺฒ™ถ์ฟLผa.็าbb˜dlฌถŸzะ฿Nhด์‹+fนฟง๎ถ๖Vศ* 3‰W7Y|l;?EGO“๎='‘‹ิž{ฬ…5ง์r\œsา",MiB*ƒ'NŸQHa€ ่อฐาdจ๎jืร['G}ท๎q็๋kิrฺย“G0ƒPะDีสJย,วc*j๊'*ษM็ ฑX฿ค๕=j’ +ฐขO @` NTP๘zฉHจB]ฌš†ล_">7Ir๑XD]‹"ั |€G๏5. $ลฑ’rฒŒT } ขแŠขดWแั๓ฐ๗‘xฟ (มžฝl๓ต>“'T๛nmา‘i4SB^^หvอ1์ห฿ดŠ‚งIEๆ}๗ห‘Ÿ>ฟ"Vฉษไ‘7ชฤง๋.^ำž9R“๏ฑ>Š ฉคš–V^ˆkt~ภป๋๛์b y จgใbโั‡Lืb(Š|๕ษV‡?nฺDFL56C#œฬ#สฉ๕c} @ˆโั^์ม่ฤ€ธ๊{Z&๙dฑาฬฬrM รรhา}๚จมํ,Hน๋~;ก ๔elต^'9€šืฯ^ฐูร*“"ร +'ฒ™rMฌ ๛…Btแb‘ฏFึ1^$บ 1ฌ‚4M ใAc(ม`C"ฺm—ึV€ชD-‘l๛ukกฮ ๘Vฺว๋@๚y๓&ๆ—g_]ป’ฏ/“ฉjvไฺะEุูฑ,ช@(Mพ๗e๊฿”i&?Z" >^พหrKsฒkจฌ๋~๏็uื(ธfญบอ๖L๘RปHฏ‘ODํkนทีpoะต๑ู^รฅฮ+้ไฬEำ1!%C๛ nK7ฬฯ๋ำ๒ู๋$๔ม#๔?=9•]๛“ฬž™teรฮซฅnน๛ Zฺว:ืืษ๚ฤ๓Vjsู ร๋ฟvวยโ จฝ‹แu5กคJ"ฎ๛ฅ\๎ฃ wร๙5บF-งฑ'Ÿoฟ>„ภ!…ERต๋๘ฺJีNฏxhm๘@bƒ[๔Pd“คจ}:“A๔า'h8€@ํl(‚ฦขฎK]๖๎หณ6} 1˜‰{ฐบ9„j+qe€ฮ’onŠตัฑ่ Ÿ<กฆผฉ่%มX•ม๖กœ๘ิZ%j)ด~“&–_–ฺคP๖ฝวบlฑ๒XฆฤK‹๗่QฟิฏฝคพUu๓ฆจฺdฏ๖rEbHH ๔ฌ/ฆhฏ9ปถ›j2y}7$ิ Fvฏz๒2ณ š๗ผ‹hโšฃว๗ฌ|๐,ƒ bผV๎๊฿—฿๐[ 4๕†*wRนฒ 6Ž๎‹^็อfK65ึฤ–ธ€ ,%%ฉœy฿ำ€เไ†?K7ช๋|“ืฝU{•-๒ฯ&้9hP้‹ซuc็d๖”4ฒ;4#ลyตkู์‹หžอŽ็;Gฬ๓€฿sj๋"l0ว,ือศา๋๛h#O..)!ฮฎฉ๙ฒrๅ๋kิj|๑d๘ุ^๓ัš0ˆ 4UตฟถRI~]^A  ๓๒šI ˜+Mh†$GZX#๑๊P ฏ!ฐบgl†@%๐ŸJkขฐ—ฅDษDๆ%ŒW'๙้-ๅปmL T‘ฬขŒ.;– ง‚B๔ VY็BmQ"าค†1dโ˜ ฟ๙_ๆ1ใ8Aงำ๙฿iดบ+ใ๏8ฎบLI๕มๆ;n›ตๆ๕\ฉoาAี . ิ*kเ’ฌท)CฯV{|9 ’ไ๑x_J$*+C++,็R๊‰ใฤ—bSก4eำ‚ส“ำฬ‚หpนน'ผuพ“๛มฎu…ซ๗o้mRM”จตฉ„F=t‚jœZyชลฐะEฃฌะ๔ZT@NDถเ๊ตฟ‰๑j๖Tั€% Pภ’†ชb+ƒศNว8๏๋฿A •d%โ#Jบ๏VX๐=ษะvาดค$…รปฐXfํv]จ#D >ืมu๏žถใฟณ) ขต๙k๎๖vGmฦืฮ1.ๆŠ žlขง ฬdษ้Lซ๗๎@‰ฉบ๚ƒu๕๋๊Oอ๖ู:˜ด๓ีัฯb๚™.๊ฃ ""ฯ|๖€˜ว!฿}ญNQ9ดว็์ฌ๖\ะfฉGG>>ฎ~])™=Kรฎุ๘ฟwe@ฃa5.‡หช›5œฏ?\ ฺ-ฐ†เฐ๑ฏ>UD3 ผฆ1x3I ")%ลษฯ#{Vn์ษœ˜จ8i๓บK ‹(๋ฯžจ]?ฎั5j5:ย“ฉ "MTํFV"ข‚ƒตL๗—W;o"#(จษ‰#ีŸ1ฆศศKXT๗`B@ว€& ชฺP# ข"€”gย‚ล†"ัืWiฐฎฟไ-Wะฎ›r^žฒฝ€@S!๚ฌ$คš9!—4:ึ‰่ั{๏NKฅฺ ถฏn‹ ”&%ฬa&ฃ>๘>lฐ}@NVfง!ฃปหษw›ฐe๙ ~L}ถฝลดA]d™’ผR ฉ้’฿ฆู,ฤUบศ2iL…Fซ>$UฃJื^d=โๅมีปG[ฐe2่‹T2=)Iษภคฟ<‹)ฆ>m฿'cฉฆ๔ฬฯฮ‘์o ซ,ญ YŽNก#ฮกK^gชž"[พณš„2#เฦžฺ๗ค๏ึ-โิzถ\ฌ(่4˜B ƒP‘วŠ2($L–Œผ‚Nงฟ๛๔'†…nค๑—฿„š็Xภ>ฌ‚ภ๒฿ว,ˆ๖'ThX^V<Ž%ลาZo<บ .‘˜!o.1`AždKh-ฃRๆ{ะEg—ซ๏::;3าร9‘CPœš]ชP‘ั‚!qDS่๏zxt:ฟ๙sy1ส๏nฝ'Š’ใา‹ๅ*โาkyุมงjkฟVUnฃฝฮทsจ%!๗ๆฮ}*ถv[ชD/Œปฟgฏw!4ุฌภ;bผw3Yz9 ด6xGl ธ…้ัwEท^iฟO[๙'ฃw/ญ”คฤ๚มAr{ฒ๙Cแiท3Ž๙อ๘์็tœ|81‹Jr?hฏภSH^T ˜rd&™เ$`€‰L:=ฉ>เก•พm ภทž ูืwํบำ๙ึzูšท๗ํ๖”ิั๘5ƒ๖d’Z|Š ค๕ช ๅ+ฑ๏฿ญํ`ใ้/ฯK‹ธh๕oำ›ทึDc }๑~;:K8Œe|&๚Œ%…แฝwฺฅXฺUZœฎท"`Yท1ฉนฤฐ}V…๗ฟž๓อ…ฤซุฐ๙„œ3VX Yท1)sะฐj( ค•7s$:]g์๛ดฯ(พ‰uZNศว`ีmU"าคBฤ`าˆw๗4œzŸ๏ํvyค๓ษ;ๆษท๗\ ž6ŸฏS|cฅฅ๋†ฎ๒Œ’ฤ #๛ฝศWSฅูวา์\Z๙;kj๗5"ญษฮ>_gy1@Eค:ี5็hศUฌำ<™'็Gฑ?ฟoฺก๕ร;„W6ฟฅพ๗๗ถ฿q5HY)ไ>๏*=ุฯธ9ธ;[จ,๊ศข-wHŸณ๎Ÿพah๋hY}ีq๋?S๗{ธมขežไ๑ฉ~s1๔ฺžzณœŸ‘ู๋Rไ็แ๔๙_‰๑C^๖๘ –๖&:7˜ D1–๕?,‡j|!ใูฯ๘ณณj*3^yุู\xำ Zfไย$ๆ๚{ <Kทnำ_นรE^"N6VYA๐าพผ+ ’l ˜ฐ๐—eผ%ฬ_B ~.ฆL3Aฟค-ํำช*aดBP$L๖฿๕pŠU`3๗k๏4‚_Eฯ๖Ahฌcเ๔g“6+Œฉฑ๒ดป๔ัI^wด^ฟrrฒํ“Qaaณ"ด+nRm7€@ ข-cา7์ฺฮV}€n‹4‚_Eฯv‚๛ฤษฦVsy€—ฦ]ุ฿ัJ!~P@ ˆ_‹’ป๋Œ๏iถฟŠžํEฮcง:Z ฤŸฦŸณก@ h)h@  —ibVฅ๐—Yะฦ@ „  ๑4ฅAsVฌ4ฎ†ฦๆค A ฤNซ๕0ษ>๋.=q%DZw•~O๓tœำS05“w๏? ธดี@บต๒E ๊QYy'++รoร_:"ฒ2าO~ศjึฬ๓YYท–*๐*Nฑuuุๅโ4๛ฏ6ี๑cL>‘••ั๐๓สa•ฌโ‹‹^พOIŒ{๙เ์F๚ํ๗ค†;…gfd…๖ฆฮgˆรหFe๙ญWใ'ศCฦนฆ๒2Sขzญ'ูJeI๙๛=ฝžDfม—๙้‰พVธั!|๔n\g8zKใ/ข6่>ส–่^฿ฆ‹šซpร๘H+ขK]ั%†์ฤวฦœ๐ฦิ รฃxoy”BDรธžQAPพ๑ฆัฯ 7rม m‰n=šŠ*ธคเดŠCvžบ็ไ๕[[T๒r Z;|<ผp‚้บ‹–๕คAงฑ3ี6๏Mœ4C ,)ีF'7"\tฦ)tcิ๕‡ข็\X:lผฑ้ั&OืEt|:ฬH%JJJศ%#lNXŒSJ๕t:่•ญnฒํดๅ0  ทป`?€ฝƒฦา8:๎u๔|อศ 9ํ่ธื๑lX1PxHรC[ถ๎๕-ะ˜ฐ}สVjCgีy๘ต-S 'อ฿๕ZwืfCฑfj˜ฎ“ํ>์ะQฦKฝ˜ห—Œ•€Nณท/cZ7q๘„นŽ‡;ฏ๖ๅF!3ูbžhV.…2ˆ@u’ฑ๊ร/›yvO’Qป)“ำi>>):pมŠก…nฃ…วDL๑NํfโAอŒ …ั‚ญhแื@~1!OPœI(dc‘;i/๚RB่<™`฿ฃ=ฑคมhใ %Q @ฎX7ก:ณ'€ิC4—J N‹๘dๆŠ,ส่‚K Nซ๔ŠC}Vm:๐DคFF)ท=ข๒+สำ=๐Qฃด€ €ฮ`ะ้4ภq +ฒ9zlY๏ึ(QN่–R3ฆ'QืK—ำ_wฺ๏๙๛ไoรn8›vc`jฦ{n„ว~LŽ ฺฎW+งถฦ/+#+ํ]xภƒ๓ห4๊๊ฝศU|JJKฟำ+ˆทw ฉ๏?พ]ฌุ ซ~z๖rนค๊_ eŸโฎv8wfฯลูฝ”@ด็ศegถบฝแำ9a—Ožษeœ๊ฯฑพOฒ าnN ”sซส*9^]^ม-/)ๆ–r๚ยฝ4v ท(:โ-ฎึEพ67แ!ซVk๘ป‘ีคNDO'\ฃกณ7๚๏oP{ภ+&G๔ˆvมGูšZตข˜,ัc>สฝƒP:๐nธPGใ€฿Aอxฒœฟ๏๋๚ƒf1ลั๖7Cƒฏ˜ฅมขu6ฒ9w๓Qฤc‡V–irpูดฝฝOอ4q๋ŸญึaMีp๋้Ÿ>|pŸ$šศHZoฅ๛m ว‘‘>ท|๎˜&ฮXฆ?ั๑ฦƒเเkฬ4่ิQ)฿ั๑‡Ÿ™[;6ฌต{s_Qy.ื๏‡>{์๋้ดbd'kHšš‘อูรƒ฿?cg…FU๖ฺb^$๐ฎ(4ค*๛ืJ‘ๅBสaŽั“ฟ มฒŸ— œt์sˆสQFoฅห๑KR‹ฅผ€8ก˜ D%€P๊้XuTพยฒ BQ€S5lภ ภู€Wa\~ฏ5ชตA @ชQ™‘i'$$ฑพ‡|ยr‹ูฮ‘—lญา(ผ4ฅซ0)EE"?ฏบ฿๒C;งจ็ๅๆ*(*Bฆฟ็›กN77+฿๒ฏX์~pzŽzื่๊ึะจ#.๎ƒXำษc๚&ผOึ˜ถ“%ž๎Xผ๚TŠ๖ทใซ4ฤ&ํ<ถ|ธHฬiGื{‰uว}rjต๕์sNร๔”ๆ;;O—~{ึมูฏคง‰ร?Kีท<RXFฏ๏ฯฬฝๆ~๊UxฺฅEร†Lฃแ=๐’’rH=e:lษ๙ุชฬ•ิCc ‹I(๋h+žุ่! m)ษษฉ๎9tจ4 €ฉฌ?XCZFฆ9sลาก|๕ํ  OฃฐuฮOุ๑ไไ่ Œ)ญ3Hป}DTš๚‹ัฑn็_[o่คฉnดเใ˜จ)ก@P™IH&ัยถำ"ฝAu !ƒจฬ"ค’ia6ดะณXyMm\•Y„T ํฉ -าบ.&คฺยnฟ Z' ๙?ˆญŸาะe๊‚ฟ‚lฮณ๊ถu๙H&ˆoฎต{ึ(“%G๒M๖ญิล่:JYNn=ึ™3=v{c บˆ[๋ฤ์2iผ่ {พฅฝ(3R5lVไ>wยจq๓ฮ'gzฌฐ๖โ?hL5ฝผdโšวj–หF0ฉ2ขR*รC^j๋้‹จ* J3ญ—เWืNcถ๑๘ฝ>โ“ฌl{ฝu67๚?{็ีัลแm๔ถ ‚X**b‰‚ฤ.๖[lฑล_+๖bWb41&จ1๖Žจ @+์จH‘—;๏Šจป) ™็ว๖์น็œ™;w๚ําv@๙SปhฉJปVw— ๏.ไะฅ฿๔#/sง> M๛(๕^Z’๏’ุOชฒต$"gzU“j้@–ฆ๊๊2๚9*'1gIB&@ ช ’’ hBBI–œึGMซ!3jz๖‘wใึ๐Nณ๑n;‰ษฉวRศ;95ิƒด‰{๖ESR(JJH:2ณฉด>ภ้Si ˆU•ลโk–„r[Pง&‘ศๅrQ5ซ6:ู๒lฑDD{/ึภŒณ5วŒาฺ7sฦž‡ฉEb0Jฤซณ๗mะีk9‚:ถอtเwจ฿ๅ๎AZทjก‰Z ญ5เ๕๛:ทฟ6ฝŸ{iฺฯ๖_y๑ม\zยฉ™}Žœพษํฯองžๆๆeัog”ญž#z๋!์่ย>จ™u๚iณ๛kปพ3‹ฟพ~“{ฉ๋ฅ%Pg๒ฉ็Ooํ่‡+‹งํzQZ?%€ต๚ํ:wƒsอ#AHI„ะ๏<ผfม้—œชดืฒช๋.81;;ๅีหจฮฐฒด[Žํ’o?ื๚*ผ—j–ดpพํB*๖'oUi•อฯQyฺั.[y‡กA€จฺ๕จฆ&x98THต๋ธGa<‚๊ๅLฯฤ=†ด5•f ฎ##_…ํ‡พโgWา'Ž}u๑jbฟq ‹๏|ุKžำ้ึิะ€H$ไ๒bฌบๅ๕š™9ีษา@Mคฎ คƒฃp?ๅjŽ;จ#โ™{G.%ฆ๒˜่ไœ_Uh=ํฤqqฬญฟ,s๗™วษ*F9•šนŽŠMไ‘?xc1`ษฆ•Gถฤถ๑เ”l//๓+‘อโม‡Y2่์*uฑ"#Ssเฮ‘ถด$BM{็/Nน ๅศ~ุ็lปํม H91ญๅI‘vญn‹7ญ ใ็zฅ6Ÿ๔ฃ…๛œy‘€๊eส 9ส A๓ึฉP8ส ๓/เ„0ฯืเ@ C’ ๅp6=บ%ŸZ@ค็Nใ( B8"‘(_(—หEB•๙)‰Lm9ิU@ žœฟผ๘cG|Tะ‹‹œ๚9-5&hํ๊[yršทj”๒4ว{‰‚WBผ฿ห‰ญšรึV็n) ๚ศส_องฯv[]ไทซ๋๙ะlˆDข=ํนฏo^Š>MปP(ฬš๖ะฃ3พ๓*˜[™ I@‚2๏ๅ‚t oำD\!๗Irr!Še๑sTfไฤ+ˆชQ๋qฎไM6xH&น7—0€ฯ$ิค ‰Mาx Žฤtๆ๋’Dค<&š“จฬ““ UO…}•ค฿ 7‰@… f?SBf๒ŠญY|สญ๛V`hค ค02ช๖๖m tœl์j๕ฤอ)ƒ๗Œฝฑ`p๐P๏์v๐๚ฯob—ย[uฦใว๑ƒฟงอผŸ~9ฒใ€L– $œv้Knญ*KŠC]žD"€Bง$=\6o|yn๏กดFs๚็šE‡ม(oHs{{1’ฏฟ—ฉ;ญ๓3ยXhCN[h9dœf์แัmงyซœ๖PFฟffิรok‹‡iฌ๎คeJlบ็sบ{n„ิทvถ—\๗ธ๓€Tš˜˜XกP$ฆ E๎ณDม๓‰ะถ์ไจyฯn,อN ๕ป•0^๏ZตฎajผวwDฎ_› 4pWhqใ$ผ‚’ผA/ยW ”/ฬ#ผ‚พ{ฅrด•‘‹๐n#ฮ,\K.— นCA!ร&rน<์ภ”nฏ‹rTฃ๗ {ฟ‘Žณ ฟณ Gy๐Zu;ti~ร๋zDPpŒŸ_์เึ ›ฺ>๐[’ป9๑‰N@คcัrุโ๕s๛žt$ถ`29 }.%.5[iฺ ล{MŽ’๖ไ7แJšํสผ—"#T!ฆๆm๑t>‰L/Jณ,~ŽสŠ:ช7ฆ‰7HEv ‰Oแ k‘7‘ษAขd€D™‰€ฟ+’RD@N){…่p"{า๔K%ใ3ัmIนง$!ฤฺVธฉฃบ-•?#q๏Šา,ๅึ!ฅท}|,๛j*ีิ2๋4ด›๐ส•็H๖_?n๊?SภqD!ห–egฟฟyŒฒA,ๆBฏ8zใXœ31๛2่N2๔šutดnุ๊๛๕วŽmำT‚่ˆzทzม/ฎใmr/ีฌ฿uุะaŽu…€^“ร† m[‹p!‰žI-หึ]›๋ฆfiท“C/—<€:-š๋ม๗๎CฌึุึXHฺิฯ๙ นดๅศ'๘ใคœ๔}›€E็‰“~ัูJ่6๔ใค1%ู์ฌฌ„ไ|ฃmmุˆ1s'w5๚บ"wแฉ52oึ๗M๕%๊&฿u5บs๋II„I/Bšv์b,แ8-หฎ–/B^ ‹๎ f lคอS7k๗mˆ๐เั๖ถv-mํZฺฺu[”แ>ซe :รf‰ ึ๚๓ธ๐ฎต๐๊๖]๊‰ีชทํะLขฒฑbิผนิธt๓๗ล* E}C#ฑ@ |๎3\y๐ต‡.]ทh๋œ.๊๏eQพ>Yญฦh์๊ตœFฑผhFŸๆข์คทฑษ<ภ็&ณญsSC‰Hำขฯšซบ๋ชJ{TxธqซVRimงŸFตั*<ํŸ {9 ฑœdูy@™•žš|Gอj#*5F๚;€’ุดfG*‘@ฃ)5ๆศ( คฆา๊ถเ„&ดš Rข๓W]˜Ÿฏ๖ดพ‹ ˜๋’„ˆ\นฆo3„6HEi–†ฒฉ˜ํ–\pํ›snธู ฉ'งwXxiํRซๅs๖{สร๖ฬ๛1deไฌH๓>ฑ๕ื๓ใฯฏ๚ญœ&U$’9wIn!๋โ’Q+…‹G/ณ$#:๘œ๋ฉ[ดญฝq:Y๛งQทอ]ภภq๚†…Mี;ฯะ?นzv๋J๏oฆOุถ‘e{žXดkV๏ๆา฿||™ิ1ˆmlฌ€ธ'O ถƒขฯลืซŸ้w1(gH‰ฦZิ1Wใอฎ;๘๔_ธฐONชo?a‘}๒'n>ลn๎+-!้Pญำ๔ ณำโ#ธ,_‘#็ั‡Wmnธdลษ๏43ข๎žป๊JZ‰„^xjัฌ็—j*C]ื‹p๙๗ห6ŸกƒŒ๘ื7wญ>X;ยฃŽa|ปฮเHฤO ๊ ฉ6Šo๋ˆืn$ถ -จ้เ ’…8o.•อP+EฝmvฯฎK(J/ูcฺฦKWซงˆพbŠ[*—.คxฌ฿ะxษfษ๚‚Œศ@ทีฯe*Eœ๙๓•‘๋ใŠ๔ˆ;n ๆ์พฏฬd ƒOx๙(›าŒ"ัฏWA[#BพอG)61ฬ`0 FๅBทฃsC‹หฟญฤ‘,๘ฒ็่ฉว/Nฬ–SP๐ษv/~\J›Œฯฆิ?ƒ๑9ฐ๙Fฅอ?0ชlม`0*lŸ<คช๎^ ƒม`0 ฃฌQน~ฉย:[ Fแ|ู๎ธTj๐ฝG0ฆIลิŒ&•ใeฤqqๅ๚R)ƒม`0พ$lม`0 ƒม`ึ`0 ƒม`0ล…๕U 9ืo๛฿ ธ~๚mท‘5@\ซ๓]G/\ปxุฦํ 3็u'ฯ^๔ฺ;ซญ™ม( ธ:c๖฿๐]ช็pณภ฿๊N*4อ&ร6>ใxษ๓๘–ŸWหุ๊_ปิๅ€‹็ŽmœิZJT9* 4ป๒ .—ฅ V๑ต>฿ ฐ6m:—wฺศ;ฮง฿X—:พ*ล๘ฝณm l\ผ๗Ž*ษป?Biฑ)รzฯVX‹ํจฮ9V๙$>}T…&Lฯ+:6น[›ฎCVผhณz’= ๑„ตC๙Cำ{;๔พไฎํ’išช.1D9ฮg6wํ GQC๖”+{”›"0้ัไยน[ๅ6ภ๒pTaม„•ไฯฦt8฿f>ฏž๘ะl8Uปอ]ว]u#šฝhœjBZŸ ๕ /Pb๊kฆฺjMsท.ยb ีQฝWด๎ ?ฮo๐/๔‡าj’2๐ฮส#ฃช#ถi่พ๛มgI™oo๓Œnย ”B  x‚๊Žs\k]7ƒ๑P๛vยฤ:žฟ‰สฬg$ฤผ}๓๖mLฌv—มฏu4\…&Hจ๏ปฯ„e(ฒ‚๐fๆ†€พๅ7า{_ฆศฒโƒ=.Gทhaฅ๊rฅะซ๘:๕iใyผำ/|“ึ ิiณอผy๎๗z ๙๚ucฺฦ•oใ ‰#ํโสwq-0ํ Kญ็๑แmฺไพ–Hsว็ำบ–J5m›ซ™L^„‚‡์)ีะ.Mึ~ตุธx๏kืmล‘sWฎXีวœ ี}๋อCr'๊xย}ฆ-AฝqGƒŽLถฌ6์๗›A7ƒ“j๑๔๓9ดn`œ†Wำiฮฎฃ.y฿8พฅGŽ||ญ”ฃฉฌุY๗žROป๙/ฤ-–๗๖‹|ืํณrฯ้฿ด่6kท๛? p&ณ8rแ๊…s‡aฃ]ˆ#ฝVใทw๗ผr)0ะ˜๛ูu}ด”งH…ฃข‚?ธฆoญ๒kEฟ$—Q2ซ)ษณ_น็/ ˆDิภœD]Cv6d/I€ ‰J„#ห š€n}šฎฺื ญnƒpo’•‰๔;$šาj&*ตจถysููฝ&1 ิ fธgFUGOO/+5%w(%5EO_‘ž๛๏ท^utZcžiฃถญ๏๛f๋O›ƒฒพlœ ฦ็มYŒ˜ั!x๋_weŸ|%n5b˜ไ๘^ฟ •š—w JˆHฏq ซิ'Oใค7oฒดnญวขv-๋่้๋ๅ่LZโี&ฮ็WขูJ9 ƒฤพ€a€>•jทฏ€hโ?•๓๗@ึโ5•๓šสฝŠอฝดบq๛ˆvZMฦจN็? < “ัT?oคอิก[9Ÿ฿ˆF?j$€˜ณ$! ี‚NIIœLญ ิ๎้,tํmยฅฺณFทๆ€ิkพw๊ทถำ€ญZ๋^๕นGฒk ญ ํฯ฿๎Ÿิาึฎฅํศ=น$๓#j_™๓ะEท๋อ๚กฝ€V๗Y๓ฌn/่่าR  %YrZg5ญ†ฬDจฉZŽŽฬl*ญp๚TZbญ2๐ฯ๚ŒชมGsz„ัห†๕0ใlอ1ฃด๖อœฑ็a•mc0ช:=ง ‘ํu๕L๔+ฝ:†Ÿ>ผMํ~[n๑๕Xd๘ฯdื 9ภ๎Zภvปวมนๆ‰‘ คGŸyžคfA‰คผqำุ`่ืง j๕`$zBxิi๛้มHS5ะ6E์mศฒ‘ŒxีึษีŒ8CRากGb6Uฯ ํh—ญผรP„๎ Šโฤ[ =ฝ๓ฬห4>๓ู‡น3I~>lํZŠ]๛V&พ~A|!—Gzl๏ๅ฿หwฒMคฬฟฑz๋.8!+#ฺ๗าm5KซY…W'ทšฬg<พœeb*อฝใbS(zvอ๒8ฝ ธwฏ฿ฬศHO ผ—žž!‰๓oฌ]๕|”สหcฝฝn๊7hจฏสQrdd*!„€NฏQฃโJRคฬ‘สเฯn๘๚]คŸฯjf&E๙Qผ’\6ษฌโ@Luๅไๆ2๎ฺ~ข;˜7ัษ•ว=†ด5•f ฎ##_" hืฃššเๅเD*4y๒โ0ัห;ย‚์>n}Us๊ŠมxลG Jj8L]=Q๗ุ6๗?แ๎ใฑสe๛”/ ƒ๑๙HšO๚ัย}ฮผHเ“fŒ e;ปื—.J3ๅฤด–'Eฺตบ-ด‚ŒŸ๋ว‡Y2่์*uฑ"#Ssเฮ‘ถดpG…Bม ๓I๋ =q}w“+C”!(', Tไฺศษ{(สˆW Uฃึใ(\ษ›ชygSš›‰”งBก๚^ ญ wอภ*เฬอBปN y๎ื …‚€H$สสๅr‘P๔ฉฃM@IฑQํŠณ้ั-๙์ุะฯ๒)"‘ศdะ–C]ๅ๊ัม๙kO?vฤGฝhฐ่ภฉŸำRc‚ึฎพ•'Wžขฯ >7็ห‰โ•ไฒHf•‡<‰๔E6์'$:†๊™"2RอITๆษษ„•๊ฝgูเ ™ไ\ภL>[ฅn๚ โ“DPศ`๖3ี/‹„ฒฃช“””$ัิ ZZZ‰‰‰ะqZฐฑซี7ง 3๖ฦ‚มมC=พณyรซbwว1ฅฆnซึ5L๗๘Žศl{ณแ_ƒ๎ €-Z$฿<^˜ๆŸzŽš๗๏ฦา์”Pฟ[ ณํญแๅซoํl/น๎q็ฉ411ฑpG…Aเs[q$6…—šCR‡ผ๗^าโL„^A๓ป„หณ๙)๊จ˜& Yู1$>…7ฌEiฟR# ณๅ9M‡ˆซ~๑›[[7•ฺ๙,|฿šเyสqE9สๅr ทc&ไrUขถe'%ลFu|฿v๋q~xdy‡\.;0e„๋ขี่=รoคใ์ดย=Jกมศ๙2ง๘%น,’Y๕IวGณ ๙ใx…่p"{าดขƒ*้ศไ Q2@ข‡ฬนauTทฅ๒g$๎]ฎ@ท%ๅž’„dkCVeๅ?!eศบ๔ุฆื`K‰บQ๓~M‚๎56$ ๙…–'!ฎ$,๚KF๗9P๛€ึ์H%h4ฅฦy›wฐ…ฆo3„6H๓๏u๖ดพ‹ ˜๋H{)`๓ŒชDณyW~๋Ÿsฦห้€)xพญ๗ศ=แQ‡ปš/๚ๅฤT}y๔ฝำ V_J‘ณฃ4ฬ๛xฤึ_ฯ๗?ฟ๊ทrEb0พB๋†–ฏBž^ฌำ/พัaูๆS#t๚ๆฎี_ˆ>ผjsร%+N~ง™u๏๔UWJ>X%ํร;Ž‚"–„M๓ๆส“ƒ‰คMูฯœyHฑำ ƒม`0 ฃธจ\ฟ๔5๗Œ ฃ๐dF™Pศม๑Ÿภ~ƒม`0พ0lม`0 ƒม`ึ`0 ƒม`0ล…๕U‰f๓ฎ์e๖้Ÿgสm„I‰.ฑq๑ธ~?๗๏สœ–อ&ร6>ใxษ๓๘–ŸW@ฬœื<{ัk๏ฌถzŸ฿–O๓SœI—Yปฯ๛^๗ฝโฝ฿uR ํ’\ฎีwcฮ๏x#(๗7๕^ุ*๗ปšƒw๙yฎ้ฎ“งl•€๋ทo^๖v฿1ำฉzูคSช‚':&๏ฝไปผอG๚\1๛o|$Pจ4—”g]!Ž” ล8q฿q_+>2ค฿ฎๅmZ|FาUd๘ำ{ทe{˜โ{›ึำฮๆ`๑กฮว7‚‹wกU๎GqjZฟiŸg€ืŽแ–ชl–ฅ6KJ๙วID‚๏ํด7y›i่‰ดี>ิE๛Ÿvฃซๅ6ฬด๕ลsh่ขฝงฦpCยึ”+Aถrๅป๘kาmฐŠ๏ผ%๏o 5PฅiA\y๋†1mบ‰oๅ๔E“SR4i ผร:พlj^hkGT‡ฺฬๆ6๐๓iฝ๚eใœ฿ส`”!/wWhA‰้เycEวฦv;ญึdาŽ_'nฟ<ฌำ ฏurพซ-W=ๅPำัๅ““dJ์Q~ฌ\!-(!‚ฟ่[1BญFVี%…™1O_รขb„O฿fแS”ไ็5^‰Pง฿Oฃท Ÿ์• จ9hำ๑ั:‘TหSOฮluสOู๖๙m๙Œ[Pzพฝ๏ศ=แB}๛nซF]พด๎ŽาˆJ‹าเk๖^ถเ{{๑“{1Ÿ่๋๗œ1T#*ฆPกา\R*,ฤ‘Mจฅ&นถˆd\~ัŽ'ฯB๑3ำฏๆ“M.vK^N6n้ัf l\ผ]>VRr#” N5ว‘Stฝw>M4%๙G๚–ะๆG(ทYBส9NฎSc๕FI(xž็l-†ง ใ%zj+[Hxgฆ‚กถ๚,m|/ิ–ธุชตบšXฆฟrU ™-&น-1ญ?&Gๆ~๓b ๗2ฆ(MM€BZŸโ!๕ /@zE_jช  Fั$p/4ค-ฦะฤ๏_!๗uวPxp~ทALจอXZm5Q๚|-ฌภจ๚h4บ|ั๗ญjฉ%ฟ8๑๛๖ฝพ‘2€3q˜ฑdJWk=yิํWญฺw/นยŸบ66"o฿fiคศณ qžEําอื E!ž”@B}ธ{&,CŒ €DsCผฆ…ž‡ บใฌcd;&lRv;๓ ๓์‘รTPฌgbaฎUP˜’๕2$TP’Ÿื*ัRณ๕Rาe”็RำฒS“e%บ\)6.ฟ’xพญ๗•'ฟQWžp๋ฉฎs P๊ชYJƒO|๎็พuท๏3๛Vhซ};abฯM๋.ฉWˆPi.)ชt๔1zดีršsฮn›ตภณฅ\h๕ฑ๗ูซฏR?ึๅ,Fฬ่ผ๕ฏปฒย…JsIฉP…ฃOI$ืงr—!^S9ฏฉ\h<๒x็5•„ง|ฌ.จมeฮg IตฆฦF`<๊พโฎฮแฯฃึ(ชซา&ŒPฮx&ฃฉ>€ศใ„vคฆบ0HำNVํฮ`ูญ‡ุ๓\p!‡ำ+ญ@ญy ๕'w๏พ๚E mSี`kจ้…Yร‡,ผe5k”@…อ˜Cclํ:ฏบล{.hikืาvฬพจBl~งฒฺ[นMญ๎ณๆY^:ะัy๔–X็5ใm €8๗ {่ศi=Œป๔~ฝูี/ฅlโ,4ไM๖ญิ๒–x.{(=Aนโeอว๒[CBกบะF‹่ŠUู4้7mPยถ!];๋eค8—S9๗i4๖เmา%ณ™c‰@ะธzิชญ๕'น-=M;ถญ๕yษ๘๊R „_$๙|uf๑Nky‡E|ฃvข™Bษฉกค๕HณŠน”hBBI–œึGMซ!3jชDง#3›J๋ƒœ>•ึ€XK…fI`๓Œ*วq"mCCm๙ยะ ก๙7V๏ฎ๚(•Gชทือ#๊ใQB-ซ๚ฑ[‚ณW/ฃ 4ผ^Z2+ฺ2ฎOก/u}๔๛ˆp8M‹‹6ฮ้๏?๖฿Hะ๎ทๅาโVฒ็K'ฏ ’ัห†yซีํตdลจ7ฟอœแซzœก„๓S9๚็ฮฎ{yม่ oD๕/\>ๆัฐmฒ‹y‰จ๗ใ1฿ ˆ่‹ƒ›Q๊aย(f๐=ง ‘ํๅ™ˆ!… •ๆ’สฌ+!ˆŠ@^SดM๑ฮr ๙]ฤ :Z$IEทEฑง ห‚/ขฺ:$! xKž๒MฆH"ืo•Wุ_ zvอ๒˜U่Š0ฅ d>็๑*x|๗aฆZๅƒลฐฉŠศณ๖พ^๛กฬค@ไ^)l~งาฺ[้ฅๆ฿Xฝ๕฿œ๘^บญ6ฮสAฑ ฏo8ีgฮ-ŠXทฮ~0„Pš8K‰ฆ™ฦFBYJ๖ึ›)๙ม‡Š…MตS๚.A๖8•—&GFฆึ%„€NฏQ#3ผ:นํ๘ำd ๙VpV+S)(๎^ฟ™‘aŸx-.ฝ[†HชฒSRน6A๕wฤ?' !H(Auj_๓๗:Nฉ&@๗uZSažห ฤ๒ื‹จฺ๕จP“คษม‰Th๒ไลaุŽๅศzIAP›i>๎?œฮ๔งธ]˜g0*J?ึกขฌี|๚lทฑีๅaAปบžอ†H$2ดๅPW9zFtฐ€P(Tศ•ฎOJ~้sๆeQณ“฿D็ฎ‡:|ษะo๊‘rbZห“"ํZoZAฦฯ๕Šิp˜บzข๎ฑm๎-~๚ร%ฦc•ห๖Ÿ ฬ2T๐I~*Sาดw๎๐โ”หPˆแ‡}ฮถ(๖ๅ%#dว€‘{ย‰ธบรข[วLWน๕!Šผค๙ค-็ฬ‹DวกRกา\zจ2๋ส•ฐํ9๓แ”ยl<_ƒ IชŠ œ4ฏ๓Mเ๒†“|Hฆอp'Ÿปพ’ภู๔่–|vlhกJJ+ภ8พ„6U‘_* ก0ฟ}Q*›๙ไวฉด๖VŠH$สI.—‹„นeIเภษ˜‘ยทนฟ)จ^6q~&iแ้ฝรกฅ)šฺ\ื3ฒ™19*CCฆ‚๔๘Vbญ๒R>*่EƒENœ–ดvu~ง9HyJH•^nb`Mำ๎s๙๗{vr yฟ24 #์w’ำœฅˆ อ^!:œศ‚4ญˆPหŒtdrจ™ ัCfจฃบ-•?#q๏rบ-)๗”$$€Xฒฒ(+UบCส๘ฯ@ซ][=ฑฤธ[—o=LˆลเE3๚ด07e'ฝMๆ@XHˆQ๓6ๆ@Roเาอ฿7ˆ 7nีมJ*ญํ๔ำจ6Z Yพyๅฒํ๓ปhโ<1[ณeO็VFj"‰ดqŸN–>ฬุH›งnึ๎บแH๖_?n๊?SภqD!ห–egิ[)H&Q๐€ฏ0!ๅรำ *อe๙™CํกKื-Zเ:ง‹zฮ็ค! M;v1–pœ–eWห!/ ปผ,เิMฺทฎU> ŠฃํฝmํZฺฺตดต๋ถ6(ร}VหปB• •ๆ’Ra’ƒ†เฮ˜6OuU/ณM‚a3ˆDPk}žค&1ฅ๕ญษ“m\(GญZVXิศู๑™ว…w๏%oข"Mฟํ๐ิฐ^ื้?ดหฉม”W€ลทY"ดŒอ DœศจS๓ฬgO฿•‰อOQZ{+%<$คบ}—†zbต๊m;4“‡„ฤ€ภjคKป[๋'.‡1ฝgl\™วYlxฎƒตZ]ยjยฆฺ|t:าจ–๚๘ฺ]ฉ^M์ ‘฿Wuฺ“P$ั74 ๊'I•FŸ๊๊ค๚0BKjb ZรI‘*4sเIˆ+ ‹ฎธxหJbะšฉDฆิ˜#o๓ei:๐6Chณ4ใ‡~{Z฿‰ŠEPoLuIBY<๘ุFU"หwสหฝข/ผu`ษพ็๘ฉpฬอSj “ž_ูฒ๖T€๕/ู์1Y_่ถ๚น @ผวo๛:ฌ~r๘‹}s๖๙ “o71๔itฒQฺำˆยฬ๐๙ใ—ึ๓ใe$ษŒytqๅ๊ใo\}ฃรฒองF่ #๕อ]ซพ‘ณฅ3ฬ๛xฤึ_ฯ๗?ฟ๊7ๅD8VMษMZAย”๐3!Ÿj๚V”P ้J๓^> O”ฆ= ฯkผ?๘{แฉEณvž_ชฉH t]w, *~Žโ“๔ p:`J/€ๅ”ำShvZ\xะ‰ๅƒJdณุจHป’ ฎ}sšŠn๖B๊ษ้–จา\R*,ฅฃ๗็/ao™w€’RขŽaผƒ3HโผนTีs9šํ:ƒO {H<j ฆgนxำจแ=๒ฎJžN ถGป‡gื\๘{z๋พ๖ซwœ๖๒๘ฒC>}†PQ฿fฃ™žษyืศ‰€Ixพญ๗ศ=แJo„—็ผ1yๆ/c๕ฌ๐;‡ๆฌขชl*Eีอ๕)Jkoฅ${ฌ_x้สใc๕ั๗Oฬ_q‹ฤt่‘;†฿ฮˆฐ๖LŸ?ู_Z~-ญ<โTNณฦฺKkๆด๒5N›"-"}่ƒ์}O„ำ›k๕!3‹ฟ’แž €?๓0ำฒฑฦฮZศLWx฿U}xkฤ™?_นนžณธK‘qวmมœ๗KRe‡˜C;ฉ๙ke$ไ(แuกH@ฬ!."A…&>˜šจtฤ#ฺรฉJสฟ%กฟ?ผUMาำจ<์XAุ!ข;ŒถmGq$r7‰)‹•DMํ‰2งป๋Xฟฤ`|]๔๊ใ์~Š-ซcTz”ึดW33ชuพƒ‘‡ถ๓ฺŽzอ๖.ร๓ฅ*‹อ๒ ฒฤ๙)โN+ผ๛^๏1ๅL*"ช3mzฎ=ึาqU)๔๋Uะ:ศ„ฏทC๓ัCŠอ?0 ƒQนะํ่ฤะโ2m์V›ๅAe‰S ฒเหžฃงฟ81[NAม'?ฺฝ๘๑—ŠQ๕a๓ŒJ›`T ุƒม`T"ุ>yHฑำ ƒม`0 ฃธฐฃา0^ๆ๗ฅC`0 ƒม๘ฏร๚ ƒม`0 ฃธฐƒม`0 ƒม(.ฌภ`0ˆNฃษ{/๙.o“/ื๊ใxษ๓๘–Ÿ็แk๗Ÿบp๑ฑ“ZKUํ๒#ฦิn-5ัษจืŸwFูIๅˆแ€?ฝ็[ถYฆ๕ดณืo๛฿๚๗‹ujๅ็นฆ{/ ๏ฝฃฬ*6ฮBquG๏๗าำ0G*ฒ™uฤcฉ}a๏สิคMf๓N๙K๙ฦmสทนf1~ฏวl›๒๔P่ัVฎ|—Mš€จต™อ;mเๆำz๕ิม•ทnำฆ›๘VN_.์’SาBjPป-|วeณœ๕ ใฟ@อหv>6๘mLก๑ ๅSฮป๔s่oฮZ?๋ฌภt๐ผฑขc“ปต้:dล‹6ซ'ูsOX;”?4ฝทCแK๎ฺ.™ๆ ฉ &OoQห^T๊ด~ ๒ิจ~ฃด˜๔่nrแญ2อโ6n้ัฆU๓ษG?}๋\ดฯoหื์ ,๎™ๅgแŽ๘๛7ซ๕ำฯ๖๊g1dVWฎฎืาห™aฺŸJ๎q~s9ฟˆz?Tง่KL‚sพ9+ษ4$G@1~œ฿<.เ_่ฅีrK(ค๕)R๚‚ยฌ~…”ด„˜๔ฅBoํ Xม`0 $>๗s฿:แฟh๐‰›4oxฬ๑—)2Yยํ#ฺฮ<“€„๚ฑ๛LX†";!(เofn่[~#ฝwมeŠ,+>ุใrt‹V*=ลŸ%Ii3˜๔ง๒๓ไM )m0•๏ฐwœO๋ZๆjJฺ๓Gะ๊Cxว๕|›‘4็h@‘m>Ÿw\รwศท]ฬด.ฏฉ˜u๏)๕๔ธหฮ4›wลm„ h4บแ๐Yฟ๋—<๖ฏืT ู๎ปผฏำB7O๏#ซปึPiS)6.7oนnl+ญพ ี:,:โ้็spM฿Z6/ ฺ”๖ีs๏X ๊O8|ai;mเj:อูu๔bภ%ฯใวทิƒ๊8๕Z฿v๓สฅภ@๗c๎gื๕ัRแHvk๛oม z๏ูราvn๑Œ/CGๅŽXD_Gv6dแ$>R•šJƒWšL%ยzใŽ™lYmุ๏7ƒn:‰T)เ!KDf"2!lF๕‘๐X@‹j๋79๙๙šฤ$Pƒš€pdYAะญOำรฟpเ%ฅ๘%€เZฏyvตฬผณƒม`H}์}๖๊ซิdzzzrแ7#9|๑โๅ๓-rฎ%€ˆห;ŽฅDคืธ…U๊“ง๑@า›7Y ZทึใQ ป–u๔๔๕UปJ#ฯKHช556€š}จ์ wewอ‹ค{s๗ห<+ช–zˆ=ฯฒ ก๚—ัม{v4๕ท๛ฦญๅ7ีšทPwr๗๎ซ_ดัอผD6๏ญ๋dืาvา‘'%ฬ{ 5ฝ0k๘…ทฌfฒ+8š๛อ8๗ {่ศi=Œป๔~ฝูี/€V๗Y๓ฌn/่่j_#+œผ)'ฆต<)าฎีm๑ฆd\ฏ8>์ฬ’AgWฉ‹™šwŽด-ดaoะชฝ‚ฐี๓ฯ๑ขœ4ฏ/Aเ>Yjถ=w<+ใ%ัสท๋y"yt๘๋}๋—‡ณ้ั-๙์ุะB•ขฌี|๚lทฑีๅaAปบžอPแเใKhS น"๗…B(ฬo_(ฑ)pเdฬศ แ฿ไJD"Qๅrน\$}œผ8๙จ  8๕sZjLะฺีท ^าbา๗F๗hislำ=Y9ชคy›†$โ น๏N’‹ปอ$?xฅษ,2ํU kšvŸหฬ๛˜~ƒ๘฿$2˜L๕๓jฐ”วDs•yr2a%ญ(n ัz=hไn. Jห‡็Š[B ƒQ้ILJขภ๛‡ฆBกด-;9jsฟKณSBn%ฬถท†—ฏพตณฝไบวw คาฤฤD•VIMZ฿†<]I$cyซไ๚„Wะ) ยWจธXŸึo€ภนr]$ยoปuŒ8?<2_ภ๓T ศํ˜q\^nง?>ฑbย ˆt,Z[ผ~n฿“Žฤ฿ๆg†&fห๓บ)สlJš๎/y๐ช๕จมf—๖…Srนทศšv1ƒRส‚อึ/1 ฦูฝl๛ FWMฝ†เnf๗‚ž ‹๎ f lคอS7k๗mˆ๐jอ†ฬ›๕}S}‰บ‰รw]๎zขย&Aญม4ำƒฤf"๒แ:RcmH‚a3ˆDPk}žคชญ€ำ‚DยฑD๊?ศู๑™ว…w๏%oข"Mฟํ๐ิฐ^ื้?ดหYM,/šัง…น(;้ml2จญฬf‰ะ267q"ฃvNอ3Ÿ=}งาฆภjคKป[๋'.‡1=wอ\xHHu๛. ๕ฤjีvh& QีษŠ$๚†Fb@ ๘ฐษ๛‰#Rs่oถoฟšwjใั่ฉฅeโจBP‡XNฒ>ธ(ฅษT™๖ุ่7:Mฺึะ3ฒจ)ญlว)GŸ๊๊คˆ‚๖ดพ‹ ˜๋’„ฏxโJยขฟDฅAu ัtเm†ะfi๎/Fฆr^S9ฏฉœฯQ(nฏRw๐้๚%ƒม`TI์–\pํ›ำจpณRON๏ฐ,๐๐ืZ‹W๛ษ@๓เ์‚5^I.พัaูๆS#t๚ๆฎี_ˆ>ผjsร%+N~ง™u๏๔UWT<$ญiนไœๅz›ooจใDw฿ฎ3๘ฑ‡ฤซZ)๐ŽผˆแlฬZฏแ^ฝ*œจจทํั๎แูu Dฑงท๎kฟzว‰a//;ไำg8 ๑Sแ๘™›งิ2&=ฟฒeํฉOOb-ฬfฃ™žษyศ‰€Ixพญ๗ศ=แ6.ฟสi๖Ÿ˜‚'[ว์‹zy๎ฯ“g๎๑2Vฯ ฟshฮ๊ ชย&1:ฟไŽแท3โฌ=ำgใO๖—–_KK๖Xฟถ๑า•วว๊)ข๏Ÿ˜ฟโ–ชqๆฯWnGฎ็ฌาQคGq[0g๗ŒO๕™1F|่‡Sฑ๘n:hูOญ.-ฟ^ZGฤด™๋๛เอฟ[๋•ๆงสLฮธฐsณำ๒u'‹Sno9DฅkL1‡v R ฬs†"บรhvTG"w“˜œ…M•wBu ‘E“๔4*+tฌ ๔ีิิสำ>ƒม`0Šๆjff[V\Sฺก5|~'rZ]๙ๆšฤ็Xๅ}ศ—ฺฮkO8^่5ป ณ•ยฆธำ ๏พื{L9“ €ˆ๊Œc›žkuw+ฬQ™gT&๔๋Uะึˆ„ฏทฎ๛่!ลๆ ƒ๑ตภฟFt'ฺvฅ<(าษซ}_๏๕หกัน‰กลe:^9lส‚/{Žžzโฤl9Ÿh๗โว่ˆม`lม`0พุƒม`|ฐ๙|๒b๛ง ƒม`0 Fqa๋— ƒม`0ŒrK~*ไ๕ 9ส ภๆ ƒม`0 Fqaƒม`0 ƒQ\สฆPSรเpM๓ ‹งๆ5K5k•ุ€ล4๏ˆจ๐ํ>76ซฎEFD]›o+ึ๋ปโฯง/Ÿ=8ตyTm@ตv3๖\ผ๕ไี๓Gทฮ9ีฮ d6ad๓Ÿž_พxไฝgf;}ะl6แทณืƒ_ผ~๙์พ๏ฑ_๚ื.tEุง6KคYหIJ{}]H nึฎ}_ZŒ-ล6๓oDE[eW,ซต๛ฌ>๊sูใ;—๖ฮ้Pฃาฝ(‰่4šผ๗’๏๒6… 9“.ณvนŸ๗ฝ๎{ล{ฟ๋ค9 ธV็นปŽz๘\๑ณzH‰jMขg;a๋ฟ็ฏ^8ณลw 4 ZX&ิnoจlฮPŽๅจWฯ.l/ฎXฏอๆ] ธ~?เฺูใปๆ๔จซ96jๅ็นฆปNYว ูผ+n#L Uัด~ำ>ฯฏร-KdzฺY๋ทo๛ƒE)bฎm0•๏ฐwZม7iAหŒิ v[๘Ž#*hnฅCiึ jา&ณyง|‡ฅ|ใ6๒S๕fศL ๊เส[7ˆiำM|+งŠŽฟThาบx‡u|๛ูิฌh๕ฒ-Keั ‹Œtqูฯส…ํt ง|Ve๒™Ts˜๋1ฏEอ2 พ‚l๔ื1m$wwฎ\{8ป5Lo.„ฐœํ3:Wฟjฉh ็นฬดWฑฯ]ฉMํnหwอ้ก๗่ฯ•๋=ใjwžนอฅบฝ็.ํำT๒`๗ฺMgขjุ\3ฅ]Il_ณ๘—3•Nิ[฿pt95‡ˆี6ฒvฤมMฎ้-๗๗ึ!ีKtฝฺŒ๔„_๊|Œšฝ—ํ8|lบ๑˜ข„u๚ิ1z๐Nญป9%๚at']ฦƒ–O5:๏าฯกsฟ97j<ฎณž*M5—m_l๚พkฟษ{ฒGฌ€S%,”X๒๔yฒl3๑!ฏ/lZถ๚ภ]Y…;~พฝo{วa /N2ฉษgฐั>ฟ-_ณ'Pี{ศห5ว‘Stฝ&t๎ิyภผำก%บ๔แ–mZ5Ÿ|ดLืฎ› งjทนซ๓ธซnDณญก๙+“พT_–พชJณฮด?•ใๆr๕~ผฉ˜็ฬ็ี?ผžBZŸ ๕ _ูฦ“ช  Fั$p1w๋",ฦPขMe[–สขภัเิไ฿wฆฆyษŸภ็vn=๓ศงAวฆูช€ิn๒็o‰ˆ๒›ำuภึKCž๙๏่o4่ืŠ๙c๖๊฿wธ,-iำทปกrcนณญ๕ƒ,jู๋|บP็฿š5w๋kิˆฤ็~๎['๏ื ไข„ฉ‰‰ู™)้2สgฅฆeง&%สq“ๆ ๏Ÿ92E&Kธป}D™gUhข™“ำซใnทcำRร<๗Ÿ็-U •c๚#฿ล•๏ฒ‘o1†ๅต„$ i‹ล|ง |›ษTš3อ!กถ›x๓bหEผUmšŒQ๏๛[ภอ €›ืํX7กm^JLแ๎u5ภ๓่ŽIญrfุ5บlบพsˆQฮ๗–?>=ญ‰ อ’Ce‰ํ8%๏ะม 4p๘ฌ฿๕K๛Wko*ช ใิด†๙๚\งพฟtเ`ใโp๓ึษ๋ฦถาสาฦล{๏Xปn+Žœ๓๑9ดnPnUฉืjถใ๎žW.บs?ปฎTภ™8ฬ๚ใ๐…k—ฝOฮiซQPxไยี ็2ยFช็เทฒ=ื์วฃ~พพ›๛ฉส๏ฝฃr‡u‹1ง๑ูˆจ9‰บ†์lศ^’•๗rwม7ด^ ๒์j”ๅ’ฒlฟศwุ>+๗œ}@‹nณvป3ฑq%?DGEึ‰ีI๔udgCNโ !€”‡ไูฏ๓F4ย‘eM@ท>Mฏ๘”Zแ$+้wH4ฅี -Ÿล,Kลง,๚ŠŒ_ใโ๖r๚7ฬjญฉุ&zmV๎7}fŽ^9๗HQnฺฤฮ"H:.u›฿S๛๊ยQe5z๋o๊ฯŽ-œ๕ห๙(€ฟ็6k๖ฌY >+‰๗ะ฿๛ู+8๓abb"`คฅ…ฎAฃ 4ฉTŠฐฝ#ํtZy "cง6๕>))ต6 AฝแปŸ=๗?ๆ:หมHฮ#ํ์๔>;m0ร๓V€[๘?ฟ๐KPIโ,พf๑/g”1ฆ฿ฏ˜ช๘?{gU๖๐s฿]C—ˆ(ˆจˆ˜ˆ…โkฌจk`ป๊šุญจ?w-ฌตฐD%Dp คKš˜x๗๗ขผ7 *๎๛~๘ƒนs๎y็žน๗พ๗่ฐ๖ถ]Fm๙ืดk[ %\g€ญ๘ห~™f#Gฉ5ฤพอˆ๋ซๆ๔ๆ€ๆฐต์-่iฒำ”ป6›VชQ{ˆฅพIWMK”ฟ6GฯU]ซซaA'IYŽx.ซŽ.`๔๎ไฆญFํ84›v1 ๙OzผQ|ผQ‡ Eา”ขข(ก๋wตš้ิถ฿nมไูฆ\Zูฉ‹สกแ๖ํพ์9ใืฦ ๑ฺ๋ํญยgumi฿}๚ฐอ๏Xรๆ5Ÿงพอุ4@W g๗IN?]>ฯฆฅข9Š( ฃF*:3ไ.™ั๊;ร]5:<จ๗’้ฮๅ4ำAใฺพ=wๅ9ั๘—iC,มฤฤpJ~๋ก~๒SRLMMไ่ิQี ‚›ฅ`จค5Mˆฅ%๗ฮ.VWำ65\ฆสฅmหิ Eq7๎ว)˜~fฺขฉ—‚‚ƒNป„อุxO ฅฅ%a7ป๙;๗nYแึˆM'ฉฉฏณ2Kํ&๎X๙‹EfF†žพ>M )ˆ€ูDภl”\ „-q)โr"^ˆ[”-(E™o€o:˜ฏŒฒh$พDxๅ'{'๛?.ๅ—‡๖“Wu|ถโทฝ&xฒtl มƒ(kG'5ใียBŸัH~%™™™e™ม`จ็x๒์๔=‡ฯฤศฑ•@ๆ๛xU#CBีeีๅƒ[‚พกAส๛bท๖rrฐŸๆ๓ๅพๅภ!*ง&บนNปk6฿ฃ+Œ‡ฬžปod_็๎GงxO๒ผJ๓ึต~žหZ<^;ผ{Ÿ!s}K*Wุฦฎาญ฿ุƒB๗MZ@ฦน ๖Nฝ7D‘ห์์'œJญ[‡ิเJAญ'๎ดtYKถtY๕‰ภbฮป†๒ชYw@็ฅช–ญA๊†=แ63FqผW_ร=ปิ|ฝ๙๋nAษeๅBซi€จ เ1สสจขกeKฐฎ๐ญะว5>ฟ;ชภรจT‚-'a}(ษ%-zaE๓R จณำ‚œ ™Y{Jู3๔๕Fsd77อฒใ?‘l]พXฺที€ะKB๏๓vKว๖ชyแ๔๕'y๘C่้3งO_Œฌ๚ื”จ๖†ๅจ๕ฺ๔ .l“#ซ! dึ๋]พ>8›Yฮรm;}้j"*€ฦ6Jื<งn.m๊ถz๑@ เuXxh๛ษ…E“งoพo8yฟื๏M~ป?พ ‚ 8š๚š(๗ๅ#๓V^ฮ o J;*+sด••อ‚‡2แ7ง7Ÿx–/< {Tjnฎ›ทHปํ‘!,อy|ฤsึ™W5*sd๑ผิด฿ณ๓Žไ^ฐูดK)ห‘ฅ}[-ศ๓?ฐแะ_+Fฒh฿ถš‘Fพช๎V%มa!€eห–wฎ>.$%้ื/‡๒ํ์ส็„แ}“๙ฑ>‚R™dฺ+ัKษทฏ‡+ตlI฿ธคBe฿™,šž’๋วข็Ÿ& P˜;5;gA™ฒๅM:mัฺ…‡ยTLMตหโทiูฟ็๗@M] x\R’งฉซญ1ห“ฃณ@337Ca าe•rd\Qฮะไ”E0Xฯ`ถผุ฿ํ‹6นทl่ 7'๖_;ม–€)ตm)๖ž์6`ิš'-–-ภง‘Tโ๑$ G฿บฝ…†X"ๆ๒x4Šƒัซ ฤป๗ -๏€ง)›งอzฺ6˜เ4วส/ ำJ2Tณcศ๔Cs…ลฉ>่๊•อญ…?m๋ิž ีษั๘ว$$M=N?ธR้ฯkจvU)„ ฌชTืีUG๙๏ยฮญๆŸ๑ ษF†บ–-Z๐-ฺตะ24าKHHฆO@•}—^ยธจgฅฦ&|(HI)B!@ˆะjีJฮ๏Fึ6Ya7Ÿๅ‰ล…๑๏Se๋นฬ›Yg฿๗QDJฒ"ต›ท ฐ]Ž๋พ€‹5%(r ๑เ4าAkp;`s1zจฺ๘t^ช๊O>~) o#|„ฮ79Sืะธ”šbซัd—ๅ˜†’3ๅi๘Ž˜/„฿~`mเK ˜๊VXUH ZY…๓R ๘l๊j–๋|ลc๎ฝตฃ๒Gธไ–n‘J“ ี'ชqO€D$"$ ”ี/\.@๛ทCฯ‘W TUTŠ)ดWgาO๒๕แ฿:๚ZZ่ˆR˜y>้j‡1vห9—/yฺq3ข.o^yุ่๕ธ‚O/&žŽ‰Ž$#ญ@Nฯ cxใ{๘Rศ+ฤ ๒์5ฬฺฺฒ†บ[r์๘฿IฟืPmVo๗ฑƒ›y๏xฅจNลŸ.—p ŠP)ƒ%_ดพษŠืgšˆ฿G๘๎[ป๎ส1@š@ฏฅzส{ER0–e*’$A—ร‘ˆeซฮŠโn๛W~J๕ูmิตTๆ่H`จY๗”หใˆลbKฤภซิ่ซtูYช๘<฿ฬ”PY žหแ˜?'ซRŽD"1€‡2y‹?๋ค~tึ0]พMqๆ%ใb‰ไกัฝผช฿[9™l6ซขหคP2หSณ๒uv™จŽ/ฬ]ž[๘๘๓z ,"\}ๅ^žฬฯEล"€ิิT@F†้`ld ˜’Rญฮฯ!Zซkฏืึฐล‚eฆ๏๛ผ ๕gฝภๆpฑT*๓–”$y<@^~>ฎ9“Jฅ4’๙Y™,]=ีฒฑ==ฬฬ š@ลัยึ=เํ:"SผndW‹๒๐<”U@๒อ€g‰ฒNษ•dจƒ_#80hxp!ษ๙ฟkถๅแกกY#:ถhฃk4tUฉ<ษชˆ า“ไทฟ๔t๕ฒณฒq—ืMน  ‡Q+ท-=อ'+!กphวfjon๚L๏dซœ๔ไCMRd8p^งะฑฮ )Fีš๔่ำ\๐oภรไฒB(•J+ช ‚ตB$Iโ™™cผซ}(ตCHWีYเ‹ฮ8&Œ€ฏ สsI‹๒ฐ>fถ QธBŽ—~z(]วลๆ]เีR”"PLI<ค%!ัs@mช—@ <%€ž”Tl W{,y>f@M๒RMจƒiiiI4†vลšZ[ตUU€Œ.ฅ้ฝyTZm{:ทlแ๘๛ถ‹๗MhSึJ{บP—)ฆOš9ฝทงPUยข๗ิiำงปYs4 Ÿ>mBw3(Rถ3~๘ŸKึM›บq† C๏'•m`๐ฦNŸ6}๚ด้ำงู๔mํXผv6\zO„€ีˆ%ž“ฆm๙ณ7ฒ"ฦร‹'ฑbฐนl๙ŒY[็ธ*CaLฬป่ฌ$]t†z5ฐm{ง&z\qnzzžดข&`g- งRม=yอฺ๘ธ8ใ^ร ”8๊MF๚๗ะšlU$"iณูM•Tฺd)ก4^Sู0++ @ป๏ฬ ๋ํ๗ฐฌ$^ฅ%<‰-ญพ3–Mšฒjœ#@j์“,บgฉ้ฎใ™S"๖>.ฮฐ“‹ฅ€’อ„=3ฺาฮuววลป jฃรS6๎ู฿IWรUˆ๙ขขๅiษ=3‹Š”๙7L~/ูะPRCCcน†€$ถาฎ๊ชhttŸ1ฮcู˜‰ฑO๒จ…โฎฟƒvSท-ž2}ำฺQ&ข‡Woั:„ ๎ cณ›:ส้้]’3ถ ฤย๊ฃ|๒฿ฝอmำณ ิš๖ํ๔wขุ่๖ƒ›i*):p5‹yI#‰ฃƒƒ›ื†ฏชfึห•๔†&Pq@\`! 4ภุค ข,iส| พ ูฅีH2T‹ลVVU&€งk;ะQ_จkjฆฮ%RC‚K'm๗๚ƒb๙’5ƒเ้ด>m๗ฝ—ศbฤŠyƒฺ›๋pฤ๙™Y$ ๑๑บNŽลo^พ~…:w%โk4mลๆ๐ดu๕ธ,‹๕E๛ฝฑ๛๊ญ+–y-๊S~cjR’‘ck>ฟฑหใ:หv&%พ}ซืฎณ9€g5l๕ฎ฿m้j0j‡คงฆ˜t่ัŒฏkีw๎ฤฎ๕ทIŒrฑI7เpAษ้ขd€D:ปl|คขบฝ—~~(]ง \ *Uฐ๓$z๋…ำ๊ัฬzฃฌงุด'ๆ๑@ฅ 6"Pfช์ี๎คHv–u~ฯK5ก.ถK ๆfฑ7kซMะV&ฅข๋น9๋4ํฉา;ซฦญgฏฟ๒ะ ž0ํูMฏซQe๏_Iภๆู‡ VแนT˜x(๒ภํ์‚ท๙u๙๒AeNา๎4eEง‚3/ฝƒƒ6Nฅปfฬ E๓KำžŸ๕\ฑ+F&Œzฑขง,f๚แG'ราRรnลไXู”„‰ษัycลไœ•#=–v”fฝบผf๕ๆ๛"€iตi€฿:’9๏nํธ๎VYžUPg’ย’J4ั๊›ฌุ็์ซO.ณ4`็พธต~ั™๒•”O]#ูYrหa…•‹ํทํผ๛S๐๖ถ…gkาฐ็ฎSๅฬำิ^Zด:-๕’ŽมU?๕โฎรC๖Œnl็Ÿ{๏ถพๅโUหQภ๊I•V๙}Y{2๓ล…ฅ+vั.$\ิTด8pอBJศบ๙V.oฟ๓Tด'ŸUœผ~ํป?๏ยส%ํwx0“/I‰<๕วœฐฏ™&_็Œบji่โขMylUๅ9:ช"i้๙์œ=ฅ4๑]ดฯรญ๋œีD้ฯฯ/^น็ ค๔ูN9Z[ณฐฝ89j๏ฤEิ์A QะŒ‚้๗™ๆvZukpY+f{ไ/Pten5”G—_]ฑเเญีชาผ„ฏญS ํ*ฏF+7^CGš๑๔ฦฒM๙๐”JRxwหj๋ต‹N๛๋Jร/<GาVธL,ฝ #[ฎฦึ(๑,๑ย‘tœ ป‘ ่)โธโ’‹„lุ‰^’ ‚ ส—ฉค๘ง๛Rฟภ๙ู1gื-ุ,ํฝคๆ$ฉ๒?|ฐ๓ kxูfชkแ3แๅท ง(Ÿ|Pผทฯรษ $?๒^ถุ่!ไพ‘”ว/~‘T^+ไ๘ํ?ีcใฎŒ~wjัฉะแ ะovUปfhณ„)฿ะี`4นถ็Tท.ziอนเAฃ ี|C#ห๖w]Ÿo๖ {ผึฏโฤŠ;ูeเ<”zฅืจqGํฅฺšิP pท๕๚TKง%ž<]wฒญ์– ง–„ฃปแrฬ42."๕ัุi=&3QยQTฑ&_”†ลX’ŠTา_ RR๚tขใ,ื๙Šฯฟ›3”๚fOo(0ฉ[๐'โ ฌฤVจฏ–้๛ตe๔๛foฆื-ตฌ?๏—”tQRเฒผ†€’@1pšโ6๎๐jสฌฒ*•กึp š4"๒ ีฺOูพŠปซŠ Ÿ๑honฏuƒ๖Ÿyฝวr๒฿๛ดผ๚o}ฝํ๚ฑ`ผ๔ ะถชี˜‘Kqฆ9ฉMq‡H๎ทC๓ลKชหภ๐] T›๋v’–ž๘๕†Ÿ_ษfV อิำyจ๔œ๎ีNฅ4ํฉ฿า๕ม?c็Dฯ๎๙Ÿ}้ฮTฑฒเลฑ•_ฝI๐ง…๑รw้?00ิฒh\BMe`๘/‘ธŸH6์คž›ึ๏๗6ขIฟปaฬ ฿ŠฦK ฿ƒŸ๒@/†zแ+๗?T‹ƒD%#Ž|?ŸIๅ่”€&10Tๅง฿ภภภภ๐3QหŠำ€๖?0๓ Šย๔E^ฅูจ]๗žฎ\]{wถทะ @ปy๏A} –ฑร/n]ฌ”ๅh```o่‘ิิไ‹๔jซHuฤ้ิไิฒฟCƒ~“๊ีึฃถŸฟqืา๎Y๔+ย‘Fซ'๎†ฌํ…๋aง%X•Z7฿@6V,ฃ๚ธ๙,าyูc ฺู๙kŽPํKv๕๋!ิ2z=ข;๔Pเาu{ส'-็{๖oฬ?->—1q8ิS?๒ฯvž'ฦษนื๔ ;U[พ๓”xppภัM้tึJ5ๅุY–)nฝtูA๖XMฺvดฐฃูงา_๋†u;๒ท‚ยu Š›L!ปo%ป-ฤๆๅy’ะวอg“=ถ“.๋ศึ€ ‹lูธธอNาัๅป$โkกJ&%KlทtูNv_Šญl๊ๆแrชžนmsฅด๐;ก…HรากKK๓๔๐ภ,]}mศศAบบ|„™3h~Jk๎ผซ:ฮ๓V dn&I1ฑฤƒsัร๕BšR๋i๖N‹๎ถ๖i:pอฒ฿;q_ฦVฝ˜P{ภ฿ฟ๓nฐ๓ ๔R(-xฺLaTมืูฉไ UUU ?ฟTOW@[Oป8ฟ๖`30Afึ๘พŠน8ว^ @’r๎น๋Or?Rภm9vŸฃธ๘๘ธจ[Ojซ&ว$† ”๒๗ฑ๋‰Bฉ87&)ifฎ yoB}๗L๙soฬ—MฅSฆZ๚๏๕ฉNแ*’”2โซE฿ธ๖ช@$ส J353กึV’‹xXุnูย&เ ถ™I:o%ป/ฦ+Eะฤ-—=7“vN๔Wมrฐv#”"ˆSQาsะถ@|ู€ข๓RD66Œ›o -mฐําe3ูฆ 0ยฝศฮnภsฦeCนe“T&ี ๚Yฟ|ฟว$ภ็3m—y1Pฑu฿~F่รป~ง7L๊fR6qฤ๙ฟตƒ]–{๛‡๚l์kHซ“;ฯภ๐ศจ+ทz8ช}๖า๏ฑยว?4๘์ฆม>o^Tาi๐›wLx่๚nD้BCยBv าฃีIi'a}ม฿>ท๏฿พy~๓;u ี „ฉหขร๎„฿๕ฟดcฒƒV™ส{OxX –อ”๓ทWwUฏ;k Wฅ=ฑDI('T๘$ˆ๒ $J๒€kฝ@IYดัต'๏ปไ๋t7"ย๗ข๏ญƒิส2ƒ‡“๋:Ÿ›มม็ถทd@ท!<ญ?~ํฏกํ]๓=9ีถมโOแ:ภvˆJK@๐ฅaฌo ภม:ๆ(๕ˆล zย=QjY6 JญA@ำ ุU2)Qร๊(ฝฬKPF.ึ1ญƒวห้?ไพ ŠJ,๋msีีy"Qูล๏ฅY™R]=e5=โฌ,ๆ๊,†šฃฺๅ‰•c^ท๋๚›๒‘YžหชฃKฝ;นig@AซQ;อn%MHH###•žซฏœ˜าJระP>$€ฮ ๙cูA7_H œๆLํอก~…Nƒั7ึzzhํฦ[๙อึnž`AgรE๒ฝ>1ลˆฃeบ่ๅซ(Š ผq?พสL0a1f^g{Ž<Uต๐8u๛^ˆซืŒฐVฆ•ค|ะณถ๐JาlาD/?/ฺJ2H `ƒr)จ›O—ไ"0†5ใ‰๛‹ˆˆ[ะhฎ˜ข0้้Gˆ'‘๚ฏ˜O๗FRฎ$ๅWัeŸ#ข‚Œ†bทDุ"โวฺๅ'HุC๏G*Cฐ …อ&ย 4ฬ&f๑Y ฯ$ลข4uํ!ฮ„ IDATฯ๕ฟ๙Lฮย*ƒกžใษณำ๔>{#วV^ฅvํ•™ัฏ฿ฦw]ฦธšืHg์ึ^N๖ำ|พผ?ืw“ F\eฝ`œ‹Fgฦน ๖Nฝ7D‘ห์์'œJ•ฃณชjจb5 U›ec‹๎tั฿ฤhล{’็ีฒ มrเ•S\ง5›๏ั•ภฒ5Hฐ'fฦ(Ž๗๊kธg—Fu™Œ๏…๋T‡Qฉ[Nย&๚P’JZ*ภ•‚ZOi้ฒ–l้P>ZQˆฒ%XW ๘V่ใ๋๏˜ŽšC™LJP"ฦ|@„6ๆท.บพ๒๗Oสบf6๖Ž.=[p^|ฝก™™=sc]qV–๔ว=gŠแวฅQ‹–*๐ืV๏#/<‘Zฺที‚<ต๒h ‹๖muโ>€ฒ‘‘S็A\๚wด74„‚ eอถ‚››fnูฟ๑ŸHถ.Ÿฆฺ า นW็6v๎N๏Cปฎพ077ฅ3‰แวC}ศ๎ศG!~+tOฮ๐Šก_ฒข3`ๆHั /สm6lฤุQ#=fo‰ฑ˜ป่W:IบqN_ใu๑สŸZ>^—?ะ<;„š j ข‡™a% (ษP7์G มP๚>ชa๒Xช๚˜ ย็KbuŸฟjฐH,ำ™ "1”<ƒV/_Žž| @šybฌLฟFฮ$ฃดะทิ๏ึy"ApิuuีQปฐs๋ถ๙็”Q}ำ/^Hฤ=~^ผ้ค#ๅฦพSฒSBƒa33~่ฌjงy3๋์๛/ŠHIV`@คv๓ฺtQอ›Yg†|–[*L นญิิZ8ฟชัw‘x๏ธ‘S9Bm์ฌ%JMฑีhฒหrฬ Cษ™Ÿยูญม ฅศ›G,HI)B!@ˆะjีชbk•}—^ยธจgฅฦ&|้ใ‡‘Bก@๐6โมG@ศแะํcjH|้:ฐค€Y n…UU”ม@\ฌ)A‘kˆง‘ๆาธฌh#๘Ž˜/„ขj๔cA™LJH๔๎<า๖ ]6“†ƒ(๛ห๕๋3uลึkนพ ๑‡่ธฬ’OS ™ูj—พ พ็สภP~ไฆธฐ๏U?ู@"๙ผ๕วๅqฤb1ˆ%bเ๑x…oใsกkหžภJOทฑ๏๛มโใ:€D$"ห• บบ€J'สmFฮŸําTG‰ฃฌ DgาW%“แ >๎uAแๅ9W8๊\W๎\‡&/ ๅต›6ยwั’€JM8qAzšl‘S๊๙[/›5ศฆ”ค|ZวEG6vIพ๚ฯฅe{รโฒลด&ๆC‰*่šโ‚Hษtค ฬLฐมl2iHฐD_ชรไงฅF€/†ยQY&ุ•ขKฉขc๚าAo’bัปฎ7<ไ ฅ๙ฌ฿k>wกท‡$1&๐จ—ืญ„ฯผดณำ'ืP'า๒9"ฉTสfWด/jฅณ‚ ;9Ž๑๐็๚J€ฅ,L{ฦฃ‹ยแp*L’H$ถ์'–<=s%c์”ค}พ้•ล๋ฦฮฏ?Œดk’ƒะ_T๐๙RD–ธ๘ !w7™๓ฎ๙Š3WgeฤlูUŽฑฌเ`#๔“ทIแ:1,@%(v13b @ข”“ ~‰า2ฐ– ค ใ๊4,๒'D์๒€:(“Iƒเ_‰XŠภlึฎ‹„า๗X-J^ŒLา 9i)yสฅ้ [kลภ๐ŸAมึแgMp’$8Tผะ@$จq8P๖โ‹%๐!F๔๊ฅuโ„ษธัิ%jฒ‡ŽJ'ฏฟ็Žัถ๗tฟญ6๖ไตYฆ๔&ี<™ _P—]/๕ฆฝœUc}gaqaBhT๎ยN-! „Jฒ‰cGCฃใ!cdŸํ#[>+eRูYง^”5,ไ„`ซช๚ทหoร3๖ธฬฟZํ–Q•HI=#๔> ‰JIC=HฯDJ๑‡ฟˆ๘Lฺxˆ$ ˆ9ภfH๔F‘Sˆƒ)ลํ{DะG‡ฒ41ใ^ฝIrฃุ\{&฿ฉJ Iฬbษ:QQ๎AๅuS.Gรยaิสm‹GO๓ก_UE็Wšฦf— Yิกฮ $Iโ™™cผ้fภ>“ฌp‹ลช!แต+๏i|วq#ฬ๎žJ*oKีต รลๆ]เีR”Bต{Wง)ไP๓ ฮ๋:ึyแqC*ฅ๋PBO  €ง%y๘bvกb่โ!- ‰žjX'\Q&ณ e0ฐว’ื่c๙š˜x…r ธ๊Ÿ/๛Z่ซC—K–”P๖fpฮหฐจ๘Bชฏช%-9™-ื?7.์5ูN˜๐$ถด๚ฮX6iสชqŽฉฑOฒ -!กTลิ4๛๑ตฐhยภRโiึฌฐ;r5ฐ˜u5ส}@k-J‹MOหธQำŽ}i•ชwGwCJ“~(ค–อึJBูฌk‡&ษIษ4’/7ะษมษมษuKŒะwรฐร ybU‡nŽzJ฿vPฏฆ/žฟฆ‘ค|†ฆฆ(+Sฑ๓f„y A@ ๙I i‚„…Eฉ ำยทšŒ5หฏ”๔€@ภk :bTHง_Œr’ฐฉ pนภ1ยฆญ ๗ฝLงn[เp@ฉh“จHฎyฅ9ˆc ฺฺภำ!ฯ$ฃo8œ_๛ฎtVzjŠI‡อ๘บV}็N์*;มbฤŠyƒฺ›๋pฤ๙™Y$€ผ}‹Uuึ5#sมั๋๊าฎไ๕ซ์:ัY•ฤทo๕ฺu6็๐ฌ†ญ๕ป-ํœคทo :๕iกลU2่าฃญไํ,–๕XฯฎQฆฎ>IŒ™; bโญฮํTeเJP)ๅั?ฺXSๅำ•๔2ุžถฎ—ลbฑ>๕#Pบฃฌงุด'ๆ๑@ฅ 6"Pf*€ๅ&b“nภแ‚’ 6าEน^%ั[/”˜๖ญmฏ-”ษี๎คHvฎ˜‘ี๎†m\0—สถุHณRฺk}}‰XฆŽƒ>mาN๔‹~พj๊?–Q๊†์+;๗j5ฉU/๋๋‡๔\w๕ฌžด]iี˜฿—ต'3_\Xบbื#๘`›๒H<พoBย€&T:ySถos.๛ฟ๕่ํGฟ๓ไ๚ ย็{ึ6›;e฿ถ'>k† ธผโ๐‚ํ๘๛R˜ฤ๐C!ธ๗ืŽ๎kv]ฃยœ‘‡7ž}เด๊ถืเฒฆโ๖ศ_ ่สk"(ข ƒq้Š“zผ’Œwึoผ”N!E๛ @สฝb๚WH^่ด4ZAIˆ„P €ภJ0@๊%ค9Š์๎จ>E@ฉท ้าูคู(ัๅาฯช'žB*#ศN}(†์">๑“ฮฎฝฬEษวQŽIyi zีšด[ŽYB๔j'Jฮก4ฉัฟ3ส]๚w}~ckๅืฒฎํ9ีmใหฃ_Zs.xะhศ‰{ลž<ืฬFบ์7Aปท\•ณ๑—Bgซ๙‡F–]r9|ผู7p์๑$;ฯภฟ†—5ผฏ…ฯ„—{&œJ}๓ะฟ3ๆ0R.MztnัฦLง“J”’…~ถฎฺๅ7C›%L‰๐๘†vูz฿ถ-ถซื_๒ะ’ฆ=นผt]@&๎KM90:Z˜๓tห๕A;่twํƒโ๚ฐSaท๕๚”}ำO sPฯ€"นk|Pผทฯรฒล]RA๒#๏e‹ŽGvฑัธ.ใ"Rึc2%•jš๘Rq'ป œ‡ROข๔bฝ†ŽฅL&ˆา K?$žCšฃp—ฎX๚ฅC_{บqe’’Rล‡Yฎ๓๗ฺQZ&*(้wไ่๙L๚/Gงไ›๔ห 7ลื/5%@ ฺ๘๏ ฅ๋(kฺ๛%%]*ีฦ ๒Qwrู๙๖/ ๋๐ธด†ขณ>h(vV…k]เเ‡g^/ฤฑœ๗>-ฏ[oป~*ดญพัึˆท?n‡ๆ‹—Tƒ?๚—แ?†fOทึa็Vึicทก่ฌŠˆž๓?๛าฉb  dม‹c+ใพทQ ??Lกa‘eFฟ+Q๕ACฑ“Š๔ปฦ๐ฝญ`๘ฏ๑C์c``````````hะฮ?ิว๒t†, z@ƒ6žแ@ไ๒ซ’ฺuz]๙3ภภภภภภภภภภภ (LกAสF†š฿ˆ๚‚ห7ไำž@ฯภภภภภ๐ณม๔พHฃีŒwCึv–+E๗Ypุ๗Vศร ภำ^ำฺซุy†?Œ“-r vIะ‰qf ิrถฯ•ฝหงVMG๕฿ิOฃ’d๘ร่ฐˆศ{พๆป|ฉIw่กภฅพ๊ภBฟ๓g๗ฒชธห†.ํ„ๅ„ำัแr}B้JOปg`นไWกc—vmญ๖๕*†าuUฉฝฤmิ{๑แ แมAว7Žlฮƒ฿ผcย#+m์E๎้ตDต/ูืสg#โๆศฦz_ฏทYLบ์ —โf-km฿O-สฆ:้Kว—ๅHq5รb๒ ฟ…•/ตฌmUm=j๛๙๋มw/ํžีM_ก8Š8ค~@†ุi7ูsฬ7:?๔g@ ;z‘}*ตn@่ใๆณษI—ud๋n@€๎๎Eถl\f'้่๒= ฏ1ชธษฒ๛VฒBl.?O*.ฉ0ฬ๙K uGฏม๛๔Q*ศหR฿๛c:pอฒ฿;q_ฦfTงำrศ=ำ๖žห2พ๓า๘^gข.็ภ๛ƒCGIP6อฎKืtyธfํ๒U˜iม๛ืf ฃ*_ุ๛ๆƒวObkwš็ฝaฝป[U๚ฮธ?ใ๛ฃไ^ฐE ัt๒พฅๆ>ำ~๓I’ศMป๖€y๎*ฉ๒}B็9(’๖Z๑ัลoฉS๎\5jมอฌบาZJืQRzษh๘ฺูzพ™‘ฬn1y฿Iฝoอฟžumž๋=NY$ๅžรโ^ัEW<ำ~gฬ†c"ŒVc~*ฮYŒฒๅธเ๙๚ฒYK5,G๕a็Wa2b‰็ข‡๋…4ฅึำ์mํƒ๊rศw4x0f๗ห (f%’Žsฑอ\\`6+K?ศ ท›Ž ฃQ*`เ`xhณ€๒๐กX/ Eœ@ฌธœท๎ำr_-ฉ8ฬC]ก7d๗ต[ืeWuVฆ“ฬ{๊ปgสŸ{cช}๕ๅๅ‰K "L–‹‹๒๓hoZ•2ฒjฑ๙•Eปc„eำ‘QWn๕pค1—ไ†Gฝา40ไU4๋7€๏๏๗ธ์%ซb๋พะ‡wNo˜ิอDสe็1ร๓Žฎ๑IหhำฎิaสTKฝ>๒ฏrญฉCM;า๏ฑยว?4๘์ฆม™ไ 'ืu>7ƒ‚ฮldNศMปเ้แ พfkVŸwPบŽ2สKึํZ<น~้}กH”๛๘cบฬฟž@ s3233233ฒิ๛ŒฐฝไBM๔dZ|iiƒm—.›ษึ€2nป‹4/_ยfตœดฑ0ยฝศฮnภsฦeร„Ÿฆ4qห%dฯอค]gูฐˆ/;t^Š›4ฅxP›.2Iม3 RD๏ c๚)ชŸ‚สeณ๒ะx%AcŒh2-ไBึvY๎ํ่ณฑฏ!ญN๊าQต}*2มม็ถทdั๊ค*\j๖D”]t –ำ/๛ฮทG`5้BLธฯŒฆ๚ฃŠŒ Œ๙4๐_nานญรd"L]พp'ฎฅ“ด่MB !ปž(”ŠscยŸ’fๆบ5r2๕ำ๋ V3leˆ^฿ฏFLหq๒พKพAw#"|/๚ุ:H:ํV„l๓ด๘ตฟ†ถw]pฬ๗ไTŸq™Q”ไAIฐbญ() €ƒuฬQ๊‹A๔…{ขิbH‚RkPะดม‚ค๏lx มvˆJK@๐ฅaฌo\{ษภ๔๊Šิ‹…ๅ’ฮŸธ[D'Yxใ~<ํื•H?3mัิKAAAง]ยflผ'ป฿ศยใิํ{!7ฎ\3ยšถŸœfใถL{y/<‹ฺหษม~š๕,mวถM^พ)ญึิต?ืๆณฒ๑ ƒกžใษณำ๔>{#วVrWํpบ๔๋าNฅแ3šดcๆ๕xถ็ศใj๚tกyผขi7ลไ๖‚ั#—GY/็$k4เฦ๖๏ๆ:ๅnใใ;๒ำNฦบCธ๕k!฿ZA้:ส@*/iiiIุอฦn>็ฮฝ[GVธ5๚ฌแภu3Šw้Dจ.z 2-€ฑฤ๏$‚๗"ี!˜OQึ;ะmฺ˜ฏ‚2ใาPุl"ฬJƒPภl"`6_>{cา2ฝ‰๐SHWฌฯ0Š5aKˆˆk`<k—wิLœ aผฉ มz,€Œ(ทงhQกข&7L>+›”ะfZฅvํ•™ัฏ฿ฦw]ฦธšหัYตtะ•#หCTNMtsvืlพGWŽU WัƒG6ิ ;jŽล๐๖๐0{งแ{“yzšƒฝ“ƒุใฒž๙ภ1ƒ๎พ"ฺjมฤnP๋ท`‰u๔๊aฮnใwgนmšl่LJพwภ'ฆqดl[ฝ|Uํ่~‡Tyz€ภbฮป†๒ช™๗02gx๎พ‘}{ปyŸโ=ษ๓jYฆง๘9Xถฉ๖„ฬล๑^} ๗์าจฌ`c‹๎tI@ธRP๋‰;m ]ึ’-dร Pˆฒ%XW ๘V่ใ๋๏jmMQFฅl9 ›่CI(iีZฒ&0†:Cp๏„ฯ{ PyŸธบX4ก{๑ย&๗–=aโๆฤk'ุrเล_c† 1vิHู[b,ๆ.๚ีDŽ†ฆSทOๅ];่ŸYํlฅี๔‹!a†๘๏i`๋ๅw•พh5 oฉ฿ญ7ฒOApิuuีQปฐs๋ถ๙ห}๙๊™šวฟฯซ6:fŽ๐๒ฏV’า!t(ž๖”๛NE|ศN ~„อฬd%ฎผพ˜,y่นlRnฺใใใ๕ML๋ฏ1Qจผ„)ตm)๖ž์6`ิš'-–-P้˜A•ฟ๔Lบvํ }๔’r •‚4๒หgฒžถ &8อA๙ไสMRฏกฌt<ƒ\ VาP7ฌh‰กไไpฐz๙ช๛ไ๋จPา$ศcๅ๒@ถ๎ณ‡์๎ P.๕ยŸ„ฯห&%ด™ถ$๚ฆ_ผ,ˆ{ผ*อ7VัIY:(‰ฟฒ๏าซR๕ฌิุค’dU W~h๐ {'€f'GใะyhŠ฿žฃก๏3“C๎=๓ภผ™ufุอgนฅยดปัJMญuๅ™ค>dwไฃฟบ'gxลTท*ฉชCช<ฝ^เvภๆb๔๚Qต‚))E!ZญZU,oงHป๔๑รHกP x๑เฃ@ ไp~ๆ“ุญม ฅ”Mi#.ึ” ศ5ฤƒำHsiฌ! Ž˜/„_3ฝเK ˜๊VXUH tตโ’5้?00ิ๘๏ฐ€ฬซวoิษqฯชzผปzโQBJ๊›เำท…์@\ž––š––š๒๖ม๙[/ญฌšศQ๑ๆฏ?๗[8ฒQต…ํก:w่าeเQํU{&T่$์๚ปธ‘P9อgิ๖ ฝo฿พy~็|W น‘Ž??ฏฺNฏด้พ}RชคqŠง]*‘ต2ฅR)›-™วXึฦล$. ”›vqAพPGGงฺ4ิ?”^ย€ษศซg_ๅ—ำยฯ฿Šoูสบ"หกซำ‡{!irข5@ษSTl Z๘6๘ใS$ฟK‡ษO ˜`W ”สt~๑ T>)! Gม`8 ฤ๋—พ,›”T[`ำฮNŸ|ฌขuLก“ฒtPRนศ TQ์(tV-\r?ษฑƒมs์d)ท฿Wูคฒq8œŠ@‰Dยasไ™TxyŽCnฎžฑ}vฎ๋#ฟPC*%ณnแ`ซ8ๅ2’;รZ™๓ฎ๙Š3WฏœZ฿๖ล–ใQๅแ4?ว–ธ๘ *)๛€H”b”ผDi U>๎V‡T{b‡V๗ฤ@ฒ• ุลฤ๋x X@Šk-Y{Šก>ษปyJาณSวฃฟฒxช5้๑๋Gำ๒1!6‡‹ฅRู;@J’<ภจ฿๊ฝcldcฟๆ^fู>ม„-“liยขŒ฿X6ท‘ Hฒ;ธ๖LพuซRำ^wy”‘ฝปšพ๛uห‹ห;*ง ?O]ฝฺ\วŽ†&cŽ‡Dฦ„฿Zdฏห๖ศ “,สพRฤ!๔ิ0ํภfณล’/ผO๒าฮRSSฮซพณ๔  ๔R^~>๘ิl—J?5ะšทo_๙o’ผ่_ bY๖ (ซ๓อฑฎ%ส|๕IcE^Dˆ”~๊ ข\gU”ม ๆqส)ฤบ?๏*e“$1‹%๋YDนปjR`)ส{ๅ/ฉJวWุIฃ3๙~hNวŽ-8ูลG|z IโO‰กE"‘TคลbI$tณ ๊M{าFฐธ0!4*ทS'น‡tษ5พ>1พ6Xฬ%๛x‘‡ซ๎ณซRJœื)tฌ๓/5u‹‡Ÿzฦญ&่4…œŠ%I๘ข{P1๑–„าžชa(!€ง$๛ฤำ‚’Šท2tย|]$kำ``จSคฯŽN[yY`zปฏบb™ืข>ฒ- ๙๏ๆถู้วˆGjM๛vo๚๎ํ;€<ฑชร7G=%o;จWำฯซYต‰ำ.ฏ๖aภฦyํUช7P6๎ึั&'-ตlง“›๓kฟู฿#‹+ๆ joฎร็gf๒–dคฅjš›Sฟ๕>๑โํ์์\ทฤ}8 ;œ :D ฆ]อศ\‡Cp๔บบด+yJ–Z s+}.มัําฃญ๐ีห์๊าnjj–—ž^JฅC้%Ql๔ ๛A๎อ4•” Fธšลฦผ,—7leซ๗โ•่5Dลผ -Bๅ;ฎณž฿ด?@vฅ7yiโX‚ถ6๐๔GF*Jถภแ€R ะ&Q.n†อ`้aพฒi$^๎q›p*šฮผ>‹‹?&ล\^ป#”ป๔๏๚ฦึJชrโ^ฑ'ฯ฿5ณ‘.;Mะ๎-Wๅญิ* |8ฯฅ‹สuŠs๑่าNmทBฉeฺ฿฿<๔๏Œ๙วŒ”K“[ด1F6๔ฎaฮแ›T„‰ัg<7>ฦH^ฺอ\บk์ญึœZ@้:ส@*/ฅ_ๅีhๅฦ‹่H3žXถ) [vหMใ฿พ๙4เKํไpAค๓8fกฤฃ(ฏ|าฃเโ๕ย…ง‰สคา๔ช5iทณ„่ีN”LณŸ&๕าEvํ d.J>Žr่ึ?•ขท—กีdาBค…๐1€Hฌพt4L(สfึต=งบmvTh[)บšฤ IDATฺโ&r)๖ำฺŠnˆฬ}๛ใvhพxI1๋—่ะ์้ึ:์zhญขว{fW[p์ะ„–๕zP๚wDป๋œS‡‡~Xฟ์lb๕ยQ”ฐVฒL,๖e:uB]”อJงj๏-ก๗nžทwวาyจ‡ิ=ขg๗ต&]บใ๋็อ๏ๆล=ฝ2]‹๛F10๋—่ศฟ2ฃ฿•Zk)}wลsDธ]chP๚bท๖ซ จ๐Cภ๊Q{_…ึทฌสZ Š™ใŽซ5@๊ฆl~'T…ซ๘ๆผŽ7๋๘แตฅ>Rค฿0ๆ๎†๏mร ฆภภภP”fฤพฌ^ชR’๘ขa;ฤภภภภภPh๛’่/PˆZFฏ”ั๕ํRถฆ,ฮxU5PจใT503๖ZmLRœr๔๚ะY&10000004h฿ี@H†jฏCQ`๖?00000000000( ำ```๘N e#Cอ๏mDภๅ๒ฝŸŽกมร๔พ5jƒw<Œ{๖oLxู?หฟทQ฿Bฟ๓g๗ฒช8” iดšqโnศฺฮๅvž2<Œ{ดศT[ฺ~zpฤ]Kปguำง}€ํ,ฟ˜ภ•]XJฝถ= ๗k$๛สtฤแPM4*=่ฤ8ณฏO‹z๛?Ž]ฺ=ถตฺืซP บดWq ยrย้่๐๒pjRE'Œ๛,8์{+ไaHPเiฏiํห.ืฐฝๅ๔ี{แwn^1ญ#Ÿn74$ูพkฅฯzุ‰๎\ภอ7ๅ^‡)-๚ธ๙,าyูc ฺู๙kถ๎ฉ๖%ป๚๕วžื2z=ข;๔Pเาuป™๑“ฮ–sn”UVLด๘\ฆฆๅ่ ;U[พ๓”xppภัM้tึJ5ๅุYvcf1้ฒƒt^Š›U‡ญŠ›L!ปo%ป-ฤๆตจ ~nจ]*`5์9ๆห2‹ ฑำ๎๒p ‹lูธธอNาัๅ™]7(žC๊!/1๛ง๊ Ž_ƒ๗้ฃT—'ค:’ง่ส|ว+Pำ~*ˆฆ“๗-5๗™๖›O’ภtเšeฟwโพŒอ๘\๎มกฃ$T1ฑฤƒsัร๕BšR๋i๖N‹๎ถ๖}บคฒƒS+ธหjืก-›tถjZ๐ต™ย(บŒkฬGฟฅN9ธsuึจ7๋q eฺ้\ฺๆนซคVฏ๊Oส่–C่™ถo๔Œ€\–้๐—ฦ๗:u9฿vสwr์7S8อFlฺ6ง๛ฐAT็l s€WyVIx9P๛0อว`ีXโม฿€uฑํ,ฒ๑;โอฐเPaฟŸ๑ํQ’zา๙|wฮปมฮ3ะ๓Kก–ฃ/์Tr;S3`D๏3iH•Wqคoํส&ตฮ๒ ์ฌŠูpL„มaภjŒOล9‹Q6 ๚Cฑ^Š8X-p๛ 8o]\๛๕“A้:“ัคEs( บะx0fWb€oƒแBV อEŒลsH}ไ%fกฎะฒ๛ฺญภ๋ฒฟซ‹:+ื,>a๊ฒ่๐…;แw/ํ˜์ eCzNฎ๋|nู0ศผขฤj๖\z%่ๆ้Y๖ ๑Re็1ร๓Žฎ๑I*ฟ๒8๏Mจ๏ž)๎ฉ๖}ŒB>v=Q(็ฦ„?%อฬu้eใ^~t์ะ •Sซไธฒ๎ƒg`xdิ•ƒ[=?Ÿ-@๚=V๘๘‡Ÿ4ธ!“ค๐ผŠญ๛๖๓7B๕;ฝaR7“ŠUK‚ง‡7๘šMญY}žQJ™vZื)u˜2ีาฏ บ)ฃๅๅ‰K "L–‹‹๒๓DฺM›๑co๛พ/•ๆ<๓ป—ึพฝ5ตฦ’\ฤำภภยvปศึ€4็ €tฐอLาy+ู}1ถh\)‚&nน„์น™ดsขฟ –ƒตกไ ‰@œŠ’žƒถโใๆณษI็ฅธ‰ll7฿@Zฺ`%คหfฒM@`„;{‘€็Œ๛x‘}ผd“T&ี ๚Yฟ|ฟว$ภ็3m—y1 ษด‘ Y;ุeนทX ฯฦพ†ด:)QผQ้4๘อ;&Iธb”ฯๆeŸ#ข‚Œ†bทDุ"โวฺๅ'HุC๏G*Cฐ …อ&ย 4ฬ&fห๎ฦฆ5Iฑ่?M]๛so>“3–H›i•ฺตWgFฟ~฿uใj^#5*GUtfœ›`๏ิ{C้ฟฬมษม~ยฉT9:ซฺฉึฯs…m์ช!๚=(t฿4กญNสJ๕ฃ๏๖ใx์œzF#<~ุๅZX7vึ†Œ(ทงhQa€*๐0*•`หIุDJ๒@I‹.ถ๑9รs๗์๋ศ๛๏IžWหJดๅภ!*ง&บนNปk6฿ฃ+€ekบaOธอŒQ๏ีืpฯ.๊2฿ ื๏1@iไ๑โ่G๏(1ofv๓Ynฉ0-ไnดRSkูศzยตƒื฿“%ฏ=ฏ4nี‚ซgl๔Qฎjญzฆฆล๑๏๓ช{๑ื˜aรFŒ5าc๖–‹น‹~5‘}ก>dwไฃฟบ'gxลศYถายจvุซCแร‡B๙)7๖Š๘›™ษŽฺซ๊y‚ 8๊บบ๊(]ุนu?๋ผฤวว๋›˜rชKVํP0ํ:fŽ๐๒ฏ์dZVAป๗โ…M๎-?zยฤอ‰ืNฐๅ‡7>ต฿๊์wvฑy^ :ๆ€PTMA๔!3ฌค%9๊&$JรG5ฌQŒM๕C3A๘rIูุ!Ÿ? ‹ฤ2Yั Cษ3ศแ`๕๒ๅ่ษืQกคI'ฦส๔kิ้LR0๚@ซ}Knฝ‘'B›iKขo๚ล ษ‚ธวฯK าสKtาAYŽjฉณชๆอฌณ๏๛ฟ("%Y‘ฺอ[ะte้*Uแ๖ซF=Fโฝใฦg…ธ6vึถ๎ณ‡์๎ Pฎ€,)`จ[aUU %@ะึ-))E!ZญZU,oฟฒ๏าซR๕ฌิุ„ }0R(F<๘(9œŸแไ‡/]Gท6ฃื>E๐1๘1_EิPฯ!5ศK5 มO]10@เwgผรFญ๋Rp๕๘Nq8i๙ซD"แฐe%cู8 &1›]Qd _งZูะัแ็็U}qAzšlUM๊๙[/›5H(ผ<วแ Gฝ‘๋ส๋ะไล๔ฎ~ูhฏ{ฮ‘ฑyœ!rŸUแyฉTZแไชžO๓Yฟื|๎BoIbLเQ/ฏ[ โ โ‚|กŽŽ@ีqฏบCกด๓ฺM›nแปhI @ฅ&ญ?ฟDต“[wW=%)งoO<ๅfฟ๏้ฟdโ๕UรolPๆJ…%ชรŽตงžฮ‡Uะ5ล’๛ู;๗ธณ>€ฮ3MSบ7UBน$’jฃฤYึบ_ึาสZฏ๕๎ข6๗ดย.aืZ„๕บๅ’"้"•JฌK.)บ_tฟL53ฯyhJ๔ฬ4ีคโ|?๓วฬ™฿๙฿9ฯ9็9๗šBเฆไภศ•ึฃX5PR๗ร๔/”ธีx๏……j]0%ืภปษ;฿ฯo’t;”ๅxงา+.ฏ$ IฬดูงpmฆNq0–ฃV๊ฌงN6›m0m๗™ฑ`)๒ฒqฤyWฉ ž๒ฯท(}_`NCqูุูBั่z b๋เ~ 1๘ >ะ,@U่มjF, ๙โผาY‰/๛zœบ๔cEynโ๖m๑u๎ k0„>แโ๗“ฎŒIˆMวใฬฃเฝR–„”ใš`ชFฎSํ/‘>‡4#/5า dI๑ีc‹ิณŽ%4ฟx KิbฑXม๛ฃหrrr|Aฝ^ปฝช๎GฤgถtŸ`ปQZRฌข"nคนqืrOxโ)@ํ‹€Šูhฅ๗๓1ฟ์Ud|‘›m?ธ!F๘๗ึตง๚…™hด”อภwน‘ceาล-‹.[ีฤz๖๚ซฟJX์Wฟ”…ฅฌฌX,EฟจฅH๗žC‡้uี?1W๔*ฮ๐ด3็7NOFไุ๒X(ฝI…4อแp@ฃŸณ-'6่ะไrลว”FUBZ[ฅdฃšjZOr ัB๚•š'6~ˆดธฑรJเณAŽ ะžMwฯค๎†!Zˆ๋๗ˆ๏jใŒ{ำ&I๔ศ q•qmฮN Mใ๚:„ข๊RFRฆmZg MkXŽdคณ@vj้\฿ืาH2Vชœฯๆอy˜:์้Fก'า๋ฒถSjAท?.พ‹ช1๐sQaญี ๅ<†* 8 UuจWโ๔&.ทœ็เึ ็ข[ cา=b’ิฎ(L›ˆ~ใ1Fu R!;ี<4๐Y-*ล็Eะตย‚็จเMS’ญ ƒU‡BgG๘่ศโ๕%๏Ye&=9YืvŒนบผ‚ฎศA‚ไdั;^ีุTGžbkูฤ{๖๔Hฺdๆๆ฿ทn๚cํ˜.ฒฒร‘›ฅfl,ๆHฯzŠ๙Jึœ‡j+ฐ9“F›=y@h2n๒ฉ*PŠFร‡๔ฬHฯจDxภB๗ณ/›4IY฿X“Mฑต‡;~V๕™(‘ฅ<2™๎ฑ|า`cM6ฟ$/ฟ”hธFอะะจ8'งบษฐZŠ๔q๒วD+k+k+งํ‰ผภ•ึSฝbLOFJ^& 5FŸCQสfcํอ^&ฟ…A3ืฌf Gัภ~ฦXํ{๑OลZส+U Ji(IตฎˆWPžšๆ@P๚ุยซี ^)h…€ำ4๙จLy>*Lว†Ž /l}lhE)"Zƒ€อsะ Qนฤํ๗ี…ˆ44€ฃJ’IRzooุถฮฯƒnผy๋’“•ูuศศ^\-ำฑ?7ผv9–ไLดฮfมXŽZฉณ1iษษฺŸ}nฬเ˜N๘๛7ลฎมaฎTYฝ็น฿๑ฦจน?OจŸข“นRCcƒุจ –6ๆ๊CๅŒ๒bรQ˜ร.ฑ>…๒ฤฝVไุ -my‹ลzkD`L:FาPไ2ชvR๘9EืฝจวEฃd”–มŒ–โsˆ’=m9šŠYMIถ2@ ศ˜ขฌ–ีCฅA;ถ๗฿ธ๕‚‹บ0๛฿‹kทฤ‹FลT†t่†W^Zย)๗m๗๋†สŠ_=ห.ีฎx–ันVl@udH์rGป.—ƒ๋หณูpร็ซฺ๖ฮฮธ/ก็‘›ย๚uุZฎksชrŸบํB:ฐห~ำ๏—ๆชฏ๐uกmง%ฌแBoืžิ}ณt90ญถมฝž๎q^p"+ๅ๊฿w—ฌ8v]_ฑ:™Uลฅ<*Lz&็บโ๗ฅดไJ^„ํ~ฉม๒!#G{ี๋{ศ(จdŽ;Sาล0x็1ฆ'ณ๗#ฟ\๒Xy๐ฺF%a๑ซ๏๓Y}ึ๓w๓ [g(๑ฒฌ๖d<ผต–ชBจแA55‚P…ฒ. ตูดฝ3 j(กส€ฒฎูdฺม„oPš/*ฟ| ํ๊2ถ TผนNฅฆฝี9  ‹Pฦ1T(q๕0=@[‚Y<๔์7”QศhR3ผท3Švใ‡?พโ]ิภ)?`ฯ‰ผ8;ๅยฆ3แ“ๆ€คL+…N‹มฯฌฝkไb๔bxฑoโผc้อ)G :aิษ(Yดcg ฟ-ั`๑2c|ทฝ[ 2Uชจ๋ฌต_g9'W๘p๛ๅIปcบ๙NE[ุ)5ี(๙"Xธา&]@Xืฉด€๓HeถูŠ้<๔๊ˆ๘73.๊๋[ปธKX™qฯwชฃถฮคฮ‚˜คำšEฒฉ•ภc†`A4 =%ฆgี™;\โrHM6ชฌภ‚ดทcาๆฅๆ€฿๒ฃำŠฝืvี~ื0QJy4vlฅwFฺย$Kวผ +rŸ5v์>ฦMJ๏m‘JŸฒwF>ผI_Nrผ$ฅฏ๑‘!?ะโ…_็oŽ,ioSฤัผ”งบN๒9:!๊;ืSi๏ธ3ๆ†5m=ทซช์:แaZ„vBลy๛E‡_บ…ดnNงณ-่,v6F~๔–ฏbว/ฝ\ˆร๕ฏ}๊>ใฝ๏ทท]\ฎfcGZCฺmŽTทi!((h๗‘ ฑผ๗’๊ณฐแำขๆžeว”W{Aฟฮxล{h ้ฤก)ฏทฎ;ึด0 ิF9ˆบ)ำฦngัูt;จyt+X}แ…›AมAWฯ๏w4 ฉฝ"|๕KBGๆ๗่yํmC›Pา฿}zดewธๅตiFส๓^_฿8{๏s 2ฆฤษ8OTg[ะY์d"'ิsnจg{[A๘ิ ะNT็>ฟทQ•๖คs;D Bk`ภใฦ€Vzo_“ค—”{[คาง์‘f’๔[2@ tjค฿๊ะZ๏fC7ู@ @ ค…๔@ ‚ด๐กQjWlBTlBิฤฺ่/!ฟ • oโz<ศอฒ)ญ~บRซ๓฿™ศฮึฮe0fๅกภkฑa!'}ฎฝZีjฮ๖“—nE฿ผz~ืโa\$^’–มˆŸ8}-๊V่ีร›&›พฝขสp๚กศ`ฏqชuฟญ ‹ŽMˆŠ‰ป๘็ GถŠe+ัแ›ืเณm4€า€ู;ฯ^ พฐ๛ว:โ%›‘tm…ฒถแ”x?{ฺค‡mvำฃๆสโฤ•.`บผQ1:พ—ž&ุ‡๎g๒xเo๔Pวbฐlภ}=้/vื}ผ0รณuฐ{`K7ฺq'mฟ›๖‘M๐d4 +ุส\UฮŸยสโbำ‘<ๅ+†๚ƒฌ๏vxผ{็ปมา=ฤ]&๊:=&gT๖พ9Kฎฑ งva่S๑K๚/ฺ>‹ฟlโีLvฏ้^;~ฒŸ๊Vม(ษจSgสๆ5fทWฬ^๑๗œฝ๓/๗ษั‹ฮไ@v๘อyผ๘†wฟ๘ใซyวาๅ4l—๛z~{+ิ๛ˆtsษX๎t‹]๛]qˆป๏ิคgะu๚๖yงsู นwqยˆอw˜%ฅOบ6ฃฝ8 ย6ะO †์MhO พยr๗J€๖งฺ๋ค/”ฆ4ํXห๛้‰ร„LAƒ• >:4/ฝจ”ฆลz.ภDE&2ภ–.Xgสซnmะค@ ศ ํษป–Yิอ้U„ญqZR ”กฃฦ%c๚i ฒฯym๙;ฎLž๓๛ฎภธูขห_๛๙’ญซฟ๊ฏ…s๎_ฑ๎@ฌฤท‹ฺจตว<†Wž_๛อฤ๔„ั๒โbพzYe ฆฉ๒ ~yIq €†Y/๎ƒำ)e4ภฃ [ูณ๗†ฐ{L’Œศf๕ฏO ๙ฮน)สAƒซg_์›๖๔›jEั๑ฯิœ๕8ญฎšeอ+สญ=๕\4ฝํฟ=าฝŠ๘๋ๅ4žx‰ั้๏ตเNฃคิI€ดqŸ™XทPๅs™JŠ €ธธฯฌg ธฅ๛ก—/๚แQCแ)๗PEcภฬฃ’_ใพžธ๚ค4kซม๊a `ภ}=ฑ‘ ภ‹-จดฎXu๎ืท.ิto%zำ6‰ืกŒึ0บŸ6ซ๘๙อฝ[ฝฎฆัŒuศˆ/3wUงฐูฟ๛าXFฏ]๐ืร~๎!+xœ์พฟรต‹ฃ~_ๅq)fฮŠ_ํ]g[*๏ส2-ัํๅOV/lช‡žF` Ib๊C]ทฎšhฆฉคฆP‘™ฯzyhบ๛ฅž๕x„Ni์พ5kR„ฬ™Aโฝ๋žฒว่y*๋K๋6แŒ้™ีฝA €W~d๗ดึฃŒUTQZ,๐1ภk”[Dkขผ—ญีJึ/ฒ"๋ผoHY๔ณวC›ำyPทrM๏„Sœ็๏ฮw๖rตBษ‡ฆZูL๛ใEษลึV6ึV๓ŽฅPVฎ†=๒˜๑ล่พe_ฎg.Yฏfพ]ีิอ๚ผ—็œZฑน๛ aaมa'ฃ–lปล(ษษฉ๎;l˜:ภึณฑ๎กฎก!F’u ๕๊๒2~ํฒ๘ำG"3เ๗hkซล~ฬgiฐ4†๊๙๊้‹ุyhˆะนณ9Žื^••q๋Oฟฤ ฤV๏?ธw๙ำg…โ$ฅN:ฏฑ๊+ฝ–Š<‚”งa=E)X5™ŠZCล€ม|ฌ ๐ฮ C…ล‚N?‘kH ฿‹”&c.(iu}J/{' ฬ?ฉ๋หจ๋หจ๛๑P•ล2Jกฮ€สxทตๆทอv๓ต[tฯตหฦ(sภ๊ฏ›ๅน'บฯ’ูl฿x”]7่>มYฮwพณำขะ๎+็ฃ@L๖ๆ๙วฦฺสฦฺjŒ•79ม7เQtA`2 โ&Z๘“šVดoๆX‡/fNษ๔]่~ฉ๖ำcโไ.'พsvZjดยe8@lf่ฤ”G๙เ™ำณ ฝ`-uเšข‚Nxw•ดใvฺƒถb/cญ„*>ๆ๖@i`ฎศ+ห hา dFๅญใ~) :๎ุ’่ๆ๙6๎ี;/๊๊ฃขj^vDh‚‚Yo-1‚tโฎษ?}ฟˆW‘s๏ต–ถ89ฉg6ฌ๔ุธd[pE๓์้Dh|ฑฺญ็ญu๓็,๘๎ืด๑›๔gะ1‡ถ=ด๒ :ฝฺธ8#ษ‚ฺS๔”'๎ˆŠˆŠป}nฉ„Eฃฆ?œˆบผgภ๏‹ญึi[บŒrTz@@ƒU@*“wว‹๒ะ๚g‰Oข@œคิI b๙wQu ๐ำPาq(G*]!?j๘P๕ ูXEง@a TCมSVU7#žy •Wƒ0J0๎าิN yKl=บ€:๗8j๓023ห‹Lฬฏช)~|ึk]@ โ๊แุ8ฏฒ29ๆNAe%อฎห๓*เเๅ” บ๊๙ฝวด‘qตhŒr[cตygฬว[t8ไ‡`c>z๔jศาฬฬr„„(u ฃ:๗T}ž•าผค๘Gี]นb3ร'sz"(H๎0ฬๅA๘9ี JIEyQัฉ„sHimศ#Hฃ—g‘† ํ๘+m; jศโXา d~yส7ช ๏าฑ+อ>-šอf ขF€-'ถ}ึล|ฦ†ใ็ฯ_<๓๗ย&&JSย/วeT5ื Nƒ’ญ๓ศ——Ž฿{•™๕"ไ Dg+ ำ.o˜6bิ˜ฑง๔ฟค ภXœ$jท•ธ}>tฤาsEด/‚ไ?งŒ๘|ˆฤ#๖,่)๓ส–๕p›ืท"ฒ8•]ษzะ'๗c~2†+FR๚คLษฎ๋=—=Fe•๏;b!PbวสSึ”ค 6ŸŽs‡ ;๘ดŒaณูจรT๑""โy)4งŒE;K1ๅไ$ฏeึt\ณถ_ศ†=qค๗๐ม`cำ๑8๓"?ฯW•๘ฒฏวฉK'ถzฒX|{รGŒะ'ŸžeIHiFIจ“u๘Eภ+^!”'กœ Pั+YyEนSa๋ฉQi5€,vใ“‚,)พzฬ‘zึฑ M1KิTbฑX๕ iLQ † tฟ๏ส?'M /ฃน3่฿”bปฝช๎Gฤg~ค]9ถ< Eขฆ9h๔sถๅฤ{š\nqqฑ8I&JJJ8ส*l>ptuีrž็5eฎษฝ๛ยหก^vุฦl฿มƒKใNืญ๓U1ํ ๔ ๐~>ๆ—ฝŠŒ/rณํื#˜$ฅO:@ดฃบ +งP แ;ŽˆZบฝ8ˆี„คLฌ|=ไ6U7ฌ.จ.šTYA9_l"999พ@ L IDATR…ล๏แfผv}œMY‚ฌะฎ(L›ˆ~ใ1Fๅ…zpz—Fฮsp#;I0ฆ็)H…์tT๓ะภvณฎ%hb‹้vีžu€กมฌ‚"่ZaมsTPท!LอSฯPQ)€ผ ิศ"ฏ|โRAึYผbV |ฆ''ฺ๋Ž1W—Wะต9Hœœ/๚#?;Gu •žบถ‰!—ภbษ)*)Rภั๊?qจOหะHE^BI6™น๙๗ญ›X;ฆKKโำ(y™\4pิ}E)›ต7{™อ\ณ๒›E๛cต๏ล?'ษDub์หษ๓,ด5-gO๔ 4ขLŒh=”ขมˆa} ณณ:l็@ฯขฟVา“๚๋ื…&ใึ-ŸjกBฅh4|HฯŒ๔ 1’า'@yhม6ศ้เ๋h}%‘ฃึ `ณAม4hT.๑€Ÿ.๚@!เ˜ƒF */ฉ0๗ัEะGz0€า““uํœjqุJ&“ผ.zŽS uชฦฆ:๒[หnไ ณงโ7ž๋L\ณข{๐ฦ=‰้๐CG% E.m๏ ?ยป่:c็ไุ -my‹ลzgค‰ะ ้Iฃd”–-ูวฃไฬฐAo`ฑ€c‚๕๔ก$S๔’=m9šŠ๋็n5Fเ>ŽXž Šฑพ*สฃณ9๙Aฦeตฌ* ฺฑฝฦญ\ิ…ู^\ป%พn†‘wใเ๏Ž›ฝงห—%์ž๗๓ลฌ+๙ูฏ Y๑&๑๔–•ฟN๎ปๆน;+๘๏™:p1zqIMP๊YvฉvลณŒN79+5rษcๅมk•„ลฏb|ผฯg@๖Yฯ฿อ7l๑Ÿกฤหzฐฺ3ฌBœ$#น็ึ{้ฏ]๗ฯ]Vม“+›ถ@ƒ๓—ข—ยำ=ฮ Nd€ูา€่ฅ˜_Qžxq๓ฎฤ้!ืฯ,5๙E`sๅญป์7~iฎ*๐ _วฺv:EŒd3’ฒ. ต™ุึ ฃ*(ธBe–ึ9ฮฆ‡tส8† %N s'ั฿‚0ฅAล ม๙KเA›<฿Hฝ*๎ ฬึ!ป0ภงvRiะŽํ<~9ฆอ.}็Oฏ€7 กaBeศO‡nxuแฅ%œr฿vƒ˜์ญh;๖sีnp8f9ฉC’q๙๏T_ฟXWVf๓]ท๊่'ณฯ]k=ศฆ๖+3 ขQ่)ฤ่ศ์ฟ๓vธjP๒90ŸI;จฐrฯPuGึdฃส ,Hƒ๚M˜igฺll7 PๆQ”+‹มค ๐๖P–V์ฝถซ๖ปล7‡คT‘z}Gcว๎cZใ‘V๊”{[ะฉ๔){gไƒ™๔่Ÿ…ต_พœไx)HJ_„Oฦาฐฆญ็vU•ยว{DV3ภ}=qีn*Uาุ9ก•ศ๖๒B{"?zKศWฑใ—^.ฤ๎แ๚ื>uŸ๑๗ฎ ำt_Qrวํะผ๗’"๓@ ’šGท‚็/ปp๓{พบ๔ษั๕Iํmแใ‡๔ะq@I๋:๎วย๏ั๓ฺ‚Œศ ๕œู๊V>5ศi@  -b็FๆK;Uฤg8 •[iRอฦŽCฅ๖ดาคVzi5มตS{gไCeฺGาD ๐ฑAๆ@ ‚ด@ @า „NRตXr<4b๓็๕. }พ๖:y้VLุอ+‡ทLํ%/^ฉ[-ฺ๓ฟkทo\>นeF฿.t* ˜ฝ๓์ๅ๐˜ะเ ปก#A’ ื“๎ฎอ๐‡าXฺ๋t โงŽึ”ฟCึ‘K๗ใ฿1ษN?์5NU†:M\นYถะfยปศuวWำŽปh‡ตธWฟ๖ถฆำƒ๛zา_์ฎ๛xaM0ม๖>t?sวฃ‡:ถฏ‘อD ๗\D{ำ#ฐ1coคิ๓—กS`8qำบolๅŸ>ศmเศไถ”{๓‡I๓SY=gํ8๒๓ฤฐฮฝa”Tฐw฿b๗rร7kŸ)ฺ-฿๏ํ๒๏ค}I4ฃdื้k\ุ็]œฮe+ X็ล #6฿a–$tP ฦ3ธฑ?^ Q(;|ๆ<^ผฤ›ภ›ซ“ ;Œฆa*Š Vw<๘{\ธฝก›๖EภK/*ๅฝ ท†'™‚ *วฎข3kgฃ˜ใˆeŽ/ภล[Pฉ˜๑้%ฅ‡ฬ?Bง ๘EdเžE›ุฐมงฯUNธ๐ฌดฆฆ()2>ะจซ8ษAŽŽฉ|๒+สำ‚O^ฃฬฤIขWฝœฦ๒‹ฃาFฦZโ$ลฃ†๛ญกGJ[ฺ}นน3p๐zŒh‚qq฿e๔ศดรZำฌึ'๎๋I๗่ƒ๛ฏกฅ ๋ฤ๗รถFใ&pƒƒ๎ืท6‘ฮHฟเศ๐ำ^_uฃ,Cขใโzป Uฎ๗e้rลฦi‹฿ี๐๐3ำzฐšฅำtแนฤhฟ%f:ณฤ%Fว%Š&((CวU‡ฮŒ พฐหีZฝ€ยยNyN2& F*กิ8าP๓Š1๎ข"VR}จ๋พ มaก11็ฏxORf~š#<"vธLฺz,เภ”มN+๓}O~9ช{ƒ€Z\ูษฎSฤบ–‚ชซ ๒สฦXว ๕’อ€[@่”'…\นZฎใฃ?fธ๙็ ตž=ตKŠ‹ลHช้่เผjห๏vญา$/7W[GGœฮŒ[๚%V ถzมฝหŸ>+')–ฎ# ็0u็ค๒5ๆRู(jีa่๚2๊๚2ั๕า๚Sฐj2ต†Š ƒ๙Xฃฎฏ`` ฉฟQแ{‘าdฬ%ฏฉๆbๆ4^>๘๊ฃ๚Fใ/guฝฑrฮฬ_โ{ฏึ†ผGX[-๖+xฯg‰“ปœ๘ฮูiqจั —แ์ๆ่L>4ีสfฺ/๒N.ถถฒฑถชฝZyส5ฝ6Nupžฟ;฿ูหีJ๔ˆปOp–๓๏์ด(ด๛ส๙รศ#f"๗ *ช@ภ๎ช~Aท?.พ‹ช1๐sQaญี ๅ0]ช7qนmไ<7i๏โ4ัฤำ!ํชญ)1ภUฉŽjุ^ฦตˆJจข€ฃPภQ‡ชโบฟAื žฃ‚7MIถ‚OพCJ U5ตšP8ๆ QƒJฅ=่“ฃ๛ฌ๋|VQ|๋ฦถuvxtใอ;‚ส๚ฦšlŠญ=๑ณช็ฯ@3i†ฮ์ีvVzฺ๊&†\ค''ฺ๋Ž1W—Wะต9Hœœ_+จjlช#Oฑต์Fโ={ฺl“>hl0uภาฦ\}จ—JrlŽ†–ถ<‹ลbฝy#4 ไฬฐAo`ฑ€c‚๕๔กคพ?Lฃd”–žึตŒ๒bรQ˜ร.ฑ>…๒ฒD(ูำ–3๑ ฉ˜ี”dk ๓ะ9ฐูpร็ซฺใrvฦ} ๅ?<HqผOโ๘z™n6kC˜$7ล„n฿ุ{๓ช“มZ‚ด่cnG’h1:7:ฐห~ำ๏—ๆชฏ๐uกmงSฤIฦ0™‰ฒฎูdฺม„oPš/*ช[ LDฯะ–ฟ`=๛ eBึค6›ะE(ใ*ฌ“ไNขพa>J;‚Š;ีš‚IQส“๔bnล“๔๊z'Eป๑ร_๑.j •r๕๏ปKVปฎฏX~๏ฬชm‰,CLซ]ฝž๎q^pB\“BZผw์ํ?]พ,a๗ผŸ/f—ํุใึ .๊ย์/ฎ/’T๒ำก^]xi งท'ธ1ี(๙"Xธา&]@Xืฉด1’—N๕๕‹uaeฦ=฿uซŽ๛แ,ํิ ไs`>“vPaไžก2Šิ SŸ๏–{ฉฬม6[1‡^y{$kM6ชฌภ‚4 ›’l HAAกวN+๖^U]J๎ži์๘๕ญ๑ฮˆ๔:c“๏4vjj+ฅ๗ถ •&uภujZ™i๋‹ษ—“œ/ษฬ,ยGciXำึsปชสฎAm ƒ๛zโชขšอBลy๛E‡_บ…๐:ดNK๗น jh"ด๙ั[BพŠฟ๔r9 vืฟ๖ฉ๛Œ๗พ฿v}Th˜~ >nQrวํะผ๗’"๓@ |จrufฝ ;mฃ“ Kj žฟ์ยอ๏๙ ่า'Gื'ตทQ„า Bว%ญ๋ธ#p›%ใ;ฮฃ็ษXๅงLNจ็Pฯ๖ถ‚๐ฉA๖O@ i;ภธเž‘ฬB†ณ9Z้ฝ•&MŽ–R’q ๔I๏]z“iฅwFZน๛Bzา{gD๚ธ1ต‘Rฒ•™–@ ย'U$ฺ้E™R๘กj-d@ @ H ้?„ถ)๊๋ฉตทm…,ฆว!Cฐนmข)cฅŸoหfksฒิulอ`ะš0฿นํ๚ปtำๅ๔จน๕็„โพž๔ป๋>^˜&˜SIั YO๚v๔ครlq’&ุ‡๎g๒xเo๔Pวv‹IKPย=ั๖๔7l,นเK/)5ไ%AฦZ๔-{”Tา„Tสม)sฟj่ข`๏พล๎ๅ†oึ>Sด[พ฿ๅ฿I๛’hi›—iw๒’ 9sื}๛~qmลeฑ7ฯฟ๘ใซyวาๅ4l—๛z~{+ิ๛ž,ขS‹ม๘q7๖ว š๏“2sทึุo๑ ฟt!@ื้k\ุ็]œฮe+ X็ล #6฿ก}๖_ด}ฝูฤซ™์^ำฝvd?ี#ฌ˜’N2jรืnฒ‹๔ํ‘Cv๘อyผx™]k\์1#kัม฿6ๆฯ^yต o-0œธi7ถ๒Oไ6pdฬ6า;r'น-ๅaาTVฯY;Ž<1์‡sขkn5&,Ÿี%ซ>,qƒะฮดผlv€€>˜๑œฎsh“พPš๒พ๛K/*%—ษกSษpๆ]ฆโiaซตX7eT2Kn O2 T~0ฃeฮฌbŽ#–9ผo{1œ๔’าCๆ™ข`๋๊ณ~ฆY g9:ฆ^๐Mศฏ(O >yvp0๐™๙ฟ—/ค”ีิcฎ„ฮC=‚ข่๘gjบzๅq{โฮ ๑๗๘แbเ +ฆ ฯ%F๛-1ำ™} .1:.Q4`Iุฏห๏ฦํWฯ:ืRๅ]Fใ&pƒƒ๎ืถ๓ป๔Ÿต๓์•ศุะ “ž Gt•ผrGัa๎ดโ#›า๙"๔*โฏฃ—ำxB~Qb๔CฺศXKŒO ณ^7Sสjช ส<ธw“qo าŸผaตฑช‰<€ฺ้‹ธxƒ.C฿-@:#=‚#รO{}ีIwฑqฺโw5,์”็$cJb+๒ 4๚nFฏถะจซHฏยE฿๗๋Ww)q3๎๋I๗่ƒ๛ฏกฅฺ‰.xE\w=r'ํฐ๗4‰"Mg)ํฐ“๙ ึVxืั›ถ_Mบห,๙>R)›๐6'Ÿ๑žฺฃvฦ2t\u่อ่ะเ ป\ญีFxD์p™ด๕Xภ)ƒV ็๛rะœJ@}จ๋พ มaก11็ฏxORnXdยรฯxO๋ม8ใ฿งห˜฿bฮิฎa๖Ÿ€€Ÿˆ)†”‘ใชฟn ฝrp8Qeˆป(šgoนโฟสN4'9๎๏ีœ PJสฃ็{ฉ๚R"ฃว๑๑PSBะhะUˆ/กƒšีฝA @ญฎ์db]KHAีUPyecฌ#v&Mzษf@๚‚,ัzX “้.๖ŠMšธœธq+"๘สฅƒ›ฆ๗V5œŸWm๙ฎ๕_šไๅๆj๋่จซซ ไzอ๛๕์อ›ทฎ๖p๎&Eeฯา:จ็ซง/ชส๏D๋3ฬF@o่0ตแ0$šje3ํy'[[ูX[ีซ<ฮฃƒ “GŒ›w7หkyC•fNใๅƒฏ>ชฏะโ>Ÿ>ร„Qำ–ํWจ…ฤU;lปq๖Oƒo68Q"ใึŸ~‰ˆญp๏๒งฯฤ6Q’“Swุ0u €ญgcC]CCLาIพืท๑}—*z<๐mcmตุฏเ=Aใ/guฝฑrฮฬ_โ{ฏึฆถู'8ห๙ฮwvZฺ}ๅa”ไธำIืnRฮใฬกํ(O นr;ต7ฦl#ฝ#<๚c†›>Rู๋SปคธถƒJ™ฬ]>๒ัžร๗k๊๛8˜้jฏ๖Pแ๛Q—ษX› ?ซ&SQkจ˜0˜5€Tฌ–BEญข"FๅB‘_ฉX-•บฝŠŠนพลํพ™๐Nูใ‰sป‡ญ๚f–G‚้ส๏Fฐ@yส5ฝ6Nupžฟ;฿ูหี ฐ๚๋fy๎‰๎ณd6wceืญ9•€มไŸฆํ›9ึแ‹Y‡S2}บ_ชอ–=&N๎rโ;gงลกF+\†ณล$ฮ๘FT‰ˆ๏=ดถ32L9*๒ˆ)†*ใึš?6qฬืnั=ื.ฃ,.๎สใื™฿฿<อ~ฬไŸRD5ƒฤธฟCณ*@i)ฝ๒™ๆzฌคทำ๖ดลp`‰๕-ฃวัiiœJi‡‘ภ‰v๔ขเอ(ทFฌ$”ก7ฌฅ\ST๐ผ}์o!JภมจZ€{,ฤ]u ชิ[-ูH@r–๓พฑdจŽ™7ลP‚“sงN>o๖L—eM~^๕uWG ฐuzถ4Qๅ ๘๒ค0จ฿ืีyย์Mšฏ[9Aา!rฆ?œˆบผgภ๏‹/J"รŸXูXณิl‡DD&Š่3๎ี๛อํเ'ๅด ?ไzœF_๓ญC‹ cซƒฎฝข(Šญขฅฅ‚J^Fูฒ#Xโisฺ††ฉ)๏OšจLw/"ศC๋Ÿ%>‰โF†่˜CZy†‡^m\œ ‰I:ฑ˜}ฟ๓{Nภมเผ&gj3ฏ์;๓๚Mfd๘=ld$JไW/งTะUฯ๏=อ“HŒ{jjชNWCvSAษฦl#ฝ#€ผพ๕ฤ6๙œ๗ฏบŸฯลืš–ฮฌ9๎เม1?ฑd\Fe• L‡b>VTP้ ๙ Pร‡ชGPศฦ*ตŽ†Ÿ|!rW7Eฅา†๊๛P ŒU?ฤพ’ฮสปe2ƒ๖‰Lษหˆธuฏoภใ^ฝ๓ขฎ>*ชๆeG„&(˜๕ึใ๑*+“c๎TV๒ุl๙ๆTฅ™™ๅ!Q๊๕๋ฉS๗]xVJ๓’โUtๅŠ Hœ๑)8ศf0@vจมํ๗iS ฬฬ๒"๓ซjŠŸ๕ZB‰‹{ท}๒ฃฎ>*ๆ๓หRSฒD-Kฆธ›นœผัเใ3Eฃ™`k@ษ;ฉ(/*z;•p)Mข ลVฒyๆTาŠ•ขุิs ?ซณฤJ‚‚$เร\ิH ฉรม–0 TLฑ’ะ ฤฝ}ค—l็ิะ.hL๘vขP}็ฬrv๋]1ีฟ4'[ด%๋์ตงณz๕๘ทฆ†ลbUpทฟ 2UŽ_]€ำq—N?+BI๔ูkฉ',zƒฟุk*’œ2๏X:’ืต๗8บgมา9‡_B^ฤํtื!–ิMั—ใ„โผ›อ6˜ถ๛ฬXฐyู๊wjS–ใJฏธผช๛ํทuฏ๑ฯnพ.บ‚ดฤ#>>ื^๑™4€ฆ&ทnHปeฒ๖gซtsZไบ๚๚๛ณตะi—7Lปโฉ(/ไU)M=8ฯ ‹IบLqกฟ8๐฿kŸop›yeษ้ืb{N ˆ’F(สษ‰๊EŒELใZG‰q็—–๐455>ไzๅjฆl#ฝ#([ux›]ฦฅ]Xท7*้ €๓ูโLWญษhะba|R€k{˜’\๗ฐ(`Š๕ึฑ%Fฎด ภช’%๋Dผ_6แœŒl6ปQ ฐๅฤฆง๔••๘ฒฏวฉK?V”็&n฿_็ฐศิ†,ใ( L๙~่ญ5ฌwฬีx!€˜bศfณั`Dล‹ˆˆบ5Žปœœ\ฝฃฤธฟ:ท|ฦ๕†ฉUUTPิœ ฐU๐‹@คนๅd`=1Uฅ Gง…!•สฑม”yUะ(๗ Zฟ'*~ฮ$YP–„”ใš`ชFฎี{>$| Y€ชะƒีŒX@‹หˆาK6า dEทษำ y<(ž2j๏ซŒจ๕วm\ห=ใ‰งตU<€’<––ถRmฆญญ“—— P\R‚ึiBก๘@ธ&๗N์ /‡>xY ท# ึo ื21—ทuMcŠj8€,าN-๋๛๚}urCœFe\›ำ ^™tqหข‹ภV5ฑžฝ~ว๊ฏ๛‰4\ZRฌขาp-ฑŠูhฅ๗๓1ฟ์Ud|‘›m?ธ^๛ฎW๎9rL฿สปืc3jป]œm9ฑA๗€&—[\\,&้ฤ#H=ตn฿เฃŸw๐ฉTcKrrr|ม๛u๋[GIqg)++7๎,ต-ŒูFzGปำr๗8ฎธิpKEฯกร๔บ๊‹˜+๚mg~xฺิ๓JG3@ดืOY h! Lฟuฌ{–ˆโืจิผ%ศงDใฒษ„@ `ฑDk5X,V}#›QRบJ@oโrศynญู?ฯl๛•@ndd๔aๆตฌFnจฎuc*† ฃIuัิ ส ส๙Œq …o%๋jAฦธ—ๆค3œฒะœ ฐhb‹้vีZ€ฤVvฒxฦT’  ฎ๏‹-1=S!;ี<4๐[฿:*กŠŽ@Gช๊๋dEะตย‚็จเMS’ญเ#ํํภ๋#sGุึ}V1w ˜ฏd=มyจถ›รํ?iดู“วฯpBxธูไor•”Fฯr’ {P๓ แ‰ีคYฝิ๕lฆ;=H|ฺค”ขมˆa} ณณj฿ตฏ"ย…ร\ง zyง๊ญP~vŽ๊@;+=umC. า’“ต?๛˜ภ1บ๑๗o๚‹ฆตูถฮฯƒnผฉ๗‰Lฆ{,Ÿ4ุX“อ/ษห/ฅ$์็fgฉ+ฝušŒ[ท|ช… ”ขั๐!r/๚ถ IDAT=3า๋ฎ๏>kฃทว:ŸUc๊ถ4( šนfๅ758Š๖3ฦj฿‹*&้$ณ/nู๑zยถๅƒปHSึ7ึdSlํแŽŸU=&ŠญชฑฉŽ<ลึฒ9ˆ๗์้›ฆโnhhTœ“S-ูYร˜mคwTUSซษฯ{ฏ๔ไ‰V6ึV6ึV6Ny+ญงzล๘8šCyh 6ฬAƒFๅฅ•๙ภตŽ*่Nxปบ< 4อ ๔ฑ…+V#ร\ฬ4*›ฬค''ฺ๋Ž1W—Wะต9Hœ,ถฑ+u% วๆhhiหณX,ึปรญ5พQ%YแีC]ง|๖๖ฺ2s1LONึตsจลa+™L๒บ่9NM\ณาำ๕‡Ž์อๅvwฯทŸ+KŽ{#šWถ‚r3รฝลŽ ึำ‡qE<ŽN c*U ๒rฌk9ฌceูำ“Fษ>(-ป=ใั0สˆ Gaบ ฤ๚สซ;ํBษžถœ‰Mลฌฆ$[ฉ˜ „/ฏ_‡ญ๕๘็บ6ง*๗ษอญ.ไ/t๛ฦ›W ึคEs;’D@๖ู >ึo;Ma๎ร+๋ผฎK:ึli@๔Rฬฏ(HOผธyWขศ๕iฤmอS_lฺฬkhยƒฟ;n๖๖Ÿ._–ฐ{ฯณห‚v์์ฟแ๗ %,^fŒ๏ถตรŠvใ‡?พโ]ิภkaา39ืฟ/ํฆ%W๒"l๗๖KฬS๊ตTG†ฤ.wด๋r9Xt.^ๅญป์7~iฎ*๐ _วฺvบ๎ศ‘ข”'้ลŠ'้u-๐์ณžฟ›oุโ?C‰—๕ `ตgX0&dŠBถlzzวo=BCLซ]”ฝž๎q^p"+ๅ๊฿w—ฌ8v]_ฑ:™UEW*C~:tรซ /-แ”๛ถ๛IŠป‘ฃฝ๊๕ฝš4งุlธแ๓Um{gg—P๎๓ศM1Lู†1/19"@Šใ}วืqรอfmcเŒฃd]@jณ้แ_]„2ŽกB u้|K9ภk_”9n(i๏ จ Bจ๒OpOfส&#ฅA;ถ๗฿ธ๕‚‹บ0๛฿‹kทฤ‹]ฃ!u%q๙๏T_ฟXWVf๓]ท๊่ฟ20พQ%ฉถ่›๏u\ฦbXดc{?_N‡iณห_฿๙ำ+เธธํ?1rs^žXu"rฺIqg Y ดhอขูิ~ลc†`A4 =…’ฯ๙LฺA „E{†ส๗จ[8:/5ฬฉ”๒๊๗5ํ0pP…ภ$ฉ&~Vง3{ฉฬม6[1‡^y{$kM6ชฌภ‚ดท}[q’ญ)((ิ๘ัiลkปjฟ1ต‘Rลไ่ฦŽญ๔ฮH[˜4ิิถฑclฒุๆ-๖ฉ$ฝwFgค-Dzฺ7‡H๖ๅ$็ภKAR๚jไุl,ฏ็เ่ศ๙kBš?ฝญโผขร/BxMหŠA~ ๛ล ฟฮ฿ูิ• K๗น jงjช๋$Ÿฃขพs=•๖Ž;ciXำึsปชสฎAmL HFeณฅษ๒U์๘ฅ—หฑ{ธตOgผ๗ึ่$ด˜ึ?B“pน่๚พ‚‚6฿j{I‘๙แใE้‹ํ7ื|V๔ฤ฿๋—tิF9ˆ:ณพU๏๘š๛{–๒ัฟMY์๛ธ้ํแ?ํ_;(q๋สำiM ฒ@eณฅี<บ<ู…›฿๓0ะฅOŽฎOjฅNB‹i๕ใ Z้?/W—ปฺ %Kฦ๙ทฺŠ๊—๎ำฃ-ปCง๊<<๐=OJQ๋๋g๏}^ิฉโG่ศฆlถ0 œPฯนกžฒีIh1ญ}BK ะ๖T็>hๆvNDUฺ“ฮu๏@ ญAlมPWWJw“e๏‘ถ0i˜eฦŽ™e/ฅ Hz๏m‘Jา{g„ัxFB3,๑๏kGJาง'#ํ›Cค๗N แใƒึล6yi(่4บษ๙ญ@ AZH@ ด=HQ_Oญฝh+ไนz\qงล๐ัA๚ย‡F๙ซ]ฑ Qฑ Qwฃkฟ„2ดฝjC(ฯW?ฝถ)ซฮฉZ,9ฑ๙s‰,CD้›ถสTญๆl?y้V๔อซ็w-ฦ;ืว ฤ๕v,…ั;bฃ}็้‹2œ~(2ุkœjƒ€Žkิ๒ช ฯั ป็ PnนŠ€๎ ฿ฤ่ธŸmฃ๚|ํu๒าญ˜ฐ›Wo™ฺK€2ณ๒Pเตˆุˆฐ“>‹ื^ .฿ํ‹ี‡ฮ…D‡‡6ณ/GbhJci๛ฏeqฦxCด๐ํดๅเ๚n“:ZSY;Dถ›฿๊_:/Gา๋l&ฎวƒ,8ดถภ* ˜ฝ๓์ๅ๐˜ะเ ปก#•ŸถHd้@zุf7=j๎ว˜u ื“bwว ืžฝJ้เพห่‘;iว-๔€@€ ถ๗ก๛™€<๘=ิฑอn>Jธ็"ฺ›แ†%–vl้F;๎คํืbS†ต็-์Ÿ&dŒกE฿ฒGI.;(๗_1ิš{ร@g…2sทึุo๑ ฟt!€แฤM๋พฑ•๚ W ฯ)งฬ9ชกKEgั๛—Mผšษ๎5kวO๖S=ฤ^dF+ZXภํฌฯ† ’ฃ฿žญšพs/พTŒทfS์1#kัม฿6ๆฯ^yU์ๅพํM~ภrง[์ฺ๏ŠC}ง&=๎$ทฅ›?LšŸส๊9kว‘Ÿ'†p๎Mษ•ฝoฮ’๋E,รiฟ]˜?๚Tลi›—iw๒’ 9sื}๛~qmลๅโ…B๔โ4_|ุ@;<ใวุ/ำ[๖คาูฬrิvถˆฎำืธฐฯป8หVฐ๘ฯฝ‹FlพำิาํhผมWXฎใ^ ะqy้Eฅผ๛’1šƒ๎Rทd„?๛๋% ,ภภํƒแ Bฆ ม‚ส๖1ถ…่Lมฺู(ๆ8b™ใม p๑ฑร๕\€!ˆŠLd€-]ฐฮ6”Wอ,)=d@) ถฎ>๋gšตd e่ธ๊ะน›ักมvนZซ@ํH›‹ำฟซaaง<'ื—XตQkรฎžัŠ%V_‡@ัa๎ดโ#›า๙"‡โ‘{wob‹š๏fฝธnฆ”ีT> บ•=xpo๑ยIO †้`ac‘‘T}ฐt‰Ž‹๗?่ํ2๔ูค3าร/82ดืW(‘$Cสw้?k็ู+‘ฑกA'=Ž่Zฟjฉ๒แ!ฯ@ฃ๏f๔๊ธ{฿h^Qn^^n^^nพส˜้o>—๚\ๅ„+ฯJkjŠ’"ใณ บ@yq1ฟชฌฒำีๅ๒’โ๙Ÿ™{๙BJYMMั?ๆฺ‰๏<่ใฯ}่ฯใ€ว๘ะc|่๎ฺH๗YJ;xำ๖ซฑIw‘,g=j.ึI;์ ?Ÿ‡ ๅ‚ป~Cึ ]O›vƒฺล1ปi๋˜ซX๎๋I๗่ƒ๛ฏกฅฺ‰n’ๅ˜ใม๋้ั;้ฯ—`ฎŠD“ธข๑H‡ตธง™x“:4Fใ&pƒƒ๎ำ๏ฬZๆ;ื@Lฆๅฮ#b๓WŽฟ๘G…๘mซ'V's้h\Ž™๐๐3ำzฐฤ๊d*\สใ๖ฤœ)š ่๑รลภVLžKŒ๖[bฆ3๛@\bt\โi‡:“ฮxO$นl`z๑ืัหiมYฮwพณำขะ๎+็ซ+ฒš=๚vUS7๋kฑ7lปq๖Oƒo6>+O นr;ต\:๏&.'nŠพr้เฆ้ฝ $'งบ๏ฐa๊[ฯฦบ‡บ††x฿…1ั5C†้š ๛,#:ฎvไ๐๗hkซล~๏Ÿฅaๅฌฎ7Vฮ™๙K|๏•฿ฺˆ>S^wŠ๛|๚๔FM[ถ_ก ๚ tาต›”๓8s้"ึžศ;›sแx$เั3๓Zฯžฺ%ลลsjลๆ๒๏/„…‡tŒZฒํ@]]] ืkฏgoผuํฐ‡s7ฑํŽlตŒŠ ‚๊0t}u}•š ?ซฅRทWQ1ื ทธ~7 หXทจ๐ จผึฏmึ›๏ *0ฤX่Q,่๔”ดŽบพ ฅ—ฝZWxต‡ ฿บLฦฺ,„{ฬย%'จ[ฟPฉ(cีบ˜0ฒrWขขืlœ…5HP OAX ”ฤาŒหจฌ„้PฬวŠช=๓ค^ฆ€ฐ ^GMR›Oฅ+ไ'@ ชA!ซิญไolR‡ลbยุ๊ k—t‰อดU WƒRytiาวUะ`;K#Œฅƒ‘T}ž•าผค๘Gี]H6าูธp•D†?ฑฒฑfจู5ˆˆL”ดฆ(3hฯ‘ศ”ผŒˆ[๗๘๚\_2›ค2ywฝˆ ญ–๘$6ต*IŠDnไ‡`c>z~ฏIมาฬฬr„„(u ‹๚…๐ qใ๑*+“c๎TV๒ุ์๒ไ”ผ“Š๒ขขทS ็า$ฺ €ไฑšลmข๎œDjำiƒฺ๒Ž  ธร0—5ํlw๓`K˜*ฆXI hPโ*+ฝ<‹4\hว_iiP๓@ๅŸฬิะ๖hL๘vbํ:ช๏œ๙Cฮnฝœ๊ˆอf ข+Œ[NT`,jaหษีูา”๐ห)ฒฐบMัิไึiท~iNถh‘SึูkOg๕๊ Iง]0ํŠงขผWฅ4๕เ<+‰c‚ฯฃโบํUxx^1{ฒฤฐ๊S^(ึ'rใ”ฯ๖บื๘g7_]AZbศŸkฏ๘๕:๘ฅ%€’ญ๓ศ——๏ฝข2O๘๎„ณีพ‡ฏำq—N?+BI๔ูkฉ',zƒ้รล”นาz4ซJฝ๊า $L(5‚จ3ฉ:›`ŠPxึ„Iธฎ‘Š…@5Z (2ฉรBYŽw*ฝโ๒JขฤL }๚W‰:K# ‹ B๕‰ว “กZห‹ธ๎:ฤ’บฃi;๚rœฤ๋šT4๕็[“ส.dํฯV้ๆดท-ศu๕u ‡๛K•ศm›Žว™G)€ไณ ่ฌฤ—}=N]๚ฑข<7q๛ถ๘:w1ใ€_ขL^ˆr2ฐŠ@2#€O)สฮล๊]!“P–„”ใš`ชFฎSmR็อT…ฌF`ฤš/Vถ๒.ŠŠC,6kภ่Gฌ!‹ˆ’ +บMž6Pศใ๑@i๔”Q{๏^•ฐ๚}‹%jมฐX,เQ1999พ พ‚P1ฑัซ๊~D|fUk oCJKŠUTTค“U๎9rL฿สปืc3j๔วm\ห=ใ‰งต/B ัฯู–t๏ hrนล’:'เ฿[ืž๊FdขัRŽทผ›ศ+“.nYtุช&ึณื๏XUยbฟ๚ ำ,eeE‰๖t๚\wบnฏ‚Œiน{W\jธEŽ-…Bั FHำ ธคผ}๋…wฟ7ฝh!~}€Jอ“I,ฤฃŽ{„ไ-T8#่แ&M˜T?…( %ฦจ"7ฤiTฦต9™๕4๋๋Šช‹šคLดฮwd*-ฐSŒฮŒ‘…ฟ๋7k™ห`hฟŒXšฌ?๋P1ํ ๔ ๐~>ๆ—ฝŠŒ/rณํื#ค7ž9‘e>p5@๑gฺD๔1‚(/ฤ0แฌ7qนmไ<ทŽ=ัฤำ!ํชญี0 €Jxo8ฏ~์R!;ี<4๐CZูj*กŠŽ@Gช๊฿>Š k…ฯQม‘ƒš5ฆžกขRyจ‘E^๙”:คB๒๚ศวถu‡Uอ้<@zrฒฎํsuy]ป‘ƒษษขwผชฑฉŽ<ลึฒ9ˆ๗์i]u`2s๓๏[7ฑvLูFBฦไfgฉ+I#ฺ}ึFou>ซฦˆถŽ๓•ฌ'8ีV`sธ'6{๒๘9( šนfๅ758Š๖3ฦj฿‹*Qฉ๐…๎g›พ]Y฿X“Mฑต‡;~V๕™(‘ฅ<2™๎ฑ|า`cM6ฟ$/ฟ”hธฤยะะจ8'งี‡Zด-zต’žิสซฟฝ๓Ž‹โ๘๘›ฝฝwAA+6ปXc‰-ถจ1FMŒŠ-๖ขขišˆ&L์ฝPขฐQDQz=z/Wv~PDรC@ภฬ๗ร์›7๏อ๎ฮN55Qnฮ[Kู‹โ ป fภฃ(eซแ.V ๑ ขศ'/วM๋คฆ จ๏๗ด ๑๖๑‡‹Wœ๒1PฌJ{zv๕ฮpY9 b^ฑฌ8ธฤL›]็hฯีzำL\T}ŽD6=ฯZv[ซค๘ธบพ]Hq”g๘จ:฿Uฮ๋ž๘แ๊†•ว๎lๆK‹’C=๗^@ๆนMžfw^FSš์ึ๚]> 6ฅแ่UWฺแฬขW?ข๔\Bjำiw@U๏G•5n+Llณ›Tdm ญb7SษŒห^ P|0e3ถ.AฉP/zำฝฟ‚ะCH(คC.D้งPAปšผŠG x~koaฝ k‡O๙หๅ้‰—ถœ 7zhๅะษ๘v0พG๒๋Yลฺหภ๛šs'ลmู*ฌ'*๔=vะm๋+SธฅOอZ~™นž'ซ|‡Š{ฟpูr๐๊LUค<๚}็? ฬ•7“[•๔ว“ผฮ‡UOB“Vค?๕Zฟ๚dT+ีšˆPฐJปชดฒฯR้…ฉCJำ่ฃ!ม_(ซ@งyVดู‘ส ์ผำ9(๙ฤ๋อ[E™จขKR_๗คžEjำqXš2Nข์ๆ˜ต€^o฿ฒtฤŠ#wTYฟ๑rชธ|ๅภ&Fgค%LšุŸ!๐โ}yM’?zKไ’ัa4ž‘ํgvฟhcสpI๓“‘ึ}BŽ>fœ๛๕ซ7ๅŒ๕Aด3"ธ<.oRุ=gkPใ†cZ›ฦๅ)4,?R๏Ba|mะผ๕‘"๓—BK"Š8ผ์”๒ส“ว็viใGU|0พ;๛ฤ”ํ๋I}ฟ0ะจ v๏|#จY๋ตญช“?tOะฝ[ว&9ะF-“!อ(๚žท๚K^ฟ้}ํๆํ‹‡‡ไœผำฺF>}ศ%ก-นwศฌึถกฉT%\๑˜โะฺี๒ิFไผ0ลg๓๔#ฑ…ํส?B๛ฆ๘สโ‘MุmML/W๙ํ๏๛nๆฤ›JKdH uwวฬป;Z ย า~ -OUvdร 3•ฉ/ฺืนC@ 4า~๘O“*oqญBLCtฦ๕-ฑ๖ƒ@ ะv ๋@ ‚ผ๖@ @า~ >6สใ„= {0<ค๚ฟz7 oพเฯ›ซงตหwทชu๏K๓ๆณต]AYฬ=๓$$pkฟ๊_†รV~N`X ฟ฿ฯE=ชเš ]๓๛ฟ๏S;งฺ๐dkc\๓?w‚๏ฝว– –บ ฦS~๒5Rต๖ทำZฐ'มก๎๙]e…›^ yฎำ๗Ÿปzื๛ากฅu๋ย‘ชโ?๏ึ:š73ฤมรฏๆy {ๆฟบgu\uว…‡w็พ๏3>ทQ’-ษœŸ๏ข5•๎1 o์ผห8A์ ;่ศๅ;ฅ‹m–าฎ๛่A[่ฎฎ2๕–?œv๙์ร7alb๔D{โqฟuฝšw2๒kฒ –ท_ฟ?g›ศm'ฟห?ž๖ ๐๙e†•,„Qgc๙vพหw]Eป mฆํ๛๊ธท'=ฌ_ื๖u:๒ว‚!ุ๋pท5ดฺu๎ิๅ yคัƒgbs์โIwฑ.๎๖#ํ#›฿4๘ธใBฺe/=p6mเีซๅ ฿› Y@ 43ฦv6ฅั1 vPveE๏+ะg;รผH*่ }ํ[ฺ่•V‚ย7ขš.^.๎ผ—d4WjŸLY&“1Lซ๎๑.Xƒ๒jR3ู๕žฤ ีร „,AƒLIดYt'bL๚'bูโsqัถืGศ1๒ถ๏MƒŒ?อŠB฿žงZ}ศ0”ฑ๊฿/rื๛า=ี,็_9ฟุJw๚ฏยC…ืt๏i๕[หuŸ๛!~Yิ[๓=jีฏปโ๛ฬRวO๕๘…jz-สย๛ศ๙บSpหŠŠฤ•ฅ"LW••‹หŠ‹Dฎmฃn\J,‰ #~žู_Vใ€ญcิ•ฝ(VF_๘ๅHจ€ ี๓_9ถw^oๅwใH CฟRำำo`PฃI ไภ฿NHJล…แ!ฯhSm(Š บ~xแทGย฿ฎสผ“!Œ8นน%]๒z’[^–๊}ๆํ๊*ณื–)?™จ,Dc–FoงŽษ/ใชšีตืค฿๛ๅ|x9โจ๗ฐ.{๙ชสbnO*{[–!Cภ|i฿{ทฎ2ลZิtuqnN•ร—6Ž1ฯษฮึัี•!ษ˜ŸLะ@ซหซ@ลxjธฒ€ม$ฌ–D_M…ณูธnˆยh dA=๘ ฉ|†ตd}‘”€+Iํygฉวฑj<ผ– ฝ†sฐFm๛รศ’S?!ฅ X‡‰‚—Qม7กส๙,ฃ|–QIนะI๒EoXล๕พ@ฏฃD9๔?_bั]“๓pX๖z‚‡C:/žฮ๑ฺ| ๎oึœnดŒY—} V เ˜ช•V็๓ ธ่*ช?XWŠ๒$X[ด,Q~๛ฺ‡›<Œช$ุb>6า…ส"PP—-ฬ่{ำ ํก๙`;ฬ๚ย :lึDใฦF6ํd|;บฐJ˜x๗‰‚•ตถ A:ภ„ฏG หกOSดudษีtvำส ›๏๔n+‡บถšฃ—L้้]4Ac่šU๏ญŸ3c๎—ปSGmkฯ@€œบˆฝธžพ%สvสัZ24ขšพpๅฑ๛‚รƒฟฐ„aรโZ,ฟพ0ะ๛pื{/'4›[ จL8๔่iเอ ฺ-๖ —%`สฟฮœ4iสฌ้S็-nพ|๕gF <žD"แ่Z๗p0WKฤ\O†$c~2RB5เƒ( !ฌ  •*F๗$ช" _ซึVc7Q~ŸC!บ›๐m˜ภb qฮ' Ce4pฐJํt๔๔จดคiP$ฦŠฒ็จห2Iฮ่mปัรซn‰kH„ข(ŽŠถถ *N>ปmŸw…ส'ทo& ้’˜ˆ็•PoะLฒศธu๔thJ^FPภSlbR๏ๅj‚ฮwํ4ํdw฿๛E-ษ๕๓yคacซ!+*sกŠSฮํฟj๐อฑC3%^nฝ1Ÿฃ)v6+l9ƒ๎ๆฃ๔œืแ์ฎ —‡2G,ษศ(C!@ˆRทณซ›Ÿtๅ่ฅW%ด0ๆqt•ก‘€4"์‘PXQ๚ ฟขBศแpeซm70f;LปLƒไ_P๕ูž^ุTŒb฿š]Š ?ด๚`-!ไหSmฃp€%ฬKฬ็-JV™,ห๗ฆั๎‡ฎ„ถƒฦู่ckฦืmfฬ้un๛รฦGGZร*‘H8l™e’ํ็›ึN่ศ‘HŠ„ฝOqIbภฤFา๎เu_๔ต๙๕ีk3^ืX๘}%\๕xšLdœ๑๒ดปใัgษ€้GWyU,…โsw’NYร•L:1T๗พ–][ี๏8ฎพพV*–mA/gJC\=— 'ฯ]2ใkC”^ฎ็ŽŠูˆ?nC ึ๘0v‚2fˆKฒ2k&9 ฮy9ญSG€(‘ˆลb•๛zธ๘จLb‹ซD2$‹˜๒๓!S๊ลPษmc\๒)LM) Sl0Y@๋ำ,ื>˜~%kŽ[]แจ:S์zัฅLั1 ™“ขdš$_๔6ๅ0jDษญyษ ež฿~ฤt๙*ฏyz’ิpฟžžw’฿|”3๙zA#uสขฎ“Jฅlv]ขI:๋จณ“รแN>tvธXŠยฬh™3eช’g_ษžต0ํ่๕ฌ๚โอc็‡ 5‰vฐE้(๊:*ys*ขf\E5ธšƒ„'ุl๘๛๊า๒ฒ์๐=;ื†c\๓โ`#๔‰vหส:I๒ E]e>O”U‰-GแŒ“”เญ็ฅ4๑a‘7%bทษ d!šจEฎA`ยZึ7Š#ำ๗ฆ@ฺBsa6ar7ฉPX=ญƒ?dโเ#o7ฐŒ๚m$ ‹USbฑXIm๏2McŠชW‹ั๓ํฬŠ_ฦM(ฅตฆ|อ}ŠUฬ๛์T๘8ใCWถq:๖๎ฃodp*pfอoวGถL2‹ฅาšฯ”ฆy<@Qq1ฎ_•Jeอ (..ๆ)ซpฤภำำSหŠอ‘!Ze?‹ๅฺ™ -0‡Iลjˆ+?๒zD.—&=.\ีท ๘2I2fศาŒ9๋ดYz๚%@uล@qnK[‡P::บ99ู#7ฟ+ษๆ0ไ'#4ช”า:(1‰ชh}ศ*DKqสฏT’์\D, eŽ s€อ่Lง;dP-ลu๕{DษŽีžผ5โ~“Œ๚ฐ{œ~gฦ๋eต4๋สืeFEฬๅm /Gีผ็๔๛ึŒฒ่ผ์๙W๏่@ำุlฑคถ6ำL:๋H$ฉ/™้•"$cกส๋>็3ณค>ณง˜=V[ 4ทrรลฆแี:”มดzWำ _๓:๔ว~฿7h–๋ชOx„Y&ŒYงz๖ธ่!ชย ฮFฅดถส*- P\N›ืแa&7$Af=ิพvธช€J x •^ง{?Sฯrาๆƒ_ุหœƒร\จฒฌgy xผ๏ซอQ3—ฟžยุ์vส"p%จŠq๋ ฌฆŠŠeฝ้ีฐ9< m.‹ลbฝัำ๔_€1๋hl๘961ภามZP‘Š‚–Qี๋—.€๔!๒ฉซ@ำ(ฅf~|๋›Fนฯฐ๑`ฬใR7l@กœฺIn|ฺa*vš„kฺฮ ๘ศ๘ะF(นนoๆํ—ๆฉK3ฃ.ฏ๖ธถWL่{์ ึฝWฆpKŸšตฒเึo็]ึ๔[‘ฯถ•ปว๎๑: ณๆEM๓>>ตz๑๋ๅEwtlอฮฐEษฏ2Ktส_ฅทฏนMๆู‰ฎnXy์ฮfพด(9ิs๏Edžไiถq็ลo4ฅูฯnญ฿ๅ#ณ—}aใ.ƒu๋šซวสqkห๖k๙เเแ๗๋ไ๊๚ฦต%๐๒ฐ{๕’Jซ%ืB–`qy~Z๘ๅญย[ฦกŠ{ฟpูr๐๊LUค<๚}็?‰ฮ›|=วWW๗?eW–ฺส]๐๎>๋6ๅฃรซฬ~๑๏๖—ฒ@xwฯf๋ญซฯxkKRCNญ:Cห’dฬOf* @$„*q {จฤ‚KHm:ํโจ ๒จ2 มฐš@ปฮiJ๕B…ฒงคžFJS่พร*‡<*)๕ตฮC.D้งPAƒณคแ่UWฺแฬขW?ข๔F“ฝ•Q์?jภ๓[{ ๋ๅ^;|zเฮ_.OOผดๅlภธP๓Šฝ`ลม%fฺ์โ8C{ฎ6ฐ๐—Aง †‚…๑EHผ}แโง| ซาžž]ฝ3หาษˆฌ—๋]Jo๎oฟ้เอล,aFจืฮ8™ESกŠŒฆญ๛,ใ—O„ฯ๖wเ›พwท>(o ;ๅpฑ“็๋ว7๋€LA%สXƒ๔ว“ผฮ‡UO๎’Vค?๕Zฟ๚dTำLj/0gŠฟ v hs%–Bพ•šี †vK๖Eค2;oวtJ>๑z๓VQ&ช(ว’ิ๛ š RPxฝ)หา+Ž9PgฦหฉโR๐•w›‘–0ib†ภ‹๗ๅ5I่-‘K๒GIe่ea๚šw ๑ญ๛„4}ฬ8๗๋Woส‹๐„๑ ฉ_าึqฟฒฒฟยงผEกyQq฿sูีwฬ*ฟฆŸญั๎tถํลฮwแูๆ7>lิ’e€8 ~;ช๎9joDk๕Iกa๙‘–Fฦทอ[)2@ B๛Bmฐ{ืเณ›ตฒ^tถํลNDั๗ผ็,ป๔๏Wb  tษ‹“cZ(ยงi?ะพ(พฒxคผ#ณŸšฮ– ฝุษDึ3๏๎hm+5ฺฤ*0@ ะ.9 ค๓vำ51i ๋ไ_ๆAh:mpฅD4‰@ „ถU(๋จัfงีwf2@ @ ไ…ด@ ‚ผผฏภั่ฬญ—~๕FNZ]GฐไKv[wรfฎ)šxา/ฮีi.ำญRต[็ภญ^‡จ;.<ฟ;๗}oœู๖นRณrอ†ฎ๙‚_H€ฟ๗ฉSmx”แฐ•ฟ_ฟ่๏wฦsQ•f๖ ๎ขอ5›Y้ํ‰วึ๕b€ƒ‡฿ŸณM>BBm[g#pZ๋๏5ำฐตR%ฐž<ฟ?๐2r ้c็Cuแุf=๔Pํ฿.ฌ ๆุล“๎b \ํGบทวตผ‰๐qว…ดห^zเ*lฺ๐‹/ฟ$ ุ{k™UรR ด๘ฆŽฮƒl…๕74S๊ะีŠJ๑น้YชืZ๗jนzŽzน‘‘-t*๐_ฃ๊แฏหฟ_พํZZkBh๒หน‹ห rฒ๋*ธxl๋Ÿ๐ใร',>%žนwž ี๔@ƒษ[—้๑˜เ2tย๊‡fK็U‹ ฿ ฮ<:cHื‘sฏrพœ3Dญ5๒€๐†ฃF๚~เแwm6กf|วhoญX๔@ย[4K†ใ1๛อี ป(฿๏(฿๏(฿ตจๆ ญฮ%hฐZฺๆEw"ึษDกฉว‚๙\ฌ*๛่๙%ุ<พ’’"็= \ฎ*ฮN{๑ ,ฆ@\/•eฝŠO+—bบ*?ท๓๙๕F”ฬบuๅง>~‘Ÿ/ „qX๗Pนร๊ ิŽพใFdBL่้๙6lIrเูsgoDฝu&ชVŸลว๎<|™riTn—YGฝŸฦ$%ล<พ๓|ง๊‰‘ษศ-็D'$F๛ฏํฑ$43EqAื/๖HxIฝ@'7ทคK^OrหหRฝฯก]]ญšศํฺ6๊ฦฅฤR‘จ0โ็™W(€ฒข"qei…ำUeๅโฒโ"™‡b›ดEglฟ–vMw๋_sภ+าย6ห่A๛iืuธcmวาฤ—ะฎ๛้A?`…7๗า.kฐy‡ๆฯวO “‘ฃตผoFิ4‹tm8๏pv๏$‹๊๊e์ถ๚๗ †๕พt`AOu€๗อทิต_'๖ฑ๒ไ๕ฟพฒge่ฒ๒ท๓พ๗}oŸ=ำAฅ„ิ{/8z้บทะะ๋ฏ฿ฺ;Nนz๔cž๓ˆm็oœ;ู‚%;!YฦฟาฐรŽMญ4ต๚ๆฺต๏บ(ูO๎VPุ›gvฬhฤญvำฤm๕๑๓พ๏:ถ~ค)%ห๗7ฯ๙>ธ็weuš!ท†}ำ(ฆิ›H้s{„ŠK| #อt;ฺ%ฒr‰ี [๊ฃุ๛๏‹ŸUึภP๋Œ+ฺYGึs€4?TU OQ&ฦบ2Gาไ—l ด$ล‚๔์าทฺๅ™/“๓%@q5ดิฤลลตŸJอฒป5โQBi‹ž—M |าhบฯšw๕r$m๊ถ๖k7!<ทM'ึ6H๘kื>%vำ_f 7c็ฮ๑๊ฯŽoyงุฦ}๋๎นๆภต๑ศ—#v๐F\{<‰PŸฒฟ[๗“สSำีลน9U_ุ8ฦ<';[GWทษ๊๊๊vงYปฯ๛๏ฝ;lp7cdฝbkูW—ฝฯธ/yฏมสศ’S?!ฅ X‡`0ซฦSมkฉะk`8k ƒIX-‘ ^MGeาšธ“ฐZu5zฬfc2ฮัV#FqฝoGือ0;ณƒ๊/ฆmxbน๒หPนrญ๕“อ“\็สu฿ตภฐ์๕;‡t^<ใต๙฿ @yคว๛ศMŽœuL8mื\[™ N๘nrแัฉร]‡N๛#1รkพวี๊วาb์ฅำ_บXtืdลผY ษ2*>ถ๎ํฌ `ุซrpP4่M๔˜C๓๕่ม“—eะN@eิชuถฯvNw๖ูชŽ๋– S–ๅป๒H๕ถ['ป ›ฐ|bMงA฿฿€1๕ฆRrณๅ dข™nG๛„9—˜OภEืPั›uX‹•ดฺem7jพฏฅ(O‚ตีAหๅว~ ƒ› >๐0ช’`‹๙ุH*‹@Aฝษ’แCึOsฬz7rh7…๘˜‚šึ‚ชuOkV๊ซŒสfฐ‰@๘ฯRxk๏สƒว๗๓€g`จม,dแ่คEฟ์8๋ฦก€ฬ{8iBแีใ&อZฃื๑ƒW_˜š€™m%(๔๙uฏื๛/D}LG O"‘ptญ{8˜ซŠ%b.ืไ@Hมฉ‹ุk๛่้[ขlืฏญCืฌ๊xoœsฟ:j๋\{NCvฅ฿@ฅ Mƒ"1VTP1‚' Ce4pฐJu 1ไ>ฑ$ู ฌ๊V1‚ผง มP๙สXตY*hŸ(vฃ‡Wผ๗: ใๆแA‰9้๗žŠ ตภด“uN๐ํ่ย*afเ' VึฺาˆฐGBaEE|่ƒŠ !‡ร0ํdw฿๛E-ษ๕๓yคacซ!+ก’ŒŒ2„„(u;ปบ๙ิIWŽ^zUB cGWiษJH–๑๏R๐ฬษน@ฝooร๛๗#h (Šฃขญญ‚Š‚ฯn็]`be•x=<ทRT๔ฎ๕ื)Yพ›Ywฮ พ]$—&% j๚@™|ทšwๆมภzž5dคบ4ฯํ๘”เ๖ยฆb๛ด~Š฿O๏ขB๖PO. 8ฺธzGV๙1 ีk !_ๆ˜j›„,)`จXb>h Pฒสdy%ู<>Ÿฯ็๓yl ธ |>ŸฯWโศ่ษก+qสร๋)Gูจ[oGtIF”ผ หะ๋fื!=4ฉŒ,๔!‡3ฮฝตaŒ@*•…dLQไ๒ธbฑฤ1๐x< ปM]ฑฬอJSฃจP86€D"sFa๓OhชD"‹U๎๋แโ  2‰-ฎ59ฆ]็UฑŠCฮI:mg W"๛บJธ๊๑4™ศ8ใ๛ๅiwวฃฯสa!„SlภตฃำX  0ลzXbƒษZŸ`‰ ธม†สสaิˆ’[๓’๋I%5ร8Rฉ! 8N] D"แฐeๆ'‡ร1œ|่์p ฐ…™ัu๓“฿Nˆ„'ุl๘๛๊า๒ฒ์๐=;ื†W`€i\zฃŒg  (๑ซ]Qˆv๋ะฅ™็ท1]พสkžž$5๏„ง็d1p8œบขฎ<.0ฐึฃw}gณูu ๚ž|แ๛ฯ}๊็Vea1@!S๊ญKsŽO ถ…3NRB€๚›๙ˆ กๆN ฌtฌขPPƒ๘‹ฐศ›ฑU๕U 4 P%Š\ƒภ„ดฌQNIสtๆŸ7ท9ืLณZz3n)`มล9รพ๕ej%7ฒภQ5ิgคT-.หฮซฒำี€Œ,\š๘4FปNฏŠษ&ยƒ< c ภfณŽŽ๖ปืูl6ิถ‰ฤสN=I o”ว๖๗ึŒๆซ<๋ฏkK€ฆi‡๏ึศแqŸลน9,m~๕‡PGG7''ปษEลลเ๕—T*•ฐ9\,•ึJišวk6{ˆ–โบ1ข€–ย๔๋ภšu€h)N๙•Jส๙ะ<๙ฯภ๎5bp๚ KI$ซฆ‘ลb5ะŸ ‘HR^2ำ+ๅ} ้พoะ,ืUๅj9ƒฮj”;fS๑ะ',ฝถ+8;((wJnฺŽฯ‚6ีlอRsyยหภQ5๏9}ใพ5ใŸ,:Ÿ[฿MJISƒ*อ/3๚.•J_KRจ฿Kฒา๊ฏ5ูฉ7!#šNsŽO ะาลๅดyอo<ฬ‚ƒS ๕WT}G1ิ8I™†Dฯu๛๘ถ6 จค€งP ภS‡สบEไŠ ็ˆ%ฑ(?๏}’๕ก˜ฟศ๖ๆŸำฬkG*ยwอ๖`l<@ฃ็/ae#‡.ๆˆอืำVฉ(ฏ๗ภVคDD—wทำn๗๋q„%77@c๘’Ž4ฯขต~3—ฮ™ท~f/€๔gัEภ๎เ:}ฺ๔ฑ4ภค๏๔้ำFwU‡ไจศPพx…›f๗DFๅR,6รปซ•Uฉ๔™๓‹~fz: ๊#พน~ท็‡V๒–ะ’เ'Vfwำโ+› ™6‚ํ๏ืไ@Qไ“ŽใฆuRSPิwž2ย$2%@qB|aทมร xฅl5ล*!>กq–– @ 8Pฐ ••Tไ‚–๐TAo๔๋๕ำeะด €2ภv ฐ๙ข0ร้๋๎{ำ7๏=bi๑๑z}‡ูชs๔๚r’ฤวหฌ์ฆฦว๋t๏gสเYNฺ|๐ {ฎŒ„ุž†ถ—ลbฑ๊*เอb|‡i›๗nX๏นz˜โ๋0A`@U๏ปวP]฿@ๆS6|?ฎ‡ฉ&G\œ“[Bะ5n๖w๏ฆอใ๐อวํบผcคš,฿iiฝYkiup๛fv?ๅ†}ๆิ[•fธŸฉ(hๅณŒ๒YF\้Cไณ •— Z‹ษท) X={kHiuฌฬ‹K็}.s?ี† fnร{W/œƒžcL@œ๒๐NDๆซ็๚Žฝ:r‘คช,/6*ฑด~ ‘ 2RีกซA\ฮM2/}ยแ]]L~๖0บพoxคู}๖บ‘jยฤ[ึxF๐{.ฟฯต๚Zื๛๗ฯH8u#สg๓ ›f~ฑพ๓โยบ Ÿ‚๐๙แํ~–/<บ/๊–Iฃ/o๘}ๅุ๎Z?๛๑่g–๓ํ†X฿˜w\gฤมแฬ๖ฺ ฮ›|=วWืw๖?eW–ฺzwฯf๋ญซฯxkKRCNญ:C€ฐi™็6yšmy๑Mi๖ณ[๋w๙ภณ?\ฐ๒ุอ|iQrจ็‹ฒพ@2\Bjำ้C.D้งP@บณ้ฎโ…r๛แ๚’.๎€ช ฿*#;๚1ขุิ€็ท๖พOฎไๆพ=๖›ท_šง.อŒบผnc™s4Jo๎oฟ้เอล,aFจืฮ8‘Œ„าoO๒:ถค้Oฝึฏ>ูจV2Œ/L|žศไIDAT‘VคU"ญ~%?HmแY{๗ีŽฤผb/Xqp‰™6ป8ฮะžซ๙5nvู๐ร?:œฒ”ฟ์บ–'ห๗‚›?ด๓็+3Nฏ>4ynCพ3ภ˜zSัžF;9W‹‡๕ย’t๗oฤศน้ทฃ=#o.‰PฐJปชดฒฯR้…j๕F!ฺ!ู‘ส ์ผำ9(๙*ฉ}ตE™จขKR_ทmeIพ‹$๎๙‹:๚๓ณผsWnhd )((ิX:bล‘;š๊|ึoผœ’—‚ฏ|ŸžIๅ่ŒดA“รบ‡ท๓ผ&;ฌi~ๅ„ถcI{ฟฒฒฝา˜@h๗=—]}วฌ๒k้ีMˆ;d›฿๘ฐQKn”โX,๘ํจบ็จฝMัI๘`š~;๏EK๋#m™Ÿ฿ไขทCiุ“ทZo}คศภ0@ ํ ตม๎]ƒฯnl๙๚7CBข่{s–]๚๗+ฑบไลษ1MิI๘`š|;„ท$†=yฏi?mƒศฝ wถถก]P|e๑ศ•/กฌป;fัผ: LSo๐!w6๔"@ Mฅฅึ?๙ื?GEด฿‹Mคulื™^์$ด}Z๗Y’็5$ใ@ A^H๛@ ฺHึษไŸ8HAรฤขƒฉถโะ๖โ{ฺู๋^r‰@๘ ํ@h? %ณ>ป7ำธ6สAบ ๚๏๘ธRa_บ ํ็๒ศ*jE™›฿V๛(t9แv๎fo๋ะี„>Iคจg๋์2l๔H๗Qn=L›Wฝ๛Y5rใFพ•ซ๛˜ฑŽ๚ž*๒๛1LขŒzs3 รปGฟm'ธฯ8๗1ี= กภๆ iน๔-f'ะXxฦํผ๓๔๎Ÿซ้ณผช0๓•เ๎wVu:ŸŸz!ค ‚<:€ษข;uๅผ ] ฿ฺ @ง๏าใก1‰ /รNญ ัH“ศKะ^`iุtทำUฆดzX•>ˆ+n๒ษทU]UMื๏7Œ5i๛โ#ค๘กร'•I๏ๆ+ฐด}’–vu9‰ฯ’ @\,๓ิ๗รQึาbฅ|xfC~฿[—ทํ”&„Gfpu:u1Tชb l‰ิ›H‹ูI 4dํ‰ฃณT๑๕ัKฟ=q8ฝฯ็หฎปฌ4|าๅศC—โj~kŒฺดaจ ฦoŽG‡Ÿ\๑g๕ฑ‚•ฑ‰*#ถพzTฉฯํอฆฏšผโจGh๗ตม8ญ“ดก} `ุต‡•*,ตฮฝํK"ณeิต๛}ปห์พŠei/‚.z๎9  Aหy๑ฮMs\:ฉ‹3#ฏ๏_ป้rผX’x6L4็พู~`ะ๊๓๕ŽณZkฃ‚—~žkV]9`๗หณ3UฦžŒ(๋s›ีA-เน’ลภก6jP๚*ะe)€z็!.ฉควODœ,ี 0๑Qh\‘F—แฬน iแ i๙QนนeU\ญŽ]ํฬดUธธฒ8+6::ตTฺf‚Žˆพฆรžใ $)ผฃrซัพ‹™Ž W ^F?O/ฃAaToำช๘Gฏ;๋+Šsข<-5sq้X\มสJโiกiO+x KO^฿ฅ”ชนC7k]T•ๆ&DE%Jcา€Tญ๛์ฌ”๓ิaพƒธ<7ต”ธบิ๋ฟg l ถj˜ฦำ=_ปํฯ'ส]mThเอ^๋Fซa๖Wฟ&Yฯ9ำยŽ2Rb”ไนm๒Z?ึ(ๅฬ๎=—&๎้€ุ‹?ฌ}G@Gzญ\ตrๅb[ยuQnlDTdBมป฿7ฎQ'3”›UŒดญ:๊QP&x•T@TeฟŒŠŒˆJศ“ฅฅWgล๒”˜ุ,ฑšฉcw+ต๗ฅ๘a‹LJำฃ#^e pQrDTdDtz)Tงnศษ{’Pฆb๎ไhก\+ฏhhฎY–šQ‚๘๙,mM%ญh`ำQกRฬัาำdษ๏ป‚ฉ}WCNQโ‹˜,ฑชƒ9Lj<#KU\๗<ญช{ิhY๗ดึ็พ|๑"นญฎยฦ2žคษมDญ29ฤQJ™ค8๎แง™ีํFนฒNิ „ลศศpFqืA7ฟีสศ066ชปจ=vข rแชxฝ=v~ฎtw๓ฦ๋…o๊` ู๖เมƒ'/bŸ^ฎ‡€ฆฆ&หrฦษะุธเ‹ž+]t$ค@ ŸŠŠด ๆล๓˜ฬr(ผˆ~›E+*2‰ฒีี•ุJ๊Šๅ1ื|9ืW`แ่ค …A—.;y=ุ]z๗QGb”ดptRƒ"๏Ÿถ?ร๘ํV ‹ู.œนU€S‚ฮ}ๆฬลGูฬ*yลง(>B@โSŸBX!)อJIKอ)ทช&ฮ|““R€x<Tฆงคๅ–cqqfZjJZvฉ”ี5ธ ฮLˆIH|ž”ภืะเ6˜ฯภฑ/3ฦฬmสย๔”ฬ"TไฆคฅฆdT(ซkp@”›‘ž››,(คชฉY;๒_•Ÿ—U ภfณ่๔๘B!เผิ๘ DQ๒๛.D}—”'(PRR“[ืฆ“.ซ,!*ฉบGอ ลๅฒ(6‡-)ษˆ}๔0ฑTV๊ธ47[H‹ซ*ส+ช$luSn•คZ@ฎฌ“?uกEแq9@Kižšถ† Hฤ~ตpแW ฟ^้P {ล๊):€t่ฌpอใซUV๎›ืŒUm”QoKGฌhฒฃ@h4๗++ธZžœ˜ ภฅ๕m ๘นI ้2;‹ฤ๛=ฮฎฐโ็+peสฝ‹ฮๅr4>?|ŒธสภWR`š(ฮ(ษๅqฤb1เglxึ(ฯ8_่nSจ้ฎฒR7ŒW,)›-ศ๕ญEิฐ๏ €iะtƒตVŠขhŒกV’b5ะwฦึ๊าหIO๔"‘ๆ)ฟตL๑ƒ์ค( €kา}ธ! ุฌZต4M€09ไVH%JึSถ๏˜ฃnjeฅ๋ฤe!@2‡P˜Mz=๕Y.75;uำ(ŒI)nๆ&ร{Rงณ^Eฆ)ฺYw๏c าŠ์ุ'‹˜งฃIEๅBฉe—!#ฅโŠฤgษEต><๋—๚?ษ‚LDb1P,แต๙6WAw๎U‘HTsษ๔ณI=E>_฿*็~XXu-bจฬฟaตjฦู‰ีโ7ŠœๆนL773…\ qืฟ๘ ๑=†Lฒถ6ˆชK๓ฝO๒ํrx@ ด อzTไีู๎็ึ๋u๎=fลญฃึ}7๚ฯูั"1@แ5กปW ‰Š๓™c‹˜$อชDส€QฏqTSรยbฉT @q8,™K ฤฟg็ุ๊OฏqภUปฒ๓๊-~LMำ์๊ั n ฝกlnoฉJุน ฑ,จป"Ÿ0ข(€_ง.DฤิL( ๋พต๖Iฤอ0๋‡2ดv0Sห‰|อ2๋ำฯ๊uzใL’๗v”คฦWZ๊šwิJŽฮoถYKrคŽKSฃ‚RŸ+จjtถท3ฐ้d˜๚0iงvGKˆ๕พT๙žŽ์ฌk\๊ไ๐8B‹ ่๋dก!@jFF๕ซ‰ป–๙ังฌ๚gํญ3โซggvYp|ญk๑•ี+… 9v๏ˆ.Sผ2Bจบ'จฐฐ€ลbลb!€ชชืห้ไy’ษ๚i@๘ดP์ุ)y็ฎ…ฦ‚D Pš“S ‰แOK`‚ำ`ื.Bงนใ/ญœนกพ๋”>†4ภค๏๔้J%ัทoผb’|^ ‡/!ึ†-]_แฬtปpdฦฦ–}…;พึK‡”ซฟ๘ฆ1™D ืd็w0ิrฆ@r1'๛ˆจ1ึl}#uฎ pิ๔Mอิ+rำ๒ญ–๒โ"1tด)Uๅ˜h‹ŠdoสTž™”ำกซzษซจ” ‹dŠ2",-•€บถEW ^Td$f—ŠมHCWWU*ี4ท6beD<|%ฟ๕r๛ŽB@q•”ต449šฃinฅS—[)ฏI\R.)Kzง=ศฦฌK‡คภ„rF;…|SMEฎ:”ดLอXโโฌฬb.C`‘Xt9F=Wฅfๆ—Š€ฦโส*)s.Ii)(้˜‹หi ดธผ(ฟPศ่$sึลWจผkgน.C๊B‹s๓FยาE_ํ[C=P=HvไN.ุLšhSxs็ฺกQz๘ฝ๔๊ฅฃ%ฉ๎E%[/dev/null | grep "Version =" | cut -f2 -d"\"" || echo " unknown") override TIMESTAMP := $(shell date +%s 2>/dev/null || echo "0") override DATESTAMP := $(shell date '+%Y-%m-%d %H:%M:%S' || echo "5 minutes ago") ifeq ($(shell command -v gdate >/dev/null; echo $$?),0) DATE_CMD := gdate else DATE_CMD := date endif ifneq ($(QUIET),true) override QUIET := false endif OLDCXX := $(CXXFLAGS) OLDLD := $(LDFLAGS) PREFIX ?= /usr/local #? Detect PLATFORM and ARCH from uname/gcc if not set PLATFORM ?= $(shell uname -s || echo unknown) ifneq ($(filter unknown Darwin, $(PLATFORM)),) override PLATFORM := $(shell $(CXX) -dumpmachine | awk -F"-" '{ print (NF==4) ? $$3 : $$2 }') ifeq ($(PLATFORM),apple) override PLATFORM := macos endif endif ifeq ($(shell uname -v | grep ARM64 >/dev/null 2>&1; echo $$?),0) ARCH ?= arm64 else ARCH ?= $(shell $(CXX) -dumpmachine | cut -d "-" -f 1) endif override PLATFORM_LC := $(shell echo $(PLATFORM) | tr '[:upper:]' '[:lower:]') #? GPU Support ifeq ($(PLATFORM_LC)$(ARCH),linuxx86_64) ifneq ($(STATIC),true) GPU_SUPPORT := true INTEL_GPU_SUPPORT := true endif endif ifeq ($(PLATFORM_LC),macos) GPU_SUPPORT := true endif ifneq ($(GPU_SUPPORT),true) GPU_SUPPORT := false endif ifeq ($(GPU_SUPPORT),true) override ADDFLAGS += -DGPU_SUPPORT endif #? Compiler and Linker ifeq ($(shell $(CXX) --version | grep clang >/dev/null 2>&1; echo $$?),0) override CXX_IS_CLANG := true endif override CXX_VERSION := $(shell $(CXX) -dumpfullversion -dumpversion || echo 0) override CXX_VERSION_MAJOR := $(shell echo $(CXX_VERSION) | cut -d '.' -f 1) ifeq ($(DEBUG),true) override ADDFLAGS += -DBTOP_DEBUG endif #? Any flags added to TESTFLAGS must not contain whitespace for the testing to work override TESTFLAGS := -fexceptions -fstack-clash-protection -fcf-protection ifneq ($(PLATFORM) $(ARCH),macos arm64) override TESTFLAGS += -fstack-protector endif ifeq ($(STATIC),true) ifeq ($(CXX_IS_CLANG),true) ifeq ($(shell $(CXX) -print-target-triple | grep gnu >/dev/null; echo $$?),0) $(error $(shell printf "\033[1;91mERROR: \033[97m$(CXX) can't statically link glibc\033[0m")) endif endif ifeq ($(PLATFORM_LC),$(filter $(PLATFORM_LC),freebsd linux midnightbsd)) override ADDFLAGS += -DSTATIC_BUILD -static else ifeq ($(CXX_IS_CLANG),false) override ADDFLAGS += -static-libgcc -static-libstdc++ endif endif endif ifeq ($(STRIP),true) override ADDFLAGS += -s endif ifeq ($(VERBOSE),true) override VERBOSE := false else override VERBOSE := true endif #? Pull in platform specific source files and get thread count ifeq ($(PLATFORM_LC),linux) PLATFORM_DIR := linux THREADS := $(shell getconf _NPROCESSORS_ONLN 2>/dev/null || echo 1) SU_GROUP := root else ifeq ($(PLATFORM_LC),$(filter $(PLATFORM_LC),freebsd midnightbsd)) PLATFORM_DIR := freebsd THREADS := $(shell getconf NPROCESSORS_ONLN 2>/dev/null || echo 1) SU_GROUP := wheel override ADDFLAGS += -lm -lkvm -ldevstat ifeq ($(STATIC),true) override ADDFLAGS += -lelf -Wl,--eh-frame-hdr endif ifeq ($(CXX_IS_CLANG),false) override ADDFLAGS += -lstdc++ -Wl,rpath=/usr/local/lib/gcc$(CXX_VERSION_MAJOR) endif export MAKE = gmake else ifeq ($(PLATFORM_LC),macos) PLATFORM_DIR := osx THREADS := $(shell sysctl -n hw.ncpu || echo 1) override ADDFLAGS += -framework IOKit -framework CoreFoundation -lIOReport -Wno-format-truncation SU_GROUP := wheel else ifeq ($(PLATFORM_LC),openbsd) PLATFORM_DIR := openbsd THREADS := $(shell sysctl -n hw.ncpu || echo 1) override ADDFLAGS += -lkvm -static-libstdc++ export MAKE = gmake SU_GROUP := wheel else ifeq ($(PLATFORM_LC),netbsd) PLATFORM_DIR := netbsd THREADS := $(shell sysctl -n hw.ncpu || echo 1) override ADDFLAGS += -lkvm -lprop export MAKE = gmake SU_GROUP := wheel else $(error $(shell printf "\033[1;91mERROR: \033[97mUnsupported platform ($(PLATFORM))\033[0m")) endif #? Use all CPU cores (will only be set if using Make 4.3+) MAKEFLAGS := --jobs=$(THREADS) ifeq ($(THREADS),1) override THREADS := auto endif #? LTO command line ifeq ($(BUILD_TYPE),Release) ifeq ($(CXX_IS_CLANG),true) LTO := -flto=thin else LTO := -flto=$(THREADS) endif endif GIT_COMMIT := $(shell git rev-parse --short HEAD 2> /dev/null || true) CONFIGURE_COMMAND := $(MAKE) STATIC=$(STATIC) ifeq ($(PLATFORM_LC),linux) CONFIGURE_COMMAND += GPU_SUPPORT=$(GPU_SUPPORT) RSMI_STATIC=$(RSMI_STATIC) endif #? The Directories, Source, Includes, Objects and Binary SRCDIR := src INCDIRS := include $(wildcard lib/**/include) BUILDDIR := obj TARGETDIR := bin SRCEXT := cpp DEPEXT := d OBJEXT := o #? Filter out unsupported compiler flags override GOODFLAGS := $(foreach flag,$(TESTFLAGS),$(strip $(shell echo "int main() {}" | $(CXX) -o /dev/null $(flag) -x c++ - >/dev/null 2>&1 && echo $(flag) || true))) #? Flags, Libraries and Includes override REQFLAGS := -std=c++23 WARNFLAGS := -Wall -Wextra -pedantic OPTFLAGS := -O2 $(LTO) LDCXXFLAGS := -pthread -DFMT_HEADER_ONLY -D_GLIBCXX_ASSERTIONS -D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG -D_FILE_OFFSET_BITS=64 $(GOODFLAGS) $(ADDFLAGS) override CXXFLAGS += $(REQFLAGS) $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) override LDFLAGS += $(LDCXXFLAGS) $(OPTFLAGS) $(WARNFLAGS) INC := $(foreach incdir,$(INCDIRS),-isystem $(incdir)) -I$(SRCDIR) -I$(BUILDDIR) SU_USER := root ifdef DEBUG override OPTFLAGS := -O0 -g endif SOURCES := $(sort $(shell find $(SRCDIR) -maxdepth 1 -type f -name *.$(SRCEXT))) SOURCES += $(sort $(shell find $(SRCDIR)/$(PLATFORM_DIR) -maxdepth 1 -type f -name *.$(SRCEXT))) OBJECTS := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(SOURCES:.$(SRCEXT)=.$(OBJEXT))) ifeq ($(GPU_SUPPORT)$(INTEL_GPU_SUPPORT),truetrue) IGT_OBJECTS := $(BUILDDIR)/igt_perf.c.o $(BUILDDIR)/intel_device_info.c.o $(BUILDDIR)/intel_name_lookup_shim.c.o $(BUILDDIR)/intel_gpu_top.c.o OBJECTS += $(IGT_OBJECTS) SHOW_CC_INFO = false CC_VERSION := $(shell $(CC) -dumpfullversion -dumpversion || echo 0) else SHOW_CC_INFO = true endif #? Setup percentage progress SOURCE_COUNT := $(words $(OBJECTS)) ifeq ($(shell find $(BUILDDIR) -type f -newermt "$(DATESTAMP)" -name *.o >/dev/null 2>&1; echo $$?),0) ifneq ($(wildcard $(BUILDDIR)/.*),) SKIPPED_SOURCES := $(foreach fname,$(SOURCES),$(shell find $(BUILDDIR) -type f -newer $(fname) -name *.o | grep "$(basename $(notdir $(fname))).o" 2>/dev/null)) override SOURCE_COUNT := $(shell expr $(SOURCE_COUNT) - $(words $(SKIPPED_SOURCES))) ifeq ($(SOURCE_COUNT),0) override SOURCE_COUNT = $(words $(SOURCES)) endif endif PROGRESS = expr $$(find $(BUILDDIR) -type f -newermt "$(DATESTAMP)" -name *.o | wc -l || echo 1) '*' 90 / $(SOURCE_COUNT) | cut -c1-2 else PROGRESS = expr $$(find $(BUILDDIR) -type f -name *.o | wc -l || echo 1) '*' 90 / $(SOURCE_COUNT) | cut -c1-2 endif P := %% ifeq ($(VERBOSE),true) # Doesn't work with `&>` override SUPPRESS := > /dev/null 2> /dev/null else override SUPPRESS := endif #? Default Make .ONESHELL: all: | info rocm_smi info-quiet directories btop.1 config.h btop ifneq ($(QUIET),true) info: @printf " $(BANNER)\n" @printf "\033[1;92mPLATFORM \033[1;93m?| \033[0m$(PLATFORM)\n" @printf "\033[1;96mARCH \033[1;93m?| \033[0m$(ARCH)\n" @printf "\033[1;95mGPU_SUPPORT \033[1;94m:| \033[0m$(GPU_SUPPORT)\n" @printf "\033[1;93mCXX \033[1;93m?| \033[0m$(CXX) \033[1;93m(\033[97m$(CXX_VERSION)\033[93m)\n" @$(SHOW_CC_INFO) || printf "\033[1;93mCC \033[1;93m?| \033[0m$(CC) \033[1;93m(\033[97m$(CC_VERSION)\033[93m)\n" @printf "\033[1;94mTHREADS \033[1;94m:| \033[0m$(THREADS)\n" @printf "\033[1;92mREQFLAGS \033[1;91m!| \033[0m$(REQFLAGS)\n" @printf "\033[1;91mWARNFLAGS \033[1;94m:| \033[0m$(WARNFLAGS)\n" @printf "\033[1;94mOPTFLAGS \033[1;94m:| \033[0m$(OPTFLAGS)\n" @printf "\033[1;93mLDCXXFLAGS \033[1;94m:| \033[0m$(LDCXXFLAGS)\n" @printf "\033[1;95mCXXFLAGS \033[1;92m+| \033[0;37m\$$(\033[92mREQFLAGS\033[37m) \$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDCXX)\n" @printf "\033[1;95mLDFLAGS \033[1;92m+| \033[0;37m\$$(\033[93mLDCXXFLAGS\033[37m) \$$(\033[94mOPTFLAGS\033[37m) \$$(\033[91mWARNFLAGS\033[37m) $(OLDLD)\n" else info: @true endif info-quiet: | info rocm_smi @printf "\n\033[1;92mBuilding btop++ \033[91m(\033[97mv$(BTOP_VERSION)\033[91m) \033[93m$(PLATFORM) \033[96m$(ARCH)\033[0m\n" help: @printf " $(BANNER)\n" @printf "\033[1;97mbtop++ makefile\033[0m\n" @printf "usage: make [argument]\n\n" @printf "arguments:\n" @printf " all Compile btop (default argument)\n" @printf " clean Remove built objects\n" @printf " distclean Remove built objects and binaries\n" @printf " install Install btop++ to \$$PREFIX ($(PREFIX))\n" @printf " setcap Set extended capabilities on binary (preferable to setuid)\n" @printf " setuid Set installed binary owner/group to \$$SU_USER/\$$SU_GROUP ($(SU_USER)/$(SU_GROUP)) and set SUID bit\n" @printf " uninstall Uninstall btop++ from \$$PREFIX\n" @printf " info Display information about Environment,compiler and linker flags\n" #? Make the Directories directories: @$(VERBOSE) || printf "mkdir -p $(TARGETDIR)\n" @mkdir -p $(TARGETDIR) @$(VERBOSE) || printf "mkdir -p $(BUILDDIR)/$(PLATFORM_DIR)\n" @mkdir -p $(BUILDDIR)/$(PLATFORM_DIR) config.h: $(BUILDDIR)/config.h $(BUILDDIR)/config.h: $(SRCDIR)/config.h.in | directories @$(QUIET) || printf "\033[1mConfiguring $(BUILDDIR)/config.h\033[0m\n" @$(VERBOSE) || printf 'sed -e "s|@GIT_COMMIT@|$(GIT_COMMIT)|" -e "s|@CONFIGURE_COMMAND@|$(CONFIGURE_COMMAND)|" -e "s|@COMPILER@|$(CXX)|" -e "s|@COMPILER_VERSION@|$(CXX_VERSION)|" $< | tee $@ > /dev/null\n' @sed -e "s|@GIT_COMMIT@|$(GIT_COMMIT)|" -e "s|@CONFIGURE_COMMAND@|$(CONFIGURE_COMMAND)|" -e "s|@COMPILER@|$(CXX)|" -e "s|@COMPILER_VERSION@|$(CXX_VERSION)|" $< | tee $@ > /dev/null #? Man page btop.1: manpage.md | directories ifeq ($(shell command -v lowdown >/dev/null; echo $$?),0) @printf "\n\033[1;92mGenerating man page $@\033[37m...\033[0m\n" lowdown -s -Tman -o $@ $< else @printf "\n\033[1;93mCommand 'lowdown' not found: skipping generating man page $@\033[0m\n" endif #? Clean only Objects clean: @printf "\033[1;91mRemoving: \033[1;97mbuilt objects...\033[0m\n" @rm -rf $(BUILDDIR) @test -e lib/rocm_smi_lib/build && cmake --build lib/rocm_smi_lib/build --target clean &> /dev/null || true #? Clean Objects and Binaries distclean: clean @printf "\033[1;91mRemoving: \033[1;97mbuilt binaries...\033[0m\n" @rm -rf $(TARGETDIR) @test -e lib/rocm_smi_lib/build && rm -rf lib/rocm_smi_lib/build || true install: @printf "\033[1;92mInstalling binary to: \033[1;97m$(DESTDIR)$(PREFIX)/bin/btop\033[0m\n" @mkdir -p $(DESTDIR)$(PREFIX)/bin @cp -p $(TARGETDIR)/btop $(DESTDIR)$(PREFIX)/bin/btop @chmod 755 $(DESTDIR)$(PREFIX)/bin/btop @printf "\033[1;92mInstalling doc to: \033[1;97m$(DESTDIR)$(PREFIX)/share/doc/btop\033[0m\n" @mkdir -p $(DESTDIR)$(PREFIX)/share/doc/btop @cp -p README.md $(DESTDIR)$(PREFIX)/share/doc/btop @mkdir -p $(DESTDIR)$(PREFIX)/share/btop @printf "\033[1;92mInstalling themes to: \033[1;97m$(DESTDIR)$(PREFIX)/share/btop/themes\033[0m\n" @cp -pr themes $(DESTDIR)$(PREFIX)/share/btop @printf "\033[1;92mInstalling desktop entry to: \033[1;97m$(DESTDIR)$(PREFIX)/share/applications/btop.desktop\033[0m\n" @mkdir -p $(DESTDIR)$(PREFIX)/share/applications/ @cp -p btop.desktop $(DESTDIR)$(PREFIX)/share/applications/btop.desktop @printf "\033[1;92mInstalling PNG icon to: \033[1;97m$(DESTDIR)$(PREFIX)/share/icons/hicolor/48x48/apps/btop.png\033[0m\n" @mkdir -p $(DESTDIR)$(PREFIX)/share/icons/hicolor/48x48/apps @cp -p Img/icon.png $(DESTDIR)$(PREFIX)/share/icons/hicolor/48x48/apps/btop.png @printf "\033[1;92mInstalling SVG icon to: \033[1;97m$(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/btop.svg\033[0m\n" @mkdir -p $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps @cp -p Img/icon.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/btop.svg ifneq ($(wildcard btop.1),) @printf "\033[1;92mInstalling man page to: \033[1;97m$(DESTDIR)$(PREFIX)/share/man/man1/btop.1\033[0m\n" @mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1 @cp -p btop.1 $(DESTDIR)$(PREFIX)/share/man/man1/btop.1 endif #? Set SUID bit for btop as $SU_USER in $SU_GROUP setuid: @printf "\033[1;97mFile: $(DESTDIR)$(PREFIX)/bin/btop\n" @printf "\033[1;92mSetting owner \033[1;97m$(SU_USER):$(SU_GROUP)\033[0m\n" @chown $(SU_USER):$(SU_GROUP) $(DESTDIR)$(PREFIX)/bin/btop @printf "\033[1;92mSetting SUID bit\033[0m\n" @chmod u+s $(DESTDIR)$(PREFIX)/bin/btop #? Run setcap on btop for extended capabilities setcap: @printf "\033[1;97mFile: $(DESTDIR)$(PREFIX)/bin/btop\n" @printf "\033[1;92mSetting capabilities...\033[0m\n" @setcap "cap_perfmon=+ep cap_dac_read_search=+ep" $(DESTDIR)$(PREFIX)/bin/btop # With 'rm -v' user will see what files (if any) got removed uninstall: @printf "\033[1;91mRemoving: \033[1;97m$(DESTDIR)$(PREFIX)/bin/btop\033[0m\n" @rm -rfv $(DESTDIR)$(PREFIX)/bin/btop @printf "\033[1;91mRemoving: \033[1;97m$(DESTDIR)$(PREFIX)/share/btop\033[0m\n" @rm -rfv $(DESTDIR)$(PREFIX)/share/btop @printf "\033[1;91mRemoving: \033[1;97m$(DESTDIR)$(PREFIX)/share/applications/btop.desktop\033[0m\n" @rm -rfv $(DESTDIR)$(PREFIX)/share/applications/btop.desktop @printf "\033[1;91mRemoving: \033[1;97m$(DESTDIR)$(PREFIX)/share/icons/hicolor/48x48/apps/btop.png\033[0m\n" @rm -rfv $(DESTDIR)$(PREFIX)/share/icons/hicolor/48x48/apps/btop.png @printf "\033[1;91mRemoving: \033[1;97m$(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/btop.svg\033[0m\n" @rm -rfv $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/btop.svg @printf "\033[1;91mRemoving: \033[1;97m$(DESTDIR)$(PREFIX)/share/man/man1/btop.1\033[0m\n" @rm -rfv $(DESTDIR)$(PREFIX)/share/man/man1/btop.1 #? Pull in dependency info for *existing* .o files -include $(OBJECTS:.$(OBJEXT)=.$(DEPEXT)) #? Compile rocm_smi ifeq ($(GPU_SUPPORT)$(RSMI_STATIC),truetrue) ROCM_DIR ?= lib/rocm_smi_lib ROCM_BUILD_DIR := $(ROCM_DIR)/build ifeq ($(DEBUG),true) BUILD_TYPE := Debug else BUILD_TYPE := Release endif .ONESHELL: rocm_smi: @printf "\n\033[1;92mBuilding ROCm SMI static library\033[37m...\033[0m\n" @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\033[1;97mRunning CMake...\033[0m\n" CXX=$(CXX) cmake -S $(ROCM_DIR) -B $(ROCM_BUILD_DIR) -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DBUILD_SHARED_LIBS=OFF $(SUPPRESS) || { printf "\033[1;91mCMake failed, continuing build without statically linking ROCm SMI\033[37m...\033[0m\n"; exit 0; } @$(QUIET) || printf "\n\033[1;97mBuilding and linking...\033[0m\n" @cmake --build $(ROCM_BUILD_DIR) -j -t rocm_smi64 $(SUPPRESS) || { printf "\033[1;91mMake failed, continuing build without statically linking ROCm SMI\033[37m...\033[0m\n"; exit 0; } @printf "\033[1;92m100$(P)\033[10D\033[5C-> \033[1;37m$(ROCM_BUILD_DIR)/rocm_smi/librocm_smi64.a \033[1;93m(\033[1;97m$$(du -ah $(ROCM_BUILD_DIR)/rocm_smi/librocm_smi64.a | cut -f1)iB\033[1;93m)\033[0m\n" @printf "\033[1;92mROCm SMI build complete in \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $(TIMESTAMP) 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo "unknown")\033[92m)\033[0m\n" @$(eval override LDFLAGS += $(ROCM_BUILD_DIR)/rocm_smi/librocm_smi64.a -DRSMI_STATIC) # TODO: this seems to execute every time, no matter if the compilation failed or succeeded @$(eval override CXXFLAGS += -DRSMI_STATIC) else rocm_smi: @true endif #? Link .ONESHELL: btop: $(OBJECTS) | rocm_smi directories @sleep 0.2 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\n\033[1;92mLinking and optimizing binary\033[37m...\033[0m\n" @$(VERBOSE) || printf "$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS)\n" @$(CXX) -o $(TARGETDIR)/btop $^ $(LDFLAGS) || exit 1 @printf "\033[1;92m100$(P) -> \033[1;37m$(TARGETDIR)/btop \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $(TARGETDIR)/btop | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" @printf "\n\033[1;92mBuild complete in \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$(date +%s 2>/dev/null || echo "0") - $(TIMESTAMP) 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo "unknown")\033[92m)\033[0m\n" #? Compile .ONESHELL: $(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT) | rocm_smi directories config.h @sleep 0.3 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\033[1;97mCompiling $<\033[0m\n" @$(VERBOSE) || printf "$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $<\n" @$(CXX) $(CXXFLAGS) $(INC) -MMD -c -o $@ $< || exit 1 @printf "\033[1;92m$$($(PROGRESS))$(P)\033[10D\033[5C-> \033[1;37m$@ \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $@ | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$($(DATE_CMD) +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" #? Compile intel_gpu_top C sources for Intel GPU support .ONESHELL: $(BUILDDIR)/%.c.o: $(SRCDIR)/$(PLATFORM_DIR)/intel_gpu_top/%.c | directories @sleep 0.3 2>/dev/null || true @TSTAMP=$$(date +%s 2>/dev/null || echo "0") @$(QUIET) || printf "\033[1;97mCompiling $<\033[0m\n" @$(VERBOSE) || printf "$(CC) $(INC) -c -o $@ $<\n" @$(CC) $(INC) -w -c -o $@ $< || exit 1 @printf "\033[1;92m$$($(PROGRESS))$(P)\033[10D\033[5C-> \033[1;37m$@ \033[100D\033[38C\033[1;93m(\033[1;97m$$(du -ah $@ | cut -f1)iB\033[1;93m) \033[92m(\033[97m$$($(DATE_CMD) -d @$$(expr $$($(DATE_CMD) +%s 2>/dev/null || echo "0") - $${TSTAMP} 2>/dev/null) -u +%Mm:%Ss 2>/dev/null | sed 's/^00m://' || echo '')\033[92m)\033[0m\n" #? Non-File Targets .PHONY: all config.h msg help pre aristocratos-btop-d43a485/README.md000066400000000000000000001471141517514752700170340ustar00rootroot00000000000000# ![btop++](Img/logo.png) Packaging status ![Linux](https://img.shields.io/badge/-Linux-grey?logo=linux) ![macOS](https://img.shields.io/badge/-OSX-black?logo=apple) ![FreeBSD](https://img.shields.io/badge/-FreeBSD-red?logo=freebsd) ![NetBSD](https://img.shields.io/badge/-NetBSD-black?logo=netbsd) ![OpenBSD](https://img.shields.io/badge/-OpenBSD-black?logo=openbsd) ![Usage](https://img.shields.io/badge/Usage-System%20resource%20monitor-yellow) ![c++23](https://img.shields.io/badge/cpp-c%2B%2B23-green) ![latest_release](https://img.shields.io/github/v/tag/aristocratos/btop?label=release) [![Donate](https://img.shields.io/badge/-Donate-yellow?logo=paypal)](https://paypal.me/aristocratos) [![Sponsor](https://img.shields.io/badge/-Sponsor-red?logo=github)](https://github.com/sponsors/aristocratos) [![Coffee](https://img.shields.io/badge/-Buy%20me%20a%20Coffee-grey?logo=Ko-fi)](https://ko-fi.com/aristocratos) [![btop](https://snapcraft.io/btop/badge.svg)](https://snapcraft.io/btop) [![Continuous Build Linux](https://github.com/aristocratos/btop/actions/workflows/continuous-build-linux.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-linux.yml) [![Continuous Build macOS](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) [![Continuous Build FreeBSD](https://github.com/aristocratos/btop/actions/workflows/continuous-build-freebsd.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-freebsd.yml) [![Continuous Build NetBSD](https://github.com/aristocratos/btop/actions/workflows/continuous-build-netbsd.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-netbsd.yml) [![Continuous Build OpenBSD](https://github.com/aristocratos/btop/actions/workflows/continuous-build-openbsd.yml/badge.svg)](https://github.com/aristocratos/btop/actions/workflows/continuous-build-openbsd.yml) ## Index * [News](#news) * [Documents](#documents) * [Description](#description) * [Features](#features) * [Themes](#themes) * [Support and funding](#support-and-funding) * [Prerequisites](#prerequisites) (Read this if you are having issues!) * [Screenshots](#screenshots) * [Keybindings](#help-menu) * [Installation Linux/macOS](#installation) * [Compilation Linux](#compilation-linux) * [Compilation macOS](#compilation-macos-osx) * [Compilation FreeBSD](#compilation-freebsd) * [Compilation NetBSD](#compilation-netbsd) * [Compilation OpenBSD](#compilation-openbsd) * [Testing](#testing) * [GPU compatibility](#gpu-compatibility) * [Installing the snap](#installing-the-snap) * [Configurability](#configurability) * [License](#license) If you are considering donating, please first consider donating to: [](https://www.qm4ua.org/) [](https://donate.savethechildren.org) ## News ##### 22 March 2026 Updated contributing guidlines for AI generated code: * Submissions where any of the code is AI generated must be marked with [AI generated]. (When code is generated by prompting either directly to an LLM or through "comment prompting".) * Not needed when AI suggestions is used in "autocomplete" mode only for boilerplate or other repetitive code. * Failure to disclose the use of AI in a PR will result in a closed PR and deliberately trying to obfuscate the use of AI will result in your account getting blocked from contributing again. * "Vibe coded" PR's where it seems like the author doesn't understand the generated code will be dismissed. ##### 4 December 2025 Since there is a increasing amount of AI generated/assisted PR's, the following guidlines have been added to CONTRIBUTING.md: * Submissions where the majority of the code is AI generated must be marked with [AI generated]. * "Vibe coded" PR's where it seems like the author doesn't understand the generated code will be dismissed. ##### 22 September 2024 Btop release v1.4.0 Intel GPU support added, note that only GPU utilization, power usage and clock speed available to monitor. Thanks to [@bjia56](https://github.com/bjia56) for contributions. NetBSD support added. Thanks to [@fraggerfox](https://github.com/fraggerfox) for contributions. See [CHANGELOG.md](CHANGELOG.md) and latest [release](https://github.com/aristocratos/btop/releases/latest) for detailed list of new features, bug fixes and new themes. ##### 7 January 2024 Btop release v1.3.0 Big release with GPU support added for Linux and platform support for OpenBSD. Big thanks to [@romner-set](https://github.com/romner-set) (GPU support) and [@joske](https://github.com/joske) (OpenBSD support) for contributions. And a multitude of bugfixes and small changes, see [CHANGELOG.md](CHANGELOG.md) and latest [release](https://github.com/aristocratos/btop/releases/latest) for detailed list and attributions. See news entry below for more information regarding GPU support. ##### 25 November 2023 GPU monitoring added for Linux! Compile from git main to try it out. Use keys `5`, `6`, `7` and `0` to show/hide the gpu monitoring boxes. `5` = Gpu 1, `6` = Gpu 2, etc. Gpu stats/graphs can also be displayed in the "Cpu box" (not as verbose), see the cpu options menu for info and configuration. Note that the binaries provided on the release page (when released) and the continuous builds will not have gpu support enabled. Because the GPU support relies on loading of dynamic gpu libraries, gpu support will not work when also static linking. See [Compilation Linux](#compilation-linux) for more info on how to compile with gpu monitoring support. Many thanks to [@romner-set](https://github.com/romner-set) who wrote the vast majority of the implementation for GPU support. Big update with version bump to 1.3 coming soon. ##### 28 August 2022 [![btop4win](https://github.com/aristocratos/btop4win/raw/master/Img/logo.png)](https://github.com/aristocratos/btop4win) First release of btop4win available at https://github.com/aristocratos/btop4win
More... ##### 16 January 2022 Release v1.2.0 with FreeBSD support. No release binaries for FreeBSD provided as of yet. Again a big thanks to [@joske](https://github.com/joske) for his porting efforts! Since compatibility with Linux, macOS and FreeBSD are done, the focus going forward will be on new features like GPU monitoring. ##### 13 November 2021 Release v1.1.0 with macOS support. Binaries in [continuous-build-macos](https://github.com/aristocratos/btop/actions/workflows/continuous-build-macos.yml) are only x86 for now. macOS binaries + installer are included for both x86 and ARM64 (Apple Silicon) in the releases. Big thank you to [@joske](https://github.com/joske) who wrote the vast majority of the implementation! ##### 30 October 2021 Work on the OSX [macOS] and FreeBSD branches, both initiated and mostly worked on by [@joske](https://github.com/joske), will likely be completed in the coming weeks. The OSX [macOS] branch has some memory leaks that needs to be sorted out and both have some issues with the processes cpu usage calculation and other smaller issues that needs fixing. If you want to help out, test for bugs/fix bugs or just try out the branches: **macOS / OSX** ```bash # Install and use Homebrew or MacPorts package managers for easy dependency installation brew install coreutils make gcc@11 lowdown git clone https://github.com/aristocratos/btop.git cd btop git checkout OSX gmake ``` **FreeBSD** ```bash sudo pkg install gmake gcc11 coreutils git lowdown git clone https://github.com/aristocratos/btop.git cd btop git checkout freebsd gmake ``` Note that GNU make (`gmake`) is recommended but not required for macOS/OSX but it is required on FreeBSD. ##### 6 October 2021 macOS development have been started by [@joske](https://github.com/joske), big thanks :) See branch [OSX](https://github.com/aristocratos/btop/tree/OSX) for current progress. ##### 18 September 2021 The Linux version of btop++ is complete. Released as version 1.0.0 I will be providing statically compiled binaries for a range of architectures in every release for those having problems compiling. For compilation GCC 11 is required. Please report any bugs to the [Issues](https://github.com/aristocratos/btop/issues/new?assignees=aristocratos&labels=bug&template=bug_report.md&title=%5BBUG%5D) page. The development plan right now: * 1.1.0 macOS [OSX] support * 1.2.0 FreeBSD support * 1.3.0 Support for GPU monitoring * 1.X.0 Other platforms and features... Windows support is not in the plans as of now, but if anyone else wants to take it on, I will try to help. ##### 5 May 2021 This project is gonna take some time until it has complete feature parity with bpytop, since all system information gathering will have to be written from scratch without any external libraries. And will need some help in the form of code contributions to get complete support for BSD and macOS/OSX.
## Documents **[CHANGELOG.md](CHANGELOG.md)** **[CONTRIBUTING.md](CONTRIBUTING.md)** **[CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)** ## Description Resource monitor that shows usage and stats for processor, memory, disks, network and processes. C++ version and continuation of [bashtop](https://github.com/aristocratos/bashtop) and [bpytop](https://github.com/aristocratos/bpytop). ## Features * Easy to use, with a game inspired menu system. * Full mouse support: all buttons with a highlighted key are clickable and mouse scrolling works in process list and menu boxes. * Fast and responsive UI with UP, DOWN key process selection. * Function for showing detailed stats for selected process. * Ability to filter processes. * Easy switching between sorting options. * Tree view of processes. * Send any signal to selected process. * Pause the process list. * UI menu for changing all config file options. * Auto scaling graph for network usage. * Shows IO activity and speeds for disks. * Battery meter * Selectable symbols for the graphs. * Custom presets * And more... ## Themes Btop++ uses the same theme files as bpytop and bashtop (some color values missing in bashtop themes). See [themes](https://github.com/aristocratos/btop/tree/main/themes) folder for available themes. Btop searches the following directories for system themes: * `../share/btop/themes` (this path is relative to the btop executable) * `/usr/local/share/btop/themes` * `/usr/share/btop/themes` The first directory that exists and isn't empty is used as the system themes directory. The user themes directory depends on which environment variables are set: * If `$XDG_CONFIG_HOME` is set, the user themes directory is `$XDG_CONFIG_HOME/btop/themes` * Otherwise, if `$HOME` is set, the user themes directory is `$HOME/.config/btop/themes` * Otherwise, the user themes directory is `~/.config/btop/themes` The `make install` command places the default themes in `[$PREFIX or /usr/local]/share/btop/themes`. User created themes should be placed in the user themes directory. Use the `--themes-dir` command-line option to specify a custom themes directory. When specified, this directory takes priority over the default search paths. Let me know if you want to contribute with new themes. The new Process list pausing and Process following features introduce a few new theme attributes. These attributes still need to be added to all of the existing themes (except the default one). Process list banner attributes: * proc_pause_bg: background color of the banner when the list is paused. * proc_follow_bg: background color of the banner when the process following feature is active. * proc_banner_bg: background color of the banner when the process following feature is active AND the list is paused. * proc_banner_fg: foreground (text) color of the banner Process following attributes: * followed_bg: background color of the followed process in the list. * followed_fg: foreground color of the followed process in the list. ## Support and funding You can sponsor this project through GitHub. See [my sponsors page](https://github.com/sponsors/aristocratos) for options. Or donate through [PayPal](https://paypal.me/aristocratos) or [ko-fi](https://ko-fi.com/aristocratos). Any support is greatly appreciated! ## Prerequisites For the best experience run within a terminal with support for: * 24-bit truecolor ([See list of terminals with truecolor support](https://github.com/termstandard/colors)) * 256-color terminals are supported through 24-bit to 256-color conversion when setting "truecolor" to False in the options or with "-lc/--low-color" arguments. * 16 color TTY mode will be activated if a real tty device is detected. Can be forced with "-t/--tty" arguments. * Wide characters (Are sometimes problematic in web-based terminals) Also necessary is a UTF8 locale and a font that includes: * Unicode Block โ€œBraille Patternsโ€ U+2800 - U+28FF (Not needed in TTY mode or with graphs set to type: block or tty.) * Unicode Block โ€œGeometric Shapesโ€ U+25A0 - U+25FF * Unicode Block "Box Drawing" and "Block Elements" U+2500 - U+259F ### **Optional Dependencies (Needed for GPU monitoring) (Only Linux)** GPU monitoring also requires a btop binary built with GPU support (`GPU_SUPPORT=true` flag). See [GPU compatibility](#gpu-compatibility) section for more about compiling with GPU support. * **NVIDIA** If you have an NVIDIA GPU you must use an official NVIDIA driver, both the closed-source and open-source ones have been verified to work. In addition to that you must also have the nvidia-ml dynamic library installed, which should be included with the driver package of your distribution. * **AMD** If you have an AMD GPU `rocm_smi_lib` is required, which may or may not be packaged for your distribution. * **INTEL** Requires a working C compiler if compiling from source. Also requires the user to have permission to read from SYSFS. Can be set with `make setcap` (preferred) or `make setuid` or by running btop with `sudo` or equivalent. ### **Notice (Text rendering issues)** * If you are having problems with the characters in the graphs not looking like they do in the screenshots, it's likely a problem with your systems configured fallback font not having support for braille characters. * See [Terminess Powerline](https://github.com/ryanoasis/nerd-fonts/blob/master/patched-fonts/Terminus/TerminessNerdFontMono-Regular.ttf) for an example of a font that includes the braille symbols. * See comments by @sgleizes [link](https://github.com/aristocratos/bpytop/issues/100#issuecomment-684036827) and @XenHat [link](https://github.com/aristocratos/bpytop/issues/100#issuecomment-691585587) in issue #100 for possible solutions. * If text is misaligned and you use Konsole or Yakuake, turning off "Bi-Directional text rendering" is a possible fix. * Characters clipping into each other or text/border misalignments are not bugs caused by btop, but most likely a fontconfig or terminal problem where the braille characters making up the graphs aren't rendered correctly. * Look to the creators of the terminal emulator you use to fix these issues if the previously mentioned fixes don't work for you. ## Screenshots #### Main UI showing details for a selected process ![Screenshot 1](Img/normal.png) #### Main UI in TTY mode ![Screenshot 2](Img/tty.png) #### Main UI with custom options ![Screenshot 3](Img/alt.png) #### Main-menu ![Screenshot 3](Img/main-menu.png) #### Options-menu ![Screenshot 4](Img/options-menu.png) #### Help-menu ![Screenshot 5](Img/help-menu.png) ## Installation **Binaries for Linux are statically compiled with musl and work on kernel releases 2.6.39 and newer** 1. **Download btop-(VERSION)-(ARCH)-(PLATFORM).tbz from [latest release](https://github.com/aristocratos/btop/releases/latest) and unpack to a new folder** **Notice! Use x86_64 for 64-bit x86 systems, i486 and i686 are 32-bit!** 2. **Install (from created folder)** * **Run:** ```bash # use "make install PREFIX=/target/dir" to set target, default: /usr/local # only use "sudo" when installing to a NON user owned directory sudo make install ``` 3. **(Optional/Required for Intel GPU and CPU wattage) Set extended capabilities or suid bit to btop** Enables signal sending to any process without starting with `sudo` and can prevent /proc read permissions problems on some systems. Is required for Intel GPU support and CPU wattage monitoring. * **Run:** ```bash # run after make install and use same PREFIX if any was used at install sudo make setcap ``` * **or** ```bash # run after make install and use same PREFIX if any was used at install # set SU_USER and SU_GROUP to select user and group, default is root:root sudo make setuid ``` * **Uninstall** * **Run:** ```bash sudo make uninstall ``` * **Show help** ```bash make help ``` **Binary release (from native os repo)** * **openSUSE** * **Tumbleweed:** ```bash sudo zypper in btop ``` * For all other versions, see [openSUSE Software: btop](https://software.opensuse.org/package/btop) * **Fedora** ```bash sudo dnf install btop ``` * **RHEL/Rocky/AlmaLinux 8+** ```bash sudo dnf install epel-release sudo dnf install btop ``` * **FreeBSD** ```sh pkg install btop ``` * **NetBSD** ```sh pkg_add btop ``` **Binary release on Homebrew (macOS (x86_64 & ARM64) / Linux (x86_64))** * **[Homebrew](https://formulae.brew.sh/formula/btop)** ```bash brew install btop ``` ## Compilation Linux Requires at least GCC 14 or Clang 19. The Makefile also needs GNU `coreutils` and `sed` (should already be installed on any modern distribution). ### GPU compatibility Btop++ supports Nvidia and AMD GPUs and Intel IGPUs out of the box on Linux x86_64, provided you have the correct drivers and libraries. Gpu support for Nvidia or AMD will not work when static linking glibc (or musl, etc.)! For x86_64 Linux the flag `GPU_SUPPORT` is automatically set to `true`, to manually disable gpu support set the flag to false, like: `make GPU_SUPPORT=false` (or `cmake -DBTOP_GPU=false` with CMake) * **NVIDIA** You must use an official NVIDIA driver, both the closed-source and [open-source](https://github.com/NVIDIA/open-gpu-kernel-modules) ones have been verified to work. In addition to that you must also have the `nvidia-ml` dynamic library installed, which should be included with the driver package of your distribution. * **AMD** AMDGPU data is queried using the [ROCm SMI](https://github.com/rocm/rocm_smi_lib) library, which may or may not be packaged for your distribution. If your distribution doesn't provide a package, btop++ is statically linked to ROCm SMI with the `RSMI_STATIC=true` make flag. This flag expects the ROCm SMI source code in `lib/rocm_smi_lib`, and compilation will fail if it's not there. The latest tested version is 5.6.x, which can be obtained with the following command: ```bash git clone https://github.com/rocm/rocm_smi_lib.git --depth 1 -b rocm-5.6.x lib/rocm_smi_lib ```
### With Make 1. **Install dependencies (example for Ubuntu 24.04 Noble)** ```bash sudo apt install coreutils sed git build-essential lowdown ``` 2. **Clone repository** ```bash git clone https://github.com/aristocratos/btop.git cd btop ``` 3. **Compile** ```bash make ``` Options for make: | Flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `VERBOSE=true` | To display full compiler/linker commands | | `STATIC=true` | For static compilation | | `QUIET=true` | For less verbose output | | `STRIP=true` | To force stripping of debug symbols (adds `-s` linker flag) | | `DEBUG=true` | Sets OPTFLAGS to `-O0 -g` and enables more verbose debug logging | | `ARCH=` | To manually set the target architecture | | `GPU_SUPPORT=` | Enable/disable GPU support (Enabled by default on X86_64 Linux) | | `RSMI_STATIC=true` | To statically link the ROCm SMI library used for querying AMDGPU | | `ADDFLAGS=` | For appending flags to both compiler and linker | | `CXX=` | Manually set which compiler to use | Example: `make ADDFLAGS=-march=native` might give a performance boost if compiling only for your own system. Notice! If using LDAP Authentication, usernames will show as UID number for LDAP users if compiling statically with glibc. 4. **Install** ```bash sudo make install ``` Append `PREFIX=/target/dir` to set target, default: `/usr/local` Notice! Only use "sudo" when installing to a NON user owned directory. 5. **(Optional/Required for Intel GPU support and CPU wattage) Set extended capabilities or suid bit to btop** No need for `sudo` to enable signal sending to any process and to prevent /proc read permissions problems on some systems. Also required for Intel GPU monitoring and CPU wattage monitoring. Run after make install and use same PREFIX if any was used at install. ```bash sudo make setcap ``` or Set `SU_USER` and `SU_GROUP` to select user and group, default is `root` and `root` ```bash sudo make setuid ``` * **Uninstall** ```bash sudo make uninstall ``` * **Remove any object files from source dir** ```bash make clean ``` * **Remove all object files, binaries and created directories in source dir** ```bash make distclean ``` * **Show help** ```bash make help ```
### With CMake (Community maintained) 1. **Install build dependencies** Requires Clang / GCC, CMake, Ninja, Lowdown and Git For example, with Debian Bookworm: ```bash sudo apt install cmake git g++ ninja-build lowdown ``` 2. **Clone the repository** ```bash git clone https://github.com/aristocratos/btop.git && cd btop `````` 3. **Compile** ```bash # Configure cmake -B build -G Ninja # Build cmake --build build ``` This will automatically build a release version of btop. Some useful options to pass to the configure step: | Configure flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `-DBTOP_STATIC=` | Enables static linking (OFF by default) | | `-DBTOP_LTO=` | Enables link time optimization (ON by default) | | `-DBTOP_GPU=` | Enable GPU support (ON by default) | | `-DBTOP_RSMI_STATIC=` | Build and link the ROCm SMI library statically (OFF by default) | | `-DCMAKE_INSTALL_PREFIX=` | The installation prefix ('/usr/local' by default) | To force any other compiler, run `CXX= cmake -B build -G Ninja` 4. **Install** ```bash cmake --install build ``` May require root privileges 5. **Uninstall** CMake doesn't generate an uninstall target by default. To remove installed files, run ``` cat build/install_manifest.txt | xargs rm -irv ``` 6. **Cleanup build directory** ```bash cmake --build build -t clean ```
## Compilation macOS OSX Requires at least GCC 14 or Clang 19. The Makefile also needs GNU coreutils and `sed`. Install and use Homebrew or MacPorts package managers for easy dependency installation
### With Make 1. **Install dependencies (example for Homebrew)** ```bash brew install coreutils make gcc@15 lowdown ``` 2. **Clone repository** ```bash git clone https://github.com/aristocratos/btop.git cd btop ``` 3. **Compile** ```bash gmake ``` Options for make: | Flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `VERBOSE=true` | To display full compiler/linker commands | | `STATIC=true` | For static compilation (only libgcc and libstdc++) | | `QUIET=true` | For less verbose output | | `STRIP=true` | To force stripping of debug symbols (adds `-s` linker flag) | | `DEBUG=true` | Sets OPTFLAGS to `-O0 -g` and enables more verbose debug logging | | `ARCH=` | To manually set the target architecture | | `ADDFLAGS=` | For appending flags to both compiler and linker | | `CXX=` | Manually set which compiler to use | Example: `gmake ADDFLAGS=-march=native` might give a performance boost if compiling only for your own system. 4. **Install** ```bash sudo gmake install ``` Append `PREFIX=/target/dir` to set target, default: `/usr/local` Notice! Only use "sudo" when installing to a NON user owned directory. 5. **(Recommended) Set suid bit to make btop always run as root (or other user)** ```bash sudo gmake setuid ``` No need for `sudo` to see information for non user owned processes and to enable signal sending to any process. Run after make install and use same PREFIX if any was used at install. Set `SU_USER` and `SU_GROUP` to select user and group, default is `root` and `wheel` * **Uninstall** ```bash sudo gmake uninstall ``` * **Remove any object files from source dir** ```bash gmake clean ``` * **Remove all object files, binaries and created directories in source dir** ```bash gmake distclean ``` * **Show help** ```bash gmake help ```
### With CMake (Community maintained) 1. **Install build dependencies** Requires Clang, CMake, Ninja, Lowdown and Git ```bash brew update --quiet brew install cmake git llvm ninja lowdown ``` 2. **Clone the repository** ```bash git clone https://github.com/aristocratos/btop.git && cd btop ``` 3. **Compile** ```bash # Configure export LLVM_PREFIX="$(brew --prefix llvm)" export CXX="$LLVM_PREFIX/bin/clang++" export CPPFLAGS="-I$LLVM_PREFIX/include" export LDFLAGS="-L$LLVM_PREFIX/lib -L$LLVM_PREFIX/lib/c++ -Wl,-rpath,$LLVM_PREFIX/lib/c++ -fuse-ld=$LLVM_PREFIX/bin/ld64.lld" cmake -B build -G Ninja # Build cmake --build build ``` This will automatically build a release version of btop. Some useful options to pass to the configure step: | Configure flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `-DBTOP_LTO=` | Enables link time optimization (ON by default) | | `-DCMAKE_INSTALL_PREFIX=` | The installation prefix ('/usr/local' by default) | To force any specific compiler, run `CXX= cmake -B build -G Ninja` 4. **Install** ```bash cmake --install build ``` May require root privileges 5. **Uninstall** CMake doesn't generate an uninstall target by default. To remove installed files, run ``` cat build/install_manifest.txt | xargs rm -irv ``` 6. **Cleanup build directory** ```bash cmake --build build -t clean ```
## Compilation FreeBSD Requires at least Clang 19 (default) or GCC 14. Note that GNU make (`gmake`) is required to compile on FreeBSD.
### With gmake 1. **Install dependencies** ```bash sudo pkg install gmake coreutils git lowdown ``` 2. **Clone repository** ```bash git clone https://github.com/aristocratos/btop.git cd btop ``` 3. **Compile** ```bash gmake ``` Options for make: | Flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `VERBOSE=true` | To display full compiler/linker commands | | `STATIC=true` | For static compilation (only libgcc and libstdc++) | | `QUIET=true` | For less verbose output | | `STRIP=true` | To force stripping of debug symbols (adds `-s` linker flag) | | `DEBUG=true` | Sets OPTFLAGS to `-O0 -g` and enables more verbose debug logging | | `ARCH=` | To manually set the target architecture | | `ADDFLAGS=` | For appending flags to both compiler and linker | | `CXX=` | Manually set which compiler to use | Example: `gmake ADDFLAGS=-march=native` might give a performance boost if compiling only for your own system. 4. **Install** ```bash sudo gmake install ``` Append `PREFIX=/target/dir` to set target, default: `/usr/local` Notice! Only use "sudo" when installing to a NON user owned directory. 5. **(Recommended) Set suid bit to make btop always run as root (or other user)** ```bash sudo gmake setuid ``` No need for `sudo` to see information for non user owned processes and to enable signal sending to any process. Run after make install and use same PREFIX if any was used at install. Set `SU_USER` and `SU_GROUP` to select user and group, default is `root` and `wheel` * **Uninstall** ```bash sudo gmake uninstall ``` * **Remove any object files from source dir** ```bash gmake clean ``` * **Remove all object files, binaries and created directories in source dir** ```bash gmake distclean ``` * **Show help** ```bash gmake help ```
### With CMake (Community maintained) 1. **Install build dependencies** Requires Clang / GCC, CMake, Ninja, Lowdown and Git ```bash pkg install cmake ninja lowdown ``` 2. **Clone the repository** ```bash git clone https://github.com/aristocratos/btop.git && cd btop ``` 3. **Compile** ```bash # Configure cmake -B build -G Ninja # Build cmake --build build ``` This will automatically build a release version of btop. Some useful options to pass to the configure step: | Configure flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `-DBTOP_STATIC=` | Enables static linking (OFF by default) | | `-DBTOP_LTO=` | Enables link time optimization (ON by default) | | `-DCMAKE_INSTALL_PREFIX=` | The installation prefix ('/usr/local' by default) | _**Note:** Static linking does not work with GCC._ To force any other compiler, run `CXX= cmake -B build -G Ninja` 4. **Install** ```bash cmake --install build ``` May require root privileges 5. **Uninstall** CMake doesn't generate an uninstall target by default. To remove installed files, run ``` cat build/install_manifest.txt | xargs rm -irv ``` 6. **Cleanup build directory** ```bash cmake --build build -t clean ```
## Compilation NetBSD Requires at least GCC 14. Note that GNU make (`gmake`) is required to compile on NetBSD.
### With gmake 1. **Install dependencies** ```bash /usr/sbin/pkg_add pkgin pkgin install -y coregutils gcc14 git gmake ``` 2. **Clone repository** ```bash git clone https://github.com/aristocratos/btop.git cd btop ``` 3. **Compile** ```bash CXX=/usr/pkg/gcc14/bin/g++ gmake CXXFLAGS="-DNDEBUG" ``` Options for make: | Flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `VERBOSE=true` | To display full compiler/linker commands | | `STATIC=true` | For static compilation (only libgcc and libstdc++) | | `QUIET=true` | For less verbose output | | `STRIP=true` | To force stripping of debug symbols (adds `-s` linker flag) | | `DEBUG=true` | Sets OPTFLAGS to `-O0 -g` and enables more verbose debug logging | | `ARCH=` | To manually set the target architecture | | `ADDFLAGS=` | For appending flags to both compiler and linker | | `CXX=` | Manually set which compiler to use | Example: `gmake ADDFLAGS=-march=native` might give a performance boost if compiling only for your own system. 4. **Install** ```bash sudo gmake install ``` Append `PREFIX=/target/dir` to set target, default: `/usr/local` Notice! Only use "sudo" when installing to a NON user owned directory. 5. **(Recommended) Set suid bit to make btop always run as root (or other user)** ```bash sudo gmake setuid ``` No need for `sudo` to see information for non user owned processes and to enable signal sending to any process. Run after make install and use same PREFIX if any was used at install. Set `SU_USER` and `SU_GROUP` to select user and group, default is `root` and `wheel` * **Uninstall** ```bash sudo gmake uninstall ``` * **Remove any object files from source dir** ```bash gmake clean ``` * **Remove all object files, binaries and created directories in source dir** ```bash gmake distclean ``` * **Show help** ```bash gmake help ```
### With CMake (Community maintained) 1. **Install build dependencies** Requires GCC, CMake, Ninja and Git ```bash /usr/sbin/pkg_add pkgin pkgin install cmake ninja-build gcc14 git ``` 2. **Clone the repository** ```bash git clone https://github.com/aristocratos/btop.git && cd btop ``` 3. **Compile** ```bash # Configure CXX="/usr/pkg/gcc14/bin/g++" cmake -B build -G Ninja # Build cmake --build build ``` This will automatically build a release version of btop. Some useful options to pass to the configure step: | Configure flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `-DBTOP_LTO=` | Enables link time optimization (ON by default) | | `-DCMAKE_INSTALL_PREFIX=` | The installation prefix ('/usr/local' by default) | To force any other compiler, run `CXX= cmake -B build -G Ninja` 4. **Install** ```bash cmake --install build ``` May require root privileges 5. **Uninstall** CMake doesn't generate an uninstall target by default. To remove installed files, run ``` cat build/install_manifest.txt | xargs rm -irv ``` 6. **Cleanup build directory** ```bash cmake --build build -t clean ```
## Compilation OpenBSD Note that GNU make (`gmake`) is required to compile on OpenBSD.
### With gmake 1. **Install dependencies** ```bash pkg_add coreutils git gmake lowdown ``` 2. **Clone repository** ```bash git clone https://github.com/aristocratos/btop.git cd btop ``` 3. **Compile** ```bash gmake ``` Options for make: | Flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `VERBOSE=true` | To display full compiler/linker commands | | `STATIC=true` | For static compilation (only libgcc and libstdc++) | | `QUIET=true` | For less verbose output | | `STRIP=true` | To force stripping of debug symbols (adds `-s` linker flag) | | `DEBUG=true` | Sets OPTFLAGS to `-O0 -g` and enables more verbose debug logging | | `ARCH=` | To manually set the target architecture | | `ADDFLAGS=` | For appending flags to both compiler and linker | | `CXX=` | Manually set which compiler to use | Example: `gmake ADDFLAGS=-march=native` might give a performance boost if compiling only for your own system. 4. **Install** ```bash sudo gmake install ``` Append `PREFIX=/target/dir` to set target, default: `/usr/local` Notice! Only use "sudo" when installing to a NON user owned directory. 5. **(Recommended) Set suid bit to make btop always run as root (or other user)** ```bash sudo gmake setuid ``` No need for `sudo` to see information for non user owned processes and to enable signal sending to any process. Run after make install and use same PREFIX if any was used at install. Set `SU_USER` and `SU_GROUP` to select user and group, default is `root` and `wheel` * **Uninstall** ```bash sudo gmake uninstall ``` * **Remove any object files from source dir** ```bash gmake clean ``` * **Remove all object files, binaries and created directories in source dir** ```bash gmake distclean ``` * **Show help** ```bash gmake help ```
### With CMake (Community maintained) 1. **Install build dependencies** Requires GCC, CMake, Ninja, Lowdown and Git _**Note:** LLVM's libc++ shipped with OpenBSD 7.4 is too old and cannot compile btop._ ```bash pkg_add cmake git ninja lowdown ``` 2. **Clone the repository** ```bash git clone https://github.com/aristocratos/btop.git && cd btop ``` 3. **Compile** ```bash # Configure cmake -B build -G Ninja # Build cmake --build build ``` This will automatically build a release version of btop. Some useful options to pass to the configure step: | Configure flag | Description | |---------------------------------|-------------------------------------------------------------------------| | `-DBTOP_LTO=` | Enables link time optimization (ON by default) | | `-DCMAKE_INSTALL_PREFIX=` | The installation prefix ('/usr/local' by default) | To force any other compiler, run `CXX= cmake -B build -G Ninja` 4. **Install** ```bash cmake --install build ``` May require root privileges 5. **Uninstall** CMake doesn't generate an uninstall target by default. To remove installed files, run ``` cat build/install_manifest.txt | xargs rm -irv ``` 6. **Cleanup build directory** ```bash cmake --build build -t clean ```
## Testing Testing requires [CMake](cmake.org). Tests are build by default and can be run with `ctest --test-dir `. If you want to disable building tests, pass `-DBUILD_TESTING=OFF` to the configure step. ## Installing the snap [![btop](https://snapcraft.io/btop/badge.svg)](https://snapcraft.io/btop) ### Note: there are now two snaps available: `btop` and `btop-desktop`. The desktop version is much larger and includes the desktop entries needed to allow for launching `btop` with a click. * **Install the snap** ```bash sudo snap install btop or sudo snap install btop-desktop ``` * **Install the latest snap from the edge channel** ``` sudo snap install btop --edge or sudo snap install btop-desktop --edge ``` * **Connect the interface** ```bash sudo snap connect btop:removable-media or sudo snap connect btop-desktop:removable-media ``` ## Configurability All options changeable from within UI. Config and log files stored in `$XDG_CONFIG_HOME/btop` or `$HOME/.config/btop` folder #### btop.conf: (auto generated if not found) ```toml #? Config file for btop v.1.4.5 #* Name of a btop++/bpytop/bashtop formatted ".theme" file, "Default" and "TTY" for builtin themes. #* Themes should be placed in "../share/btop/themes" relative to binary or "$HOME/.config/btop/themes" color_theme = "Default" #* If the theme set background should be shown, set to False if you want terminal background transparency. theme_background = true #* Sets if 24-bit truecolor should be used, will convert 24-bit colors to 256 color (6x6x6 color cube) if false. truecolor = true #* Set to true to force tty mode regardless if a real tty has been detected or not. #* Will force 16-color mode and TTY theme, set all graph symbols to "tty" and swap out other non tty friendly symbols. force_tty = false #* Define presets for the layout of the boxes. Preset 0 is always all boxes shown with default settings. Max 9 presets. #* Format: "box_name:P:G,box_name:P:G" P=(0 or 1) for alternate positions, G=graph symbol to use for box. #* Use whitespace " " as separator between different presets. #* Example: "cpu:0:default,mem:0:tty,proc:1:default cpu:0:braille,proc:0:tty" presets = "cpu:1:default,proc:0:default cpu:0:default,mem:0:default,net:0:default cpu:0:block,net:0:tty" #* Set to True to enable "h,j,k,l,g,G" keys for directional control in lists. #* Conflicting keys for h:"help" and k:"kill" is accessible while holding shift. vim_keys = false #* Rounded corners on boxes, is ignored if TTY mode is ON. rounded_corners = true #* Use terminal synchronized output sequences to reduce flickering on supported terminals. terminal_sync = true #* Default symbols to use for graph creation, "braille", "block" or "tty". #* "braille" offers the highest resolution but might not be included in all fonts. #* "block" has half the resolution of braille but uses more common characters. #* "tty" uses only 3 different symbols but will work with most fonts and should work in a real TTY. #* Note that "tty" only has half the horizontal resolution of the other two, so will show a shorter historical view. graph_symbol = "braille" # Graph symbol to use for graphs in cpu box, "default", "braille", "block" or "tty". graph_symbol_cpu = "default" # Graph symbol to use for graphs in cpu box, "default", "braille", "block" or "tty". graph_symbol_mem = "default" # Graph symbol to use for graphs in cpu box, "default", "braille", "block" or "tty". graph_symbol_net = "default" # Graph symbol to use for graphs in cpu box, "default", "braille", "block" or "tty". graph_symbol_proc = "default" #* Manually set which boxes to show. Available values are "cpu mem net proc" and "gpu0" through "gpu5", separate values with whitespace. shown_boxes = "cpu mem net proc" #* Update time in milliseconds, recommended 2000 ms or above for better sample times for graphs. update_ms = 2000 #* Processes sorting, "pid" "program" "arguments" "threads" "user" "memory" "cpu lazy" "cpu direct", #* "cpu lazy" sorts top process over time (easier to follow), "cpu direct" updates top process directly. proc_sorting = "cpu lazy" #* Reverse sorting order, True or False. proc_reversed = false #* Show processes as a tree. proc_tree = false #* Use the cpu graph colors in the process list. proc_colors = true #* Use a darkening gradient in the process list. proc_gradient = true #* If process cpu usage should be of the core it's running on or usage of the total available cpu power. proc_per_core = false #* Show process memory as bytes instead of percent. proc_mem_bytes = true #* Show cpu graph for each process. proc_cpu_graphs = true #* Use /proc/[pid]/smaps for memory information in the process info box (very slow but more accurate) proc_info_smaps = false #* Show proc box on left side of screen instead of right. proc_left = false #* (Linux) Filter processes tied to the Linux kernel(similar behavior to htop). proc_filter_kernel = false #* Should the process list follow the selected process when detailed view is open. proc_follow_detailed = true #* In tree-view, always accumulate child process resources in the parent process. proc_aggregate = false #* Should cpu and memory usage display be preserved for dead processes when paused. keep_dead_proc_usage = false #* Sets the CPU stat shown in upper half of the CPU graph, "total" is always available. #* Select from a list of detected attributes from the options menu. cpu_graph_upper = "Auto" #* Sets the CPU stat shown in lower half of the CPU graph, "total" is always available. #* Select from a list of detected attributes from the options menu. cpu_graph_lower = "Auto" #* Toggles if the lower CPU graph should be inverted. cpu_invert_lower = true #* Set to True to completely disable the lower CPU graph. cpu_single_graph = false #* Show cpu box at bottom of screen instead of top. cpu_bottom = false #* Shows the system uptime in the CPU box. show_uptime = true #* Shows the CPU package current power consumption in watts. Requires running `make setcap` or `make setuid` or running with sudo. show_cpu_watts = true #* Show cpu temperature. check_temp = true #* Which sensor to use for cpu temperature, use options menu to select from list of available sensors. cpu_sensor = "Auto" #* Show temperatures for cpu cores also if check_temp is True and sensors has been found. show_coretemp = true #* Set a custom mapping between core and coretemp, can be needed on certain cpus to get correct temperature for correct core. #* Use lm-sensors or similar to see which cores are reporting temperatures on your machine. #* Format "x:y" x=core with wrong temp, y=core with correct temp, use space as separator between multiple entries. #* Example: "4:0 5:1 6:3" cpu_core_map = "" #* Which temperature scale to use, available values: "celsius", "fahrenheit", "kelvin" and "rankine". temp_scale = "celsius" #* Use base 10 for bits/bytes sizes, KB = 1000 instead of KiB = 1024. base_10_sizes = false #* Show CPU frequency. show_cpu_freq = true #* How to calculate CPU frequency, available values: "first", "range", "lowest", "highest" and "average". freq_mode = "first" #* Draw a clock at top of screen, formatting according to strftime, empty string to disable. #* Special formatting: /host = hostname | /user = username | /uptime = system uptime clock_format = "%X" #* Update main ui in background when menus are showing, set this to false if the menus is flickering too much for comfort. background_update = true #* Custom cpu model name, empty string to disable. custom_cpu_name = "" #* Optional filter for shown disks, should be full path of a mountpoint, separate multiple values with whitespace " ". #* Only disks matching the filter will be shown. Prepend exclude= to only show disks not matching the filter. Examples: disk_filter="/boot /home/user", disks_filter="exclude=/boot /home/user" disks_filter = "" #* Show graphs instead of meters for memory values. mem_graphs = true #* Show mem box below net box instead of above. mem_below_net = false #* Count ZFS ARC in cached and available memory. zfs_arc_cached = true #* If swap memory should be shown in memory box. show_swap = true #* Show swap as a disk, ignores show_swap value above, inserts itself after first disk. swap_disk = true #* If mem box should be split to also show disks info. show_disks = true #* Filter out non physical disks. Set this to False to include network disks, RAM disks and similar. only_physical = true #* Read disks list from /etc/fstab. This also disables only_physical. use_fstab = true #* Setting this to True will hide all datasets, and only show ZFS pools. (IO stats will be calculated per-pool) zfs_hide_datasets = false #* Set to true to show available disk space for privileged users. disk_free_priv = false #* Toggles if io activity % (disk busy time) should be shown in regular disk usage view. show_io_stat = true #* Toggles io mode for disks, showing big graphs for disk read/write speeds. io_mode = false #* Set to True to show combined read/write io graphs in io mode. io_graph_combined = false #* Set the top speed for the io graphs in MiB/s (100 by default), use format "mountpoint:speed" separate disks with whitespace " ". #* Example: "/mnt/media:100 /:20 /boot:1". io_graph_speeds = "" #* Set fixed values for network graphs in Mebibits. Is only used if net_auto is also set to False. net_download = 100 net_upload = 100 #* Use network graphs auto rescaling mode, ignores any values set above and rescales down to 10 Kibibytes at the lowest. net_auto = true #* Sync the auto scaling for download and upload to whichever currently has the highest scale. net_sync = true #* Starts with the Network Interface specified here. net_iface = "" #* "True" shows bitrates in base 10 (Kbps, Mbps). "False" shows bitrates in binary sizes (Kibps, Mibps, etc.). "Auto" uses base_10_sizes. base_10_bitrate = "Auto" #* Show battery stats in top right if battery is present. show_battery = true #* Which battery to use if multiple are present. "Auto" for auto detection. selected_battery = "Auto" #* Show power stats of battery next to charge indicator. show_battery_watts = true #* Set loglevel for "~/.local/state/btop.log" levels are: "ERROR" "WARNING" "INFO" "DEBUG". #* The level set includes all lower levels, i.e. "DEBUG" will show all logging info. log_level = "WARNING" ``` #### Command line options ```text Usage: btop [OPTIONS] Options: -c, --config Path to a config file -d, --debug Start in debug mode with additional logs and metrics -f, --filter Set an initial process filter --force-utf Override automatic UTF locale detection -l, --low-color Disable true color, 256 colors only -p, --preset Start with a preset (0-9) -t, --tty Force tty mode with ANSI graph symbols and 16 colors only --no-tty Force disable tty mode -u, --update Set an initial update rate in milliseconds --default-config Print default config to standard output -h, --help Show this help message and exit -V, --version Show a version message and exit (more with --version) ``` ## LICENSE [Apache License 2.0](LICENSE) aristocratos-btop-d43a485/btop.desktop000066400000000000000000000014701517514752700201060ustar00rootroot00000000000000[Desktop Entry] Type=Application Version=1.0 Name=btop++ GenericName=System Monitor GenericName[it]=Monitor di sistema GenericName[zh_TW]=็ณป็ตฑ็›ฃ่ฆ–ๅ™จ GenericName[pt_BR]=Monitor de sistema Comment=Resource monitor that shows usage and stats for processor, memory, disks, network and processes Comment[it]=Monitoraggio delle risorse: mostra utilizzo e statistiche per CPU, dischi, rete e processi Comment[zh_TW]=้กฏ็คบ่™•็†ๅ™จใ€ไธป่จ˜ๆ†ถ้ซ”ใ€็ฃ็ขŸใ€็ถฒ่ทฏ่ˆ‡้€ฒ็จ‹็š„ไฝฟ็”จ่ˆ‡็ตฑ่จˆๆ•ธๆ“š็š„่ณ‡ๆบ็›ฃ่ฆ–ๅ™จๆ‡‰็”จ็จ‹ๅผ Comment[pt_BR]=Monitoramente de atividades com estatisticas e graficos por CPU, disco, rede e processos Icon=btop Exec=btop Terminal=true Categories=System;Monitor;ConsoleOnly; Keywords=system;process;task Keywords[zh_TW]=็ณป็ตฑ;้€ฒ็จ‹;่™•็†็จ‹ๅบ;ไปปๅ‹™ Keywords[pt_BR]=sistema;processos;tarefas aristocratos-btop-d43a485/cmake/000077500000000000000000000000001517514752700166255ustar00rootroot00000000000000aristocratos-btop-d43a485/cmake/Finddevstat.cmake000066400000000000000000000013601517514752700221020ustar00rootroot00000000000000# SPDX-License-Identifier: Apache-2.0 # # Find devstat, the Device Statistics Library # if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "MidnightBSD") find_path(devstat_INCLUDE_DIR NAMES devstat.h) find_library(devstat_LIBRARY NAMES devstat) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(devstat REQUIRED_VARS devstat_LIBRARY devstat_INCLUDE_DIR) if(devstat_FOUND AND NOT TARGET devstat::devstat) add_library(devstat::devstat UNKNOWN IMPORTED) set_target_properties(devstat::devstat PROPERTIES IMPORTED_LOCATION "${devstat_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${devstat_INCLUDE_DIR}" ) endif() mark_as_advanced(devstat_INCLUDE_DIR devstat_LIBRARY) endif() aristocratos-btop-d43a485/cmake/Findelf.cmake000066400000000000000000000012431517514752700211760ustar00rootroot00000000000000# SPDX-License-Identifier: Apache-2.0 # # Find libelf, the ELF Access Library # if(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD" OR CMAKE_SYSTEM_NAME STREQUAL "MidnightBSD") find_path(elf_INCLUDE_DIR NAMES libelf.h) find_library(elf_LIBRARY NAMES elf) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(elf REQUIRED_VARS elf_LIBRARY elf_INCLUDE_DIR) if(elf_FOUND AND NOT TARGET elf::elf) add_library(elf::elf UNKNOWN IMPORTED) set_target_properties(elf::elf PROPERTIES IMPORTED_LOCATION "${elf_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${elf_INCLUDE_DIR}" ) endif() mark_as_advanced(elf_INCLUDE_DIR elf_LIBRARY) endif() aristocratos-btop-d43a485/cmake/Findkvm.cmake000066400000000000000000000011331517514752700212230ustar00rootroot00000000000000# SPDX-License-Identifier: Apache-2.0 # # Find libkvm, the Kernel Data Access Library # if(BSD) find_path(kvm_INCLUDE_DIR NAMES kvm.h) find_library(kvm_LIBRARY NAMES kvm) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(kvm REQUIRED_VARS kvm_LIBRARY kvm_INCLUDE_DIR) if(kvm_FOUND AND NOT TARGET kvm::kvm) add_library(kvm::kvm UNKNOWN IMPORTED) set_target_properties(kvm::kvm PROPERTIES IMPORTED_LOCATION "${kvm_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${kvm_INCLUDE_DIR}" ) endif() mark_as_advanced(kvm_INCLUDE_DIR kvm_LIBRARY) endif() aristocratos-btop-d43a485/cmake/Findproplib.cmake000066400000000000000000000012641517514752700221020ustar00rootroot00000000000000# SPDX-License-Identifier: Apache-2.0 # # Find proplib โ€“ property container object library # if(BSD) find_path(proplib_INCLUDE_DIR NAMES prop/proplib.h) find_library(proplib_LIBRARY NAMES libprop prop) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(proplib REQUIRED_VARS proplib_LIBRARY proplib_INCLUDE_DIR) if(proplib_FOUND AND NOT TARGET proplib::proplib) add_library(proplib::proplib UNKNOWN IMPORTED) set_target_properties(proplib::proplib PROPERTIES IMPORTED_LOCATION "${proplib_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${proplib_INCLUDE_DIR}" ) endif() mark_as_advanced(proplib_INCLUDE_DIR proplib_LIBRARY) endif() aristocratos-btop-d43a485/include/000077500000000000000000000000001517514752700171705ustar00rootroot00000000000000aristocratos-btop-d43a485/include/fmt/000077500000000000000000000000001517514752700177565ustar00rootroot00000000000000aristocratos-btop-d43a485/include/fmt/LICENSE.rst000066400000000000000000000026271517514752700216010ustar00rootroot00000000000000Copyright (c) 2012 - present, Victor Zverovich and {fmt} 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 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. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. aristocratos-btop-d43a485/include/fmt/args.h000066400000000000000000000160371517514752700210720ustar00rootroot00000000000000// Formatting library for C++ - dynamic argument lists // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_ARGS_H_ #define FMT_ARGS_H_ #ifndef FMT_MODULE # include // std::reference_wrapper # include // std::unique_ptr # include #endif #include "format.h" // std_string_view FMT_BEGIN_NAMESPACE namespace detail { template struct is_reference_wrapper : std::false_type {}; template struct is_reference_wrapper> : std::true_type {}; template auto unwrap(const T& v) -> const T& { return v; } template auto unwrap(const std::reference_wrapper& v) -> const T& { return static_cast(v); } // node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC // 2022 (v17.10.0). // // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for // templates it doesn't complain about inability to deduce single translation // unit for placing vtable. So node is made a fake template. template struct node { virtual ~node() = default; std::unique_ptr> next; }; class dynamic_arg_list { template struct typed_node : node<> { T value; template FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {} template FMT_CONSTEXPR typed_node(const basic_string_view& arg) : value(arg.data(), arg.size()) {} }; std::unique_ptr> head_; public: template auto push(const Arg& arg) -> const T& { auto new_node = std::unique_ptr>(new typed_node(arg)); auto& value = new_node->value; new_node->next = std::move(head_); head_ = std::move(new_node); return value; } }; } // namespace detail /** * A dynamic list of formatting arguments with storage. * * It can be implicitly converted into `fmt::basic_format_args` for passing * into type-erased formatting functions such as `fmt::vformat`. */ FMT_EXPORT template class dynamic_format_arg_store { private: using char_type = typename Context::char_type; template struct need_copy { static constexpr detail::type mapped_type = detail::mapped_type_constant::value; enum { value = !(detail::is_reference_wrapper::value || std::is_same>::value || std::is_same>::value || (mapped_type != detail::type::cstring_type && mapped_type != detail::type::string_type && mapped_type != detail::type::custom_type)) }; }; template using stored_t = conditional_t< std::is_convertible>::value && !detail::is_reference_wrapper::value, std::basic_string, T>; // Storage of basic_format_arg must be contiguous. std::vector> data_; std::vector> named_info_; // Storage of arguments not fitting into basic_format_arg must grow // without relocation because items in data_ refer to it. detail::dynamic_arg_list dynamic_args_; friend class basic_format_args; auto data() const -> const basic_format_arg* { return named_info_.empty() ? data_.data() : data_.data() + 1; } template void emplace_arg(const T& arg) { data_.emplace_back(arg); } template void emplace_arg(const detail::named_arg& arg) { if (named_info_.empty()) data_.insert(data_.begin(), basic_format_arg(nullptr, 0)); data_.emplace_back(detail::unwrap(arg.value)); auto pop_one = [](std::vector>* data) { data->pop_back(); }; std::unique_ptr>, decltype(pop_one)> guard{&data_, pop_one}; named_info_.push_back({arg.name, static_cast(data_.size() - 2u)}); data_[0] = {named_info_.data(), named_info_.size()}; guard.release(); } public: constexpr dynamic_format_arg_store() = default; operator basic_format_args() const { return basic_format_args(data(), static_cast(data_.size()), !named_info_.empty()); } /** * Adds an argument into the dynamic store for later passing to a formatting * function. * * Note that custom types and string types (but not string views) are copied * into the store dynamically allocating memory if necessary. * * **Example**: * * fmt::dynamic_format_arg_store store; * store.push_back(42); * store.push_back("abc"); * store.push_back(1.5f); * std::string result = fmt::vformat("{} and {} and {}", store); */ template void push_back(const T& arg) { if (detail::const_check(need_copy::value)) emplace_arg(dynamic_args_.push>(arg)); else emplace_arg(detail::unwrap(arg)); } /** * Adds a reference to the argument into the dynamic store for later passing * to a formatting function. * * **Example**: * * fmt::dynamic_format_arg_store store; * char band[] = "Rolling Stones"; * store.push_back(std::cref(band)); * band[9] = 'c'; // Changing str affects the output. * std::string result = fmt::vformat("{}", store); * // result == "Rolling Scones" */ template void push_back(std::reference_wrapper arg) { static_assert( need_copy::value, "objects of built-in types and string views are always copied"); emplace_arg(arg.get()); } /** * Adds named argument into the dynamic store for later passing to a * formatting function. `std::reference_wrapper` is supported to avoid * copying of the argument. The name is always copied into the store. */ template void push_back(const detail::named_arg& arg) { const char_type* arg_name = dynamic_args_.push>(arg.name).c_str(); if (detail::const_check(need_copy::value)) { emplace_arg( fmt::arg(arg_name, dynamic_args_.push>(arg.value))); } else { emplace_arg(fmt::arg(arg_name, arg.value)); } } /// Erase all elements from the store. void clear() { data_.clear(); named_info_.clear(); dynamic_args_ = {}; } /// Reserves space to store at least `new_cap` arguments including /// `new_cap_named` named arguments. void reserve(size_t new_cap, size_t new_cap_named) { FMT_ASSERT(new_cap >= new_cap_named, "set of arguments includes set of named arguments"); data_.reserve(new_cap); named_info_.reserve(new_cap_named); } /// Returns the number of elements in the store. auto size() const noexcept -> size_t { return data_.size(); } }; FMT_END_NAMESPACE #endif // FMT_ARGS_H_ aristocratos-btop-d43a485/include/fmt/base.h000066400000000000000000003141641517514752700210520ustar00rootroot00000000000000// Formatting library for C++ - the base API for char/UTF-8 // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_BASE_H_ #define FMT_BASE_H_ #if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE) # define FMT_MODULE #endif #ifndef FMT_MODULE # include // CHAR_BIT # include // FILE # include // memcmp # include // std::enable_if #endif // The fmt library version in the form major * 10000 + minor * 100 + patch. #define FMT_VERSION 120000 // Detect compiler versions. #if defined(__clang__) && !defined(__ibmxl__) # define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #else # define FMT_CLANG_VERSION 0 #endif #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #else # define FMT_GCC_VERSION 0 #endif #if defined(__ICL) # define FMT_ICC_VERSION __ICL #elif defined(__INTEL_COMPILER) # define FMT_ICC_VERSION __INTEL_COMPILER #else # define FMT_ICC_VERSION 0 #endif #if defined(_MSC_VER) # define FMT_MSC_VERSION _MSC_VER #else # define FMT_MSC_VERSION 0 #endif // Detect standard library versions. #ifdef _GLIBCXX_RELEASE # define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE #else # define FMT_GLIBCXX_RELEASE 0 #endif #ifdef _LIBCPP_VERSION # define FMT_LIBCPP_VERSION _LIBCPP_VERSION #else # define FMT_LIBCPP_VERSION 0 #endif #ifdef _MSVC_LANG # define FMT_CPLUSPLUS _MSVC_LANG #else # define FMT_CPLUSPLUS __cplusplus #endif // Detect __has_*. #ifdef __has_feature # define FMT_HAS_FEATURE(x) __has_feature(x) #else # define FMT_HAS_FEATURE(x) 0 #endif #ifdef __has_include # define FMT_HAS_INCLUDE(x) __has_include(x) #else # define FMT_HAS_INCLUDE(x) 0 #endif #ifdef __has_builtin # define FMT_HAS_BUILTIN(x) __has_builtin(x) #else # define FMT_HAS_BUILTIN(x) 0 #endif #ifdef __has_cpp_attribute # define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) #else # define FMT_HAS_CPP_ATTRIBUTE(x) 0 #endif #define FMT_HAS_CPP14_ATTRIBUTE(attribute) \ (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute)) #define FMT_HAS_CPP17_ATTRIBUTE(attribute) \ (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute)) // Detect C++14 relaxed constexpr. #ifdef FMT_USE_CONSTEXPR // Use the provided definition. #elif FMT_GCC_VERSION >= 702 && FMT_CPLUSPLUS >= 201402L // GCC only allows constexpr member functions in non-literal types since 7.2: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66297. # define FMT_USE_CONSTEXPR 1 #elif FMT_ICC_VERSION # define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628 #elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 # define FMT_USE_CONSTEXPR 1 #else # define FMT_USE_CONSTEXPR 0 #endif #if FMT_USE_CONSTEXPR # define FMT_CONSTEXPR constexpr #else # define FMT_CONSTEXPR #endif // Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated. #if !defined(__cpp_lib_is_constant_evaluated) # define FMT_USE_CONSTEVAL 0 #elif FMT_CPLUSPLUS < 201709L # define FMT_USE_CONSTEVAL 0 #elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10 # define FMT_USE_CONSTEVAL 0 #elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000 # define FMT_USE_CONSTEVAL 0 #elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L # define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14. #elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929 # define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10. #elif defined(__cpp_consteval) # define FMT_USE_CONSTEVAL 1 #elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101 # define FMT_USE_CONSTEVAL 1 #else # define FMT_USE_CONSTEVAL 0 #endif #if FMT_USE_CONSTEVAL # define FMT_CONSTEVAL consteval # define FMT_CONSTEXPR20 constexpr #else # define FMT_CONSTEVAL # define FMT_CONSTEXPR20 #endif // Check if exceptions are disabled. #ifdef FMT_USE_EXCEPTIONS // Use the provided definition. #elif defined(__GNUC__) && !defined(__EXCEPTIONS) # define FMT_USE_EXCEPTIONS 0 #elif defined(__clang__) && !defined(__cpp_exceptions) # define FMT_USE_EXCEPTIONS 0 #elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS # define FMT_USE_EXCEPTIONS 0 #else # define FMT_USE_EXCEPTIONS 1 #endif #if FMT_USE_EXCEPTIONS # define FMT_TRY try # define FMT_CATCH(x) catch (x) #else # define FMT_TRY if (true) # define FMT_CATCH(x) if (false) #endif #ifdef FMT_NO_UNIQUE_ADDRESS // Use the provided definition. #elif FMT_CPLUSPLUS < 202002L // Not supported. #elif FMT_HAS_CPP_ATTRIBUTE(no_unique_address) # define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]] // VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485). #elif FMT_MSC_VERSION >= 1929 && !FMT_CLANG_VERSION # define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] #endif #ifndef FMT_NO_UNIQUE_ADDRESS # define FMT_NO_UNIQUE_ADDRESS #endif #if FMT_HAS_CPP17_ATTRIBUTE(fallthrough) # define FMT_FALLTHROUGH [[fallthrough]] #elif defined(__clang__) # define FMT_FALLTHROUGH [[clang::fallthrough]] #elif FMT_GCC_VERSION >= 700 && \ (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520) # define FMT_FALLTHROUGH [[gnu::fallthrough]] #else # define FMT_FALLTHROUGH #endif // Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings. #if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__) # define FMT_NORETURN [[noreturn]] #else # define FMT_NORETURN #endif #ifdef FMT_NODISCARD // Use the provided definition. #elif FMT_HAS_CPP17_ATTRIBUTE(nodiscard) # define FMT_NODISCARD [[nodiscard]] #else # define FMT_NODISCARD #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_VISIBILITY(value) __attribute__((visibility(value))) #else # define FMT_VISIBILITY(value) #endif // Detect pragmas. #define FMT_PRAGMA_IMPL(x) _Pragma(#x) #if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER) // Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884 // and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582. # define FMT_PRAGMA_GCC(x) FMT_PRAGMA_IMPL(GCC x) #else # define FMT_PRAGMA_GCC(x) #endif #if FMT_CLANG_VERSION # define FMT_PRAGMA_CLANG(x) FMT_PRAGMA_IMPL(clang x) #else # define FMT_PRAGMA_CLANG(x) #endif #if FMT_MSC_VERSION # define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__)) #else # define FMT_MSC_WARNING(...) #endif // Enable minimal optimizations for more compact code in debug mode. FMT_PRAGMA_GCC(push_options) #if !defined(__OPTIMIZE__) && !defined(__CUDACC__) && !defined(FMT_MODULE) FMT_PRAGMA_GCC(optimize("Og")) # define FMT_GCC_OPTIMIZED #endif FMT_PRAGMA_CLANG(diagnostic push) #ifdef FMT_ALWAYS_INLINE // Use the provided definition. #elif FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_ALWAYS_INLINE inline __attribute__((always_inline)) #else # define FMT_ALWAYS_INLINE inline #endif // A version of FMT_ALWAYS_INLINE to prevent code bloat in debug mode. #if defined(NDEBUG) || defined(FMT_GCC_OPTIMIZED) # define FMT_INLINE FMT_ALWAYS_INLINE #else # define FMT_INLINE inline #endif #ifndef FMT_BEGIN_NAMESPACE # define FMT_BEGIN_NAMESPACE \ namespace fmt { \ inline namespace v12 { # define FMT_END_NAMESPACE \ } \ } #endif #ifndef FMT_EXPORT # define FMT_EXPORT # define FMT_BEGIN_EXPORT # define FMT_END_EXPORT #endif #ifdef _WIN32 # define FMT_WIN32 1 #else # define FMT_WIN32 0 #endif #if !defined(FMT_HEADER_ONLY) && FMT_WIN32 # if defined(FMT_LIB_EXPORT) # define FMT_API __declspec(dllexport) # elif defined(FMT_SHARED) # define FMT_API __declspec(dllimport) # endif #elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) # define FMT_API FMT_VISIBILITY("default") #endif #ifndef FMT_API # define FMT_API #endif #ifndef FMT_OPTIMIZE_SIZE # define FMT_OPTIMIZE_SIZE 0 #endif // FMT_BUILTIN_TYPE=0 may result in smaller library size at the cost of higher // per-call binary size by passing built-in types through the extension API. #ifndef FMT_BUILTIN_TYPES # define FMT_BUILTIN_TYPES 1 #endif #define FMT_APPLY_VARIADIC(expr) \ using unused = int[]; \ (void)unused { 0, (expr, 0)... } FMT_BEGIN_NAMESPACE // Implementations of enable_if_t and other metafunctions for older systems. template using enable_if_t = typename std::enable_if::type; template using conditional_t = typename std::conditional::type; template using bool_constant = std::integral_constant; template using remove_reference_t = typename std::remove_reference::type; template using remove_const_t = typename std::remove_const::type; template using remove_cvref_t = typename std::remove_cv>::type; template using make_unsigned_t = typename std::make_unsigned::type; template using underlying_t = typename std::underlying_type::type; template using decay_t = typename std::decay::type; using nullptr_t = decltype(nullptr); #if (FMT_GCC_VERSION && FMT_GCC_VERSION < 500) || FMT_MSC_VERSION // A workaround for gcc 4.9 & MSVC v141 to make void_t work in a SFINAE context. template struct void_t_impl { using type = void; }; template using void_t = typename void_t_impl::type; #else template using void_t = void; #endif struct monostate { constexpr monostate() {} }; // An enable_if helper to be used in template parameters which results in much // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed // to workaround a bug in MSVC 2019 (see #1140 and #1186). #ifdef FMT_DOC # define FMT_ENABLE_IF(...) #else # define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0 #endif template constexpr auto min_of(T a, T b) -> T { return a < b ? a : b; } template constexpr auto max_of(T a, T b) -> T { return a > b ? a : b; } FMT_NORETURN FMT_API void assert_fail(const char* file, int line, const char* message); namespace detail { // Suppresses "unused variable" warnings with the method described in // https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/. // (void)var does not work on many Intel compilers. template FMT_CONSTEXPR void ignore_unused(const T&...) {} constexpr auto is_constant_evaluated(bool default_value = false) noexcept -> bool { // Workaround for incompatibility between clang 14 and libstdc++ consteval-based // std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247. #if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \ (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500) ignore_unused(default_value); return __builtin_is_constant_evaluated(); #elif defined(__cpp_lib_is_constant_evaluated) ignore_unused(default_value); return std::is_constant_evaluated(); #else return default_value; #endif } // Suppresses "conditional expression is constant" warnings. template FMT_ALWAYS_INLINE constexpr auto const_check(T val) -> T { return val; } FMT_NORETURN FMT_API void assert_fail(const char* file, int line, const char* message); #if defined(FMT_ASSERT) // Use the provided definition. #elif defined(NDEBUG) // FMT_ASSERT is not empty to avoid -Wempty-body. # define FMT_ASSERT(condition, message) \ fmt::detail::ignore_unused((condition), (message)) #else # define FMT_ASSERT(condition, message) \ ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \ ? (void)0 \ : ::fmt::assert_fail(__FILE__, __LINE__, (message))) #endif #ifdef FMT_USE_INT128 // Use the provided definition. #elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \ !(FMT_CLANG_VERSION && FMT_MSC_VERSION) # define FMT_USE_INT128 1 using int128_opt = __int128_t; // An optional native 128-bit integer. using uint128_opt = __uint128_t; inline auto map(int128_opt x) -> int128_opt { return x; } inline auto map(uint128_opt x) -> uint128_opt { return x; } #else # define FMT_USE_INT128 0 #endif #if !FMT_USE_INT128 enum class int128_opt {}; enum class uint128_opt {}; // Reduce template instantiations. inline auto map(int128_opt) -> monostate { return {}; } inline auto map(uint128_opt) -> monostate { return {}; } #endif #ifndef FMT_USE_BITINT # define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1500) #endif #if FMT_USE_BITINT FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension") template using bitint = _BitInt(N); template using ubitint = unsigned _BitInt(N); #else template struct bitint {}; template struct ubitint {}; #endif // FMT_USE_BITINT // Casts a nonnegative integer to unsigned. template FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t { FMT_ASSERT(std::is_unsigned::value || value >= 0, "negative value"); return static_cast>(value); } template using unsigned_char = conditional_t; // A heuristic to detect std::string and std::[experimental::]string_view. // It is mainly used to avoid dependency on <[experimental/]string_view>. template struct is_std_string_like : std::false_type {}; template struct is_std_string_like().find_first_of( typename T::value_type(), 0))>> : std::is_convertible().data()), const typename T::value_type*> {}; // Check if the literal encoding is UTF-8. enum { is_utf8_enabled = "\u00A7"[1] == '\xA7' }; enum { use_utf8 = !FMT_WIN32 || is_utf8_enabled }; #ifndef FMT_UNICODE # define FMT_UNICODE 1 #endif static_assert(!FMT_UNICODE || use_utf8, "Unicode support requires compiling with /utf-8"); template constexpr auto narrow(T*) -> char* { return nullptr; } constexpr FMT_ALWAYS_INLINE auto narrow(const char* s) -> const char* { return s; } template FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, size_t n) -> int { if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n); for (; n != 0; ++s1, ++s2, --n) { if (*s1 < *s2) return -1; if (*s1 > *s2) return 1; } return 0; } namespace adl { using namespace std; template auto invoke_back_inserter() -> decltype(back_inserter(std::declval())); } // namespace adl template struct is_back_insert_iterator : std::false_type {}; template struct is_back_insert_iterator< It, bool_constant()), It>::value>> : std::true_type {}; // Extracts a reference to the container from *insert_iterator. template inline FMT_CONSTEXPR20 auto get_container(OutputIt it) -> typename OutputIt::container_type& { struct accessor : OutputIt { FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {} using OutputIt::container; }; return *accessor(it).container; } } // namespace detail // Parsing-related public API and forward declarations. FMT_BEGIN_EXPORT /** * An implementation of `std::basic_string_view` for pre-C++17. It provides a * subset of the API. `fmt::basic_string_view` is used for format strings even * if `std::basic_string_view` is available to prevent issues when a library is * compiled with a different `-std` option than the client code (which is not * recommended). */ template class basic_string_view { private: const Char* data_; size_t size_; public: using value_type = Char; using iterator = const Char*; constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {} /// Constructs a string view object from a C string and a size. constexpr basic_string_view(const Char* s, size_t count) noexcept : data_(s), size_(count) {} constexpr basic_string_view(nullptr_t) = delete; /// Constructs a string view object from a C string. #if FMT_GCC_VERSION FMT_ALWAYS_INLINE #endif FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) { #if FMT_HAS_BUILTIN(__builtin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION if (std::is_same::value && !detail::is_constant_evaluated()) { size_ = __builtin_strlen(detail::narrow(s)); // strlen is not constexpr. return; } #endif size_t len = 0; while (*s++) ++len; size_ = len; } /// Constructs a string view from a `std::basic_string` or a /// `std::basic_string_view` object. template ::value&& std::is_same< typename S::value_type, Char>::value)> FMT_CONSTEXPR basic_string_view(const S& s) noexcept : data_(s.data()), size_(s.size()) {} /// Returns a pointer to the string data. constexpr auto data() const noexcept -> const Char* { return data_; } /// Returns the string size. constexpr auto size() const noexcept -> size_t { return size_; } constexpr auto begin() const noexcept -> iterator { return data_; } constexpr auto end() const noexcept -> iterator { return data_ + size_; } constexpr auto operator[](size_t pos) const noexcept -> const Char& { return data_[pos]; } FMT_CONSTEXPR void remove_prefix(size_t n) noexcept { data_ += n; size_ -= n; } FMT_CONSTEXPR auto starts_with(basic_string_view sv) const noexcept -> bool { return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0; } FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool { return size_ >= 1 && *data_ == c; } FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool { return starts_with(basic_string_view(s)); } FMT_CONSTEXPR auto compare(basic_string_view other) const -> int { int result = detail::compare(data_, other.data_, min_of(size_, other.size_)); if (result != 0) return result; return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); } FMT_CONSTEXPR friend auto operator==(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) == 0; } friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) != 0; } friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) < 0; } friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) <= 0; } friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) > 0; } friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool { return lhs.compare(rhs) >= 0; } }; using string_view = basic_string_view; template class basic_appender; using appender = basic_appender; // Checks whether T is a container with contiguous storage. template struct is_contiguous : std::false_type {}; class context; template class generic_context; template class parse_context; // Longer aliases for C++20 compatibility. template using basic_format_parse_context = parse_context; using format_parse_context = parse_context; template using basic_format_context = conditional_t::value, context, generic_context>; using format_context = context; template using buffered_context = conditional_t::value, context, generic_context, Char>>; template class basic_format_arg; template class basic_format_args; // A separate type would result in shorter symbols but break ABI compatibility // between clang and gcc on ARM (#1919). using format_args = basic_format_args; // A formatter for objects of type T. template struct formatter { // A deleted default constructor indicates a disabled formatter. formatter() = delete; }; /// Reports a format error at compile time or, via a `format_error` exception, /// at runtime. // This function is intentionally not constexpr to give a compile-time error. FMT_NORETURN FMT_API void report_error(const char* message); enum class presentation_type : unsigned char { // Common specifiers: none = 0, debug = 1, // '?' string = 2, // 's' (string, bool) // Integral, bool and character specifiers: dec = 3, // 'd' hex, // 'x' or 'X' oct, // 'o' bin, // 'b' or 'B' chr, // 'c' // String and pointer specifiers: pointer = 3, // 'p' // Floating-point specifiers: exp = 1, // 'e' or 'E' (1 since there is no FP debug presentation) fixed, // 'f' or 'F' general, // 'g' or 'G' hexfloat // 'a' or 'A' }; enum class align { none, left, right, center, numeric }; enum class sign { none, minus, plus, space }; enum class arg_id_kind { none, index, name }; // Basic format specifiers for built-in and string types. class basic_specs { private: // Data is arranged as follows: // // 0 1 2 3 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ // |type |align| w | p | s |u|#|L| f | unused | // +-----+-----+---+---+---+-+-+-+-----+---------------------------+ // // w - dynamic width info // p - dynamic precision info // s - sign // u - uppercase (e.g. 'X' for 'x') // # - alternate form ('#') // L - localized // f - fill size // // Bitfields are not used because of compiler bugs such as gcc bug 61414. enum : unsigned { type_mask = 0x00007, align_mask = 0x00038, width_mask = 0x000C0, precision_mask = 0x00300, sign_mask = 0x00C00, uppercase_mask = 0x01000, alternate_mask = 0x02000, localized_mask = 0x04000, fill_size_mask = 0x38000, align_shift = 3, width_shift = 6, precision_shift = 8, sign_shift = 10, fill_size_shift = 15, max_fill_size = 4 }; unsigned data_ = 1 << fill_size_shift; static_assert(sizeof(basic_specs::data_) * CHAR_BIT >= 18, ""); // Character (code unit) type is erased to prevent template bloat. char fill_data_[max_fill_size] = {' '}; FMT_CONSTEXPR void set_fill_size(size_t size) { data_ = (data_ & ~fill_size_mask) | (static_cast(size) << fill_size_shift); } public: constexpr auto type() const -> presentation_type { return static_cast(data_ & type_mask); } FMT_CONSTEXPR void set_type(presentation_type t) { data_ = (data_ & ~type_mask) | static_cast(t); } constexpr auto align() const -> align { return static_cast((data_ & align_mask) >> align_shift); } FMT_CONSTEXPR void set_align(fmt::align a) { data_ = (data_ & ~align_mask) | (static_cast(a) << align_shift); } constexpr auto dynamic_width() const -> arg_id_kind { return static_cast((data_ & width_mask) >> width_shift); } FMT_CONSTEXPR void set_dynamic_width(arg_id_kind w) { data_ = (data_ & ~width_mask) | (static_cast(w) << width_shift); } FMT_CONSTEXPR auto dynamic_precision() const -> arg_id_kind { return static_cast((data_ & precision_mask) >> precision_shift); } FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p) { data_ = (data_ & ~precision_mask) | (static_cast(p) << precision_shift); } constexpr auto dynamic() const -> bool { return (data_ & (width_mask | precision_mask)) != 0; } constexpr auto sign() const -> sign { return static_cast((data_ & sign_mask) >> sign_shift); } FMT_CONSTEXPR void set_sign(fmt::sign s) { data_ = (data_ & ~sign_mask) | (static_cast(s) << sign_shift); } constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; } FMT_CONSTEXPR void set_upper() { data_ |= uppercase_mask; } constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; } FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; } FMT_CONSTEXPR void clear_alt() { data_ &= ~alternate_mask; } constexpr auto localized() const -> bool { return (data_ & localized_mask) != 0; } FMT_CONSTEXPR void set_localized() { data_ |= localized_mask; } constexpr auto fill_size() const -> size_t { return (data_ & fill_size_mask) >> fill_size_shift; } template ::value)> constexpr auto fill() const -> const Char* { return fill_data_; } template ::value)> constexpr auto fill() const -> const Char* { return nullptr; } template constexpr auto fill_unit() const -> Char { using uchar = unsigned char; return static_cast(static_cast(fill_data_[0]) | (static_cast(fill_data_[1]) << 8) | (static_cast(fill_data_[2]) << 16)); } FMT_CONSTEXPR void set_fill(char c) { fill_data_[0] = c; set_fill_size(1); } template FMT_CONSTEXPR void set_fill(basic_string_view s) { auto size = s.size(); set_fill_size(size); if (size == 1) { unsigned uchar = static_cast>(s[0]); fill_data_[0] = static_cast(uchar); fill_data_[1] = static_cast(uchar >> 8); fill_data_[2] = static_cast(uchar >> 16); return; } FMT_ASSERT(size <= max_fill_size, "invalid fill"); for (size_t i = 0; i < size; ++i) fill_data_[i & 3] = static_cast(s[i]); } FMT_CONSTEXPR void copy_fill_from(const basic_specs& specs) { set_fill_size(specs.fill_size()); for (size_t i = 0; i < max_fill_size; ++i) fill_data_[i] = specs.fill_data_[i]; } }; // Format specifiers for built-in and string types. struct format_specs : basic_specs { int width; int precision; constexpr format_specs() : width(0), precision(-1) {} }; /** * Parsing context consisting of a format string range being parsed and an * argument counter for automatic indexing. */ template class parse_context { private: basic_string_view fmt_; int next_arg_id_; enum { use_constexpr_cast = !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 }; FMT_CONSTEXPR void do_check_arg_id(int arg_id); public: using char_type = Char; using iterator = const Char*; constexpr explicit parse_context(basic_string_view fmt, int next_arg_id = 0) : fmt_(fmt), next_arg_id_(next_arg_id) {} /// Returns an iterator to the beginning of the format string range being /// parsed. constexpr auto begin() const noexcept -> iterator { return fmt_.begin(); } /// Returns an iterator past the end of the format string range being parsed. constexpr auto end() const noexcept -> iterator { return fmt_.end(); } /// Advances the begin iterator to `it`. FMT_CONSTEXPR void advance_to(iterator it) { fmt_.remove_prefix(detail::to_unsigned(it - begin())); } /// Reports an error if using the manual argument indexing; otherwise returns /// the next argument index and switches to the automatic indexing. FMT_CONSTEXPR auto next_arg_id() -> int { if (next_arg_id_ < 0) { report_error("cannot switch from manual to automatic argument indexing"); return 0; } int id = next_arg_id_++; do_check_arg_id(id); return id; } /// Reports an error if using the automatic argument indexing; otherwise /// switches to the manual indexing. FMT_CONSTEXPR void check_arg_id(int id) { if (next_arg_id_ > 0) { report_error("cannot switch from automatic to manual argument indexing"); return; } next_arg_id_ = -1; do_check_arg_id(id); } FMT_CONSTEXPR void check_arg_id(basic_string_view) { next_arg_id_ = -1; } FMT_CONSTEXPR void check_dynamic_spec(int arg_id); }; #ifndef FMT_USE_LOCALE # define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1) #endif // A type-erased reference to std::locale to avoid the heavy include. class locale_ref { #if FMT_USE_LOCALE private: const void* locale_; // A type-erased pointer to std::locale. public: constexpr locale_ref() : locale_(nullptr) {} template locale_ref(const Locale& loc); inline explicit operator bool() const noexcept { return locale_ != nullptr; } #endif // FMT_USE_LOCALE public: template auto get() const -> Locale; }; FMT_END_EXPORT namespace detail { // Specifies if `T` is a code unit type. template struct is_code_unit : std::false_type {}; template <> struct is_code_unit : std::true_type {}; template <> struct is_code_unit : std::true_type {}; template <> struct is_code_unit : std::true_type {}; template <> struct is_code_unit : std::true_type {}; #ifdef __cpp_char8_t template <> struct is_code_unit : bool_constant {}; #endif // Constructs fmt::basic_string_view from types implicitly convertible // to it, deducing Char. Explicitly convertible types such as the ones returned // from FMT_STRING are intentionally excluded. template ::value)> constexpr auto to_string_view(const Char* s) -> basic_string_view { return s; } template ::value)> constexpr auto to_string_view(const T& s) -> basic_string_view { return s; } template constexpr auto to_string_view(basic_string_view s) -> basic_string_view { return s; } template struct has_to_string_view : std::false_type {}; // detail:: is intentional since to_string_view is not an extension point. template struct has_to_string_view< T, void_t()))>> : std::true_type {}; /// String's character (code unit) type. detail:: is intentional to prevent ADL. template ()))> using char_t = typename V::value_type; enum class type { none_type, // Integer types should go first, int_type, uint_type, long_long_type, ulong_long_type, int128_type, uint128_type, bool_type, char_type, last_integer_type = char_type, // followed by floating-point types. float_type, double_type, long_double_type, last_numeric_type = long_double_type, cstring_type, string_type, pointer_type, custom_type }; // Maps core type T to the corresponding type enum constant. template struct type_constant : std::integral_constant {}; #define FMT_TYPE_CONSTANT(Type, constant) \ template \ struct type_constant \ : std::integral_constant {} FMT_TYPE_CONSTANT(int, int_type); FMT_TYPE_CONSTANT(unsigned, uint_type); FMT_TYPE_CONSTANT(long long, long_long_type); FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); FMT_TYPE_CONSTANT(int128_opt, int128_type); FMT_TYPE_CONSTANT(uint128_opt, uint128_type); FMT_TYPE_CONSTANT(bool, bool_type); FMT_TYPE_CONSTANT(Char, char_type); FMT_TYPE_CONSTANT(float, float_type); FMT_TYPE_CONSTANT(double, double_type); FMT_TYPE_CONSTANT(long double, long_double_type); FMT_TYPE_CONSTANT(const Char*, cstring_type); FMT_TYPE_CONSTANT(basic_string_view, string_type); FMT_TYPE_CONSTANT(const void*, pointer_type); constexpr auto is_integral_type(type t) -> bool { return t > type::none_type && t <= type::last_integer_type; } constexpr auto is_arithmetic_type(type t) -> bool { return t > type::none_type && t <= type::last_numeric_type; } constexpr auto set(type rhs) -> int { return 1 << static_cast(rhs); } constexpr auto in(type t, int set) -> bool { return ((set >> static_cast(t)) & 1) != 0; } // Bitsets of types. enum { sint_set = set(type::int_type) | set(type::long_long_type) | set(type::int128_type), uint_set = set(type::uint_type) | set(type::ulong_long_type) | set(type::uint128_type), bool_set = set(type::bool_type), char_set = set(type::char_type), float_set = set(type::float_type) | set(type::double_type) | set(type::long_double_type), string_set = set(type::string_type), cstring_set = set(type::cstring_type), pointer_set = set(type::pointer_type) }; struct view {}; template struct is_view : std::false_type {}; template struct is_view> : std::is_base_of {}; template struct named_arg; template struct is_named_arg : std::false_type {}; template struct is_static_named_arg : std::false_type {}; template struct is_named_arg> : std::true_type {}; template struct named_arg : view { const Char* name; const T& value; named_arg(const Char* n, const T& v) : name(n), value(v) {} static_assert(!is_named_arg::value, "nested named arguments"); }; template constexpr auto count() -> int { return B ? 1 : 0; } template constexpr auto count() -> int { return (B1 ? 1 : 0) + count(); } template constexpr auto count_named_args() -> int { return count::value...>(); } template constexpr auto count_static_named_args() -> int { return count::value...>(); } template struct named_arg_info { const Char* name; int id; }; // named_args is non-const to suppress a bogus -Wmaybe-uninitialized in gcc 13. template FMT_CONSTEXPR void check_for_duplicate(named_arg_info* named_args, int named_arg_index, basic_string_view arg_name) { for (int i = 0; i < named_arg_index; ++i) { if (named_args[i].name == arg_name) report_error("duplicate named arg"); } } template ::value)> void init_named_arg(named_arg_info*, int& arg_index, int&, const T&) { ++arg_index; } template ::value)> void init_named_arg(named_arg_info* named_args, int& arg_index, int& named_arg_index, const T& arg) { check_for_duplicate(named_args, named_arg_index, arg.name); named_args[named_arg_index++] = {arg.name, arg_index++}; } template ::value)> FMT_CONSTEXPR void init_static_named_arg(named_arg_info*, int& arg_index, int&) { ++arg_index; } template ::value)> FMT_CONSTEXPR void init_static_named_arg(named_arg_info* named_args, int& arg_index, int& named_arg_index) { check_for_duplicate(named_args, named_arg_index, T::name); named_args[named_arg_index++] = {T::name, arg_index++}; } // To minimize the number of types we need to deal with, long is translated // either to int or to long long depending on its size. enum { long_short = sizeof(long) == sizeof(int) && FMT_BUILTIN_TYPES }; using long_type = conditional_t; using ulong_type = conditional_t; template using format_as_result = remove_cvref_t()))>; template using format_as_member_result = remove_cvref_t::format_as(std::declval()))>; template struct use_format_as : std::false_type {}; // format_as member is only used to avoid injection into the std namespace. template struct use_format_as_member : std::false_type {}; // Only map owning types because mapping views can be unsafe. template struct use_format_as< T, bool_constant>::value>> : std::true_type {}; template struct use_format_as_member< T, bool_constant>::value>> : std::true_type {}; template > using use_formatter = bool_constant<(std::is_class::value || std::is_enum::value || std::is_union::value || std::is_array::value) && !has_to_string_view::value && !is_named_arg::value && !use_format_as::value && !use_format_as_member::value>; template > auto has_formatter_impl(T* p, buffered_context* ctx = nullptr) -> decltype(formatter().format(*p, *ctx), std::true_type()); template auto has_formatter_impl(...) -> std::false_type; // T can be const-qualified to check if it is const-formattable. template constexpr auto has_formatter() -> bool { return decltype(has_formatter_impl(static_cast(nullptr)))::value; } // Maps formatting argument types to natively supported types or user-defined // types with formatters. Returns void on errors to be SFINAE-friendly. template struct type_mapper { static auto map(signed char) -> int; static auto map(unsigned char) -> unsigned; static auto map(short) -> int; static auto map(unsigned short) -> unsigned; static auto map(int) -> int; static auto map(unsigned) -> unsigned; static auto map(long) -> long_type; static auto map(unsigned long) -> ulong_type; static auto map(long long) -> long long; static auto map(unsigned long long) -> unsigned long long; static auto map(int128_opt) -> int128_opt; static auto map(uint128_opt) -> uint128_opt; static auto map(bool) -> bool; template static auto map(bitint) -> conditional_t; template static auto map(ubitint) -> conditional_t; template ::value)> static auto map(T) -> conditional_t< std::is_same::value || std::is_same::value, Char, void>; static auto map(float) -> float; static auto map(double) -> double; static auto map(long double) -> long double; static auto map(Char*) -> const Char*; static auto map(const Char*) -> const Char*; template , FMT_ENABLE_IF(!std::is_pointer::value)> static auto map(const T&) -> conditional_t::value, basic_string_view, void>; static auto map(void*) -> const void*; static auto map(const void*) -> const void*; static auto map(volatile void*) -> const void*; static auto map(const volatile void*) -> const void*; static auto map(nullptr_t) -> const void*; template ::value || std::is_member_pointer::value)> static auto map(const T&) -> void; template ::value)> static auto map(const T& x) -> decltype(map(format_as(x))); template ::value)> static auto map(const T& x) -> decltype(map(formatter::format_as(x))); template ::value)> static auto map(T&) -> conditional_t(), T&, void>; template ::value)> static auto map(const T& named_arg) -> decltype(map(named_arg.value)); }; // detail:: is used to workaround a bug in MSVC 2017. template using mapped_t = decltype(detail::type_mapper::map(std::declval())); // A type constant after applying type_mapper. template using mapped_type_constant = type_constant, Char>; template ::value> using stored_type_constant = std::integral_constant< type, Context::builtin_types || TYPE == type::int_type ? TYPE : type::custom_type>; // A parse context with extra data used only in compile-time checks. template class compile_parse_context : public parse_context { private: int num_args_; const type* types_; using base = parse_context; public: FMT_CONSTEXPR explicit compile_parse_context(basic_string_view fmt, int num_args, const type* types, int next_arg_id = 0) : base(fmt, next_arg_id), num_args_(num_args), types_(types) {} constexpr auto num_args() const -> int { return num_args_; } constexpr auto arg_type(int id) const -> type { return types_[id]; } FMT_CONSTEXPR auto next_arg_id() -> int { int id = base::next_arg_id(); if (id >= num_args_) report_error("argument not found"); return id; } FMT_CONSTEXPR void check_arg_id(int id) { base::check_arg_id(id); if (id >= num_args_) report_error("argument not found"); } using base::check_arg_id; FMT_CONSTEXPR void check_dynamic_spec(int arg_id) { ignore_unused(arg_id); if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id])) report_error("width/precision is not integer"); } }; // An argument reference. template union arg_ref { FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {} FMT_CONSTEXPR arg_ref(basic_string_view n) : name(n) {} int index; basic_string_view name; }; // Format specifiers with width and precision resolved at formatting rather // than parsing time to allow reusing the same parsed specifiers with // different sets of arguments (precompilation of format strings). template struct dynamic_format_specs : format_specs { arg_ref width_ref; arg_ref precision_ref; }; // Converts a character to ASCII. Returns '\0' on conversion failure. template ::value)> constexpr auto to_ascii(Char c) -> char { return c <= 0xff ? static_cast(c) : '\0'; } // Returns the number of code units in a code point or 1 on error. template FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int { if (const_check(sizeof(Char) != 1)) return 1; auto c = static_cast(*begin); return static_cast((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1; } // Parses the range [begin, end) as an unsigned integer. This function assumes // that the range is non-empty and the first character is a digit. template FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end, int error_value) noexcept -> int { FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', ""); unsigned value = 0, prev = 0; auto p = begin; do { prev = value; value = value * 10 + unsigned(*p - '0'); ++p; } while (p != end && '0' <= *p && *p <= '9'); auto num_digits = p - begin; begin = p; int digits10 = static_cast(sizeof(int) * CHAR_BIT * 3 / 10); if (num_digits <= digits10) return static_cast(value); // Check for overflow. unsigned max = INT_MAX; return num_digits == digits10 + 1 && prev * 10ull + unsigned(p[-1] - '0') <= max ? static_cast(value) : error_value; } FMT_CONSTEXPR inline auto parse_align(char c) -> align { switch (c) { case '<': return align::left; case '>': return align::right; case '^': return align::center; } return align::none; } template constexpr auto is_name_start(Char c) -> bool { return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_'; } template FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end, Handler&& handler) -> const Char* { Char c = *begin; if (c >= '0' && c <= '9') { int index = 0; if (c != '0') index = parse_nonnegative_int(begin, end, INT_MAX); else ++begin; if (begin == end || (*begin != '}' && *begin != ':')) report_error("invalid format string"); else handler.on_index(index); return begin; } if (FMT_OPTIMIZE_SIZE > 1 || !is_name_start(c)) { report_error("invalid format string"); return begin; } auto it = begin; do { ++it; } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9'))); handler.on_name({begin, to_unsigned(it - begin)}); return it; } template struct dynamic_spec_handler { parse_context& ctx; arg_ref& ref; arg_id_kind& kind; FMT_CONSTEXPR void on_index(int id) { ref = id; kind = arg_id_kind::index; ctx.check_arg_id(id); ctx.check_dynamic_spec(id); } FMT_CONSTEXPR void on_name(basic_string_view id) { ref = id; kind = arg_id_kind::name; ctx.check_arg_id(id); } }; template struct parse_dynamic_spec_result { const Char* end; arg_id_kind kind; }; // Parses integer | "{" [arg_id] "}". template FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end, int& value, arg_ref& ref, parse_context& ctx) -> parse_dynamic_spec_result { FMT_ASSERT(begin != end, ""); auto kind = arg_id_kind::none; if ('0' <= *begin && *begin <= '9') { int val = parse_nonnegative_int(begin, end, -1); if (val == -1) report_error("number is too big"); value = val; } else { if (*begin == '{') { ++begin; if (begin != end) { Char c = *begin; if (c == '}' || c == ':') { int id = ctx.next_arg_id(); ref = id; kind = arg_id_kind::index; ctx.check_dynamic_spec(id); } else { begin = parse_arg_id(begin, end, dynamic_spec_handler{ctx, ref, kind}); } } if (begin != end && *begin == '}') return {++begin, kind}; } report_error("invalid format string"); } return {begin, kind}; } template FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end, format_specs& specs, arg_ref& width_ref, parse_context& ctx) -> const Char* { auto result = parse_dynamic_spec(begin, end, specs.width, width_ref, ctx); specs.set_dynamic_width(result.kind); return result.end; } template FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end, format_specs& specs, arg_ref& precision_ref, parse_context& ctx) -> const Char* { ++begin; if (begin == end) { report_error("invalid precision"); return begin; } auto result = parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx); specs.set_dynamic_precision(result.kind); return result.end; } enum class state { start, align, sign, hash, zero, width, precision, locale }; // Parses standard format specifiers. template FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end, dynamic_format_specs& specs, parse_context& ctx, type arg_type) -> const Char* { auto c = '\0'; if (end - begin > 1) { auto next = to_ascii(begin[1]); c = parse_align(next) == align::none ? to_ascii(*begin) : '\0'; } else { if (begin == end) return begin; c = to_ascii(*begin); } struct { state current_state = state::start; FMT_CONSTEXPR void operator()(state s, bool valid = true) { if (current_state >= s || !valid) report_error("invalid format specifier"); current_state = s; } } enter_state; using pres = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; struct { const Char*& begin; format_specs& specs; type arg_type; FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* { if (!in(arg_type, set)) report_error("invalid format specifier"); specs.set_type(pres_type); return begin + 1; } } parse_presentation_type{begin, specs, arg_type}; for (;;) { switch (c) { case '<': case '>': case '^': enter_state(state::align); specs.set_align(parse_align(c)); ++begin; break; case '+': case ' ': specs.set_sign(c == ' ' ? sign::space : sign::plus); FMT_FALLTHROUGH; case '-': enter_state(state::sign, in(arg_type, sint_set | float_set)); ++begin; break; case '#': enter_state(state::hash, is_arithmetic_type(arg_type)); specs.set_alt(); ++begin; break; case '0': enter_state(state::zero); if (!is_arithmetic_type(arg_type)) report_error("format specifier requires numeric argument"); if (specs.align() == align::none) { // Ignore 0 if align is specified for compatibility with std::format. specs.set_align(align::numeric); specs.set_fill('0'); } ++begin; break; // clang-format off case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '{': // clang-format on enter_state(state::width); begin = parse_width(begin, end, specs, specs.width_ref, ctx); break; case '.': enter_state(state::precision, in(arg_type, float_set | string_set | cstring_set)); begin = parse_precision(begin, end, specs, specs.precision_ref, ctx); break; case 'L': enter_state(state::locale, is_arithmetic_type(arg_type)); specs.set_localized(); ++begin; break; case 'd': return parse_presentation_type(pres::dec, integral_set); case 'X': specs.set_upper(); FMT_FALLTHROUGH; case 'x': return parse_presentation_type(pres::hex, integral_set); case 'o': return parse_presentation_type(pres::oct, integral_set); case 'B': specs.set_upper(); FMT_FALLTHROUGH; case 'b': return parse_presentation_type(pres::bin, integral_set); case 'E': specs.set_upper(); FMT_FALLTHROUGH; case 'e': return parse_presentation_type(pres::exp, float_set); case 'F': specs.set_upper(); FMT_FALLTHROUGH; case 'f': return parse_presentation_type(pres::fixed, float_set); case 'G': specs.set_upper(); FMT_FALLTHROUGH; case 'g': return parse_presentation_type(pres::general, float_set); case 'A': specs.set_upper(); FMT_FALLTHROUGH; case 'a': return parse_presentation_type(pres::hexfloat, float_set); case 'c': if (arg_type == type::bool_type) report_error("invalid format specifier"); return parse_presentation_type(pres::chr, integral_set); case 's': return parse_presentation_type(pres::string, bool_set | string_set | cstring_set); case 'p': return parse_presentation_type(pres::pointer, pointer_set | cstring_set); case '?': return parse_presentation_type(pres::debug, char_set | string_set | cstring_set); case '}': return begin; default: { if (*begin == '}') return begin; // Parse fill and alignment. auto fill_end = begin + code_point_length(begin); if (end - fill_end <= 0) { report_error("invalid format specifier"); return begin; } if (*begin == '{') { report_error("invalid fill character '{'"); return begin; } auto alignment = parse_align(to_ascii(*fill_end)); enter_state(state::align, alignment != align::none); specs.set_fill( basic_string_view(begin, to_unsigned(fill_end - begin))); specs.set_align(alignment); begin = fill_end + 1; } } if (begin == end) return begin; c = to_ascii(*begin); } } template FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char* begin, const Char* end, Handler&& handler) -> const Char* { ++begin; if (begin == end) { handler.on_error("invalid format string"); return end; } int arg_id = 0; switch (*begin) { case '}': handler.on_replacement_field(handler.on_arg_id(), begin); return begin + 1; case '{': handler.on_text(begin, begin + 1); return begin + 1; case ':': arg_id = handler.on_arg_id(); break; default: { struct id_adapter { Handler& handler; int arg_id; FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); } FMT_CONSTEXPR void on_name(basic_string_view id) { arg_id = handler.on_arg_id(id); } } adapter = {handler, 0}; begin = parse_arg_id(begin, end, adapter); arg_id = adapter.arg_id; Char c = begin != end ? *begin : Char(); if (c == '}') { handler.on_replacement_field(arg_id, begin); return begin + 1; } if (c != ':') { handler.on_error("missing '}' in format string"); return end; } break; } } begin = handler.on_format_specs(arg_id, begin + 1, end); if (begin == end || *begin != '}') return handler.on_error("unknown format specifier"), end; return begin + 1; } template FMT_CONSTEXPR void parse_format_string(basic_string_view fmt, Handler&& handler) { auto begin = fmt.data(), end = begin + fmt.size(); auto p = begin; while (p != end) { auto c = *p++; if (c == '{') { handler.on_text(begin, p - 1); begin = p = parse_replacement_field(p - 1, end, handler); } else if (c == '}') { if (p == end || *p != '}') return handler.on_error("unmatched '}' in format string"); handler.on_text(begin, p); begin = ++p; } } handler.on_text(begin, end); } // Checks char specs and returns true iff the presentation type is char-like. FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool { auto type = specs.type(); if (type != presentation_type::none && type != presentation_type::chr && type != presentation_type::debug) { return false; } if (specs.align() == align::numeric || specs.sign() != sign::none || specs.alt()) { report_error("invalid format specifier for char"); } return true; } // A base class for compile-time strings. struct compile_string {}; template FMT_VISIBILITY("hidden") // Suppress an ld warning on macOS (#3769). FMT_CONSTEXPR auto invoke_parse(parse_context& ctx) -> const Char* { using mapped_type = remove_cvref_t>; constexpr bool formattable = std::is_constructible>::value; if (!formattable) return ctx.begin(); // Error is reported in the value ctor. using formatted_type = conditional_t; return formatter().parse(ctx); } template struct arg_pack {}; template class format_string_checker { private: type types_[max_of(1, NUM_ARGS)]; named_arg_info named_args_[max_of(1, NUM_NAMED_ARGS)]; compile_parse_context context_; using parse_func = auto (*)(parse_context&) -> const Char*; parse_func parse_funcs_[max_of(1, NUM_ARGS)]; public: template FMT_CONSTEXPR explicit format_string_checker(basic_string_view fmt, arg_pack) : types_{mapped_type_constant::value...}, named_args_{}, context_(fmt, NUM_ARGS, types_), parse_funcs_{&invoke_parse...} { int arg_index = 0, named_arg_index = 0; FMT_APPLY_VARIADIC( init_static_named_arg(named_args_, arg_index, named_arg_index)); ignore_unused(arg_index, named_arg_index); } FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { context_.check_arg_id(id); return id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { for (int i = 0; i < NUM_NAMED_ARGS; ++i) { if (named_args_[i].name == id) return named_args_[i].id; } if (!DYNAMIC_NAMES) on_error("argument not found"); return -1; } FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) { on_format_specs(id, begin, begin); // Call parse() on empty specs. } FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* { context_.advance_to(begin); if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_); // If id is out of range, it means we do not know the type and cannot parse // the format at compile time. Instead, skip over content until we finish // the format spec, accounting for any nested replacements. for (int bracket_count = 0; begin != end && (bracket_count > 0 || *begin != '}'); ++begin) { if (*begin == '{') ++bracket_count; else if (*begin == '}') --bracket_count; } return begin; } FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) { report_error(message); } }; /// A contiguous memory buffer with an optional growing ability. It is an /// internal class and shouldn't be used directly, only via `memory_buffer`. template class buffer { private: T* ptr_; size_t size_; size_t capacity_; using grow_fun = void (*)(buffer& buf, size_t capacity); grow_fun grow_; protected: // Don't initialize ptr_ since it is not accessed to save a few cycles. FMT_MSC_WARNING(suppress : 26495) FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept : size_(sz), capacity_(sz), grow_(grow) {} constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {} FMT_CONSTEXPR20 ~buffer() = default; buffer(buffer&&) = default; /// Sets the buffer data and capacity. FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept { ptr_ = buf_data; capacity_ = buf_capacity; } public: using value_type = T; using const_reference = const T&; buffer(const buffer&) = delete; void operator=(const buffer&) = delete; auto begin() noexcept -> T* { return ptr_; } auto end() noexcept -> T* { return ptr_ + size_; } auto begin() const noexcept -> const T* { return ptr_; } auto end() const noexcept -> const T* { return ptr_ + size_; } /// Returns the size of this buffer. constexpr auto size() const noexcept -> size_t { return size_; } /// Returns the capacity of this buffer. constexpr auto capacity() const noexcept -> size_t { return capacity_; } /// Returns a pointer to the buffer data (not null-terminated). FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; } FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; } /// Clears this buffer. FMT_CONSTEXPR void clear() { size_ = 0; } // Tries resizing the buffer to contain `count` elements. If T is a POD type // the new elements may not be initialized. FMT_CONSTEXPR void try_resize(size_t count) { try_reserve(count); size_ = min_of(count, capacity_); } // Tries increasing the buffer capacity to `new_capacity`. It can increase the // capacity by a smaller amount than requested but guarantees there is space // for at least one additional element either by increasing the capacity or by // flushing the buffer if it is full. FMT_CONSTEXPR void try_reserve(size_t new_capacity) { if (new_capacity > capacity_) grow_(*this, new_capacity); } FMT_CONSTEXPR void push_back(const T& value) { try_reserve(size_ + 1); ptr_[size_++] = value; } /// Appends data to the end of the buffer. template // Workaround for MSVC2019 to fix error C2893: Failed to specialize function // template 'void fmt::v11::detail::buffer::append(const U *,const U *)'. #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940 FMT_CONSTEXPR20 #endif void append(const U* begin, const U* end) { while (begin != end) { auto count = to_unsigned(end - begin); try_reserve(size_ + count); auto free_cap = capacity_ - size_; if (free_cap < count) count = free_cap; // A loop is faster than memcpy on small sizes. T* out = ptr_ + size_; for (size_t i = 0; i < count; ++i) out[i] = begin[i]; size_ += count; begin += count; } } template FMT_CONSTEXPR auto operator[](Idx index) -> T& { return ptr_[index]; } template FMT_CONSTEXPR auto operator[](Idx index) const -> const T& { return ptr_[index]; } }; struct buffer_traits { constexpr explicit buffer_traits(size_t) {} constexpr auto count() const -> size_t { return 0; } constexpr auto limit(size_t size) const -> size_t { return size; } }; class fixed_buffer_traits { private: size_t count_ = 0; size_t limit_; public: constexpr explicit fixed_buffer_traits(size_t limit) : limit_(limit) {} constexpr auto count() const -> size_t { return count_; } FMT_CONSTEXPR auto limit(size_t size) -> size_t { size_t n = limit_ > count_ ? limit_ - count_ : 0; count_ += size; return min_of(size, n); } }; // A buffer that writes to an output iterator when flushed. template class iterator_buffer : public Traits, public buffer { private: OutputIt out_; enum { buffer_size = 256 }; T data_[buffer_size]; static FMT_CONSTEXPR void grow(buffer& buf, size_t) { if (buf.size() == buffer_size) static_cast(buf).flush(); } void flush() { auto size = this->size(); this->clear(); const T* begin = data_; const T* end = begin + this->limit(size); while (begin != end) *out_++ = *begin++; } public: explicit iterator_buffer(OutputIt out, size_t n = buffer_size) : Traits(n), buffer(grow, data_, 0, buffer_size), out_(out) {} iterator_buffer(iterator_buffer&& other) noexcept : Traits(other), buffer(grow, data_, 0, buffer_size), out_(other.out_) {} ~iterator_buffer() { // Don't crash if flush fails during unwinding. FMT_TRY { flush(); } FMT_CATCH(...) {} } auto out() -> OutputIt { flush(); return out_; } auto count() const -> size_t { return Traits::count() + this->size(); } }; template class iterator_buffer : public fixed_buffer_traits, public buffer { private: T* out_; enum { buffer_size = 256 }; T data_[buffer_size]; static FMT_CONSTEXPR void grow(buffer& buf, size_t) { if (buf.size() == buf.capacity()) static_cast(buf).flush(); } void flush() { size_t n = this->limit(this->size()); if (this->data() == out_) { out_ += n; this->set(data_, buffer_size); } this->clear(); } public: explicit iterator_buffer(T* out, size_t n = buffer_size) : fixed_buffer_traits(n), buffer(grow, out, 0, n), out_(out) {} iterator_buffer(iterator_buffer&& other) noexcept : fixed_buffer_traits(other), buffer(static_cast(other)), out_(other.out_) { if (this->data() != out_) { this->set(data_, buffer_size); this->clear(); } } ~iterator_buffer() { flush(); } auto out() -> T* { flush(); return out_; } auto count() const -> size_t { return fixed_buffer_traits::count() + this->size(); } }; template class iterator_buffer : public buffer { public: explicit iterator_buffer(T* out, size_t = 0) : buffer([](buffer&, size_t) {}, out, 0, ~size_t()) {} auto out() -> T* { return &*this->end(); } }; template class container_buffer : public buffer { private: using value_type = typename Container::value_type; static FMT_CONSTEXPR void grow(buffer& buf, size_t capacity) { auto& self = static_cast(buf); self.container.resize(capacity); self.set(&self.container[0], capacity); } public: Container& container; explicit container_buffer(Container& c) : buffer(grow, c.size()), container(c) {} }; // A buffer that writes to a container with the contiguous storage. template class iterator_buffer< OutputIt, enable_if_t::value && is_contiguous::value, typename OutputIt::container_type::value_type>> : public container_buffer { private: using base = container_buffer; public: explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {} explicit iterator_buffer(OutputIt out, size_t = 0) : base(get_container(out)) {} auto out() -> OutputIt { return OutputIt(this->container); } }; // A buffer that counts the number of code units written discarding the output. template class counting_buffer : public buffer { private: enum { buffer_size = 256 }; T data_[buffer_size]; size_t count_ = 0; static FMT_CONSTEXPR void grow(buffer& buf, size_t) { if (buf.size() != buffer_size) return; static_cast(buf).count_ += buf.size(); buf.clear(); } public: FMT_CONSTEXPR counting_buffer() : buffer(grow, data_, 0, buffer_size) {} constexpr auto count() const noexcept -> size_t { return count_ + this->size(); } }; template struct is_back_insert_iterator> : std::true_type {}; template struct has_back_insert_iterator_container_append : std::false_type {}; template struct has_back_insert_iterator_container_append< OutputIt, InputIt, void_t()) .append(std::declval(), std::declval()))>> : std::true_type {}; template struct has_back_insert_iterator_container_insert_at_end : std::false_type {}; template struct has_back_insert_iterator_container_insert_at_end< OutputIt, InputIt, void_t()) .insert(get_container(std::declval()).end(), std::declval(), std::declval()))>> : std::true_type {}; // An optimized version of std::copy with the output value type (T). template ::value&& has_back_insert_iterator_container_append< OutputIt, InputIt>::value)> FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { get_container(out).append(begin, end); return out; } template ::value && !has_back_insert_iterator_container_append< OutputIt, InputIt>::value && has_back_insert_iterator_container_insert_at_end< OutputIt, InputIt>::value)> FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { auto& c = get_container(out); c.insert(c.end(), begin, end); return out; } template ::value && (has_back_insert_iterator_container_append< OutputIt, InputIt>::value || has_back_insert_iterator_container_insert_at_end< OutputIt, InputIt>::value)))> FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt { while (begin != end) *out++ = static_cast(*begin++); return out; } template FMT_CONSTEXPR auto copy(basic_string_view s, OutputIt out) -> OutputIt { return copy(s.begin(), s.end(), out); } template struct is_buffer_appender : std::false_type {}; template struct is_buffer_appender< It, bool_constant< is_back_insert_iterator::value && std::is_base_of, typename It::container_type>::value>> : std::true_type {}; // Maps an output iterator to a buffer. template ::value)> auto get_buffer(OutputIt out) -> iterator_buffer { return iterator_buffer(out); } template ::value)> auto get_buffer(OutputIt out) -> buffer& { return get_container(out); } template auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) { return buf.out(); } template auto get_iterator(buffer&, OutputIt out) -> OutputIt { return out; } // This type is intentionally undefined, only used for errors. template struct type_is_unformattable_for; template struct string_value { const Char* data; size_t size; auto str() const -> basic_string_view { return {data, size}; } }; template struct custom_value { using char_type = typename Context::char_type; void* value; void (*format)(void* arg, parse_context& parse_ctx, Context& ctx); }; template struct named_arg_value { const named_arg_info* data; size_t size; }; struct custom_tag {}; #if !FMT_BUILTIN_TYPES # define FMT_BUILTIN , monostate #else # define FMT_BUILTIN #endif // A formatting argument value. template class value { public: using char_type = typename Context::char_type; union { monostate no_value; int int_value; unsigned uint_value; long long long_long_value; unsigned long long ulong_long_value; int128_opt int128_value; uint128_opt uint128_value; bool bool_value; char_type char_value; float float_value; double double_value; long double long_double_value; const void* pointer; string_value string; custom_value custom; named_arg_value named_args; }; constexpr FMT_INLINE value() : no_value() {} constexpr FMT_INLINE value(signed char x) : int_value(x) {} constexpr FMT_INLINE value(unsigned char x FMT_BUILTIN) : uint_value(x) {} constexpr FMT_INLINE value(signed short x) : int_value(x) {} constexpr FMT_INLINE value(unsigned short x FMT_BUILTIN) : uint_value(x) {} constexpr FMT_INLINE value(int x) : int_value(x) {} constexpr FMT_INLINE value(unsigned x FMT_BUILTIN) : uint_value(x) {} FMT_CONSTEXPR FMT_INLINE value(long x FMT_BUILTIN) : value(long_type(x)) {} FMT_CONSTEXPR FMT_INLINE value(unsigned long x FMT_BUILTIN) : value(ulong_type(x)) {} constexpr FMT_INLINE value(long long x FMT_BUILTIN) : long_long_value(x) {} constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN) : ulong_long_value(x) {} FMT_INLINE value(int128_opt x FMT_BUILTIN) : int128_value(x) {} FMT_INLINE value(uint128_opt x FMT_BUILTIN) : uint128_value(x) {} constexpr FMT_INLINE value(bool x FMT_BUILTIN) : bool_value(x) {} template constexpr FMT_INLINE value(bitint x FMT_BUILTIN) : long_long_value(x) { static_assert(N <= 64, "unsupported _BitInt"); } template constexpr FMT_INLINE value(ubitint x FMT_BUILTIN) : ulong_long_value(x) { static_assert(N <= 64, "unsupported _BitInt"); } template ::value)> constexpr FMT_INLINE value(T x FMT_BUILTIN) : char_value(x) { static_assert( std::is_same::value || std::is_same::value, "mixing character types is disallowed"); } constexpr FMT_INLINE value(float x FMT_BUILTIN) : float_value(x) {} constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {} FMT_INLINE value(long double x FMT_BUILTIN) : long_double_value(x) {} FMT_CONSTEXPR FMT_INLINE value(char_type* x FMT_BUILTIN) { string.data = x; if (is_constant_evaluated()) string.size = 0; } FMT_CONSTEXPR FMT_INLINE value(const char_type* x FMT_BUILTIN) { string.data = x; if (is_constant_evaluated()) string.size = 0; } template , FMT_ENABLE_IF(!std::is_pointer::value)> FMT_CONSTEXPR value(const T& x FMT_BUILTIN) { static_assert(std::is_same::value, "mixing character types is disallowed"); auto sv = to_string_view(x); string.data = sv.data(); string.size = sv.size(); } FMT_INLINE value(void* x FMT_BUILTIN) : pointer(x) {} FMT_INLINE value(const void* x FMT_BUILTIN) : pointer(x) {} FMT_INLINE value(volatile void* x FMT_BUILTIN) : pointer(const_cast(x)) {} FMT_INLINE value(const volatile void* x FMT_BUILTIN) : pointer(const_cast(x)) {} FMT_INLINE value(nullptr_t) : pointer(nullptr) {} template ::value || std::is_member_pointer::value)> value(const T&) { // Formatting of arbitrary pointers is disallowed. If you want to format a // pointer cast it to `void*` or `const void*`. In particular, this forbids // formatting of `[const] volatile char*` printed as bool by iostreams. static_assert(sizeof(T) == 0, "formatting of non-void pointers is disallowed"); } template ::value)> value(const T& x) : value(format_as(x)) {} template ::value)> value(const T& x) : value(formatter::format_as(x)) {} template ::value)> value(const T& named_arg) : value(named_arg.value) {} template ::value || !FMT_BUILTIN_TYPES)> FMT_CONSTEXPR20 FMT_INLINE value(T& x) : value(x, custom_tag()) {} FMT_ALWAYS_INLINE value(const named_arg_info* args, size_t size) : named_args{args, size} {} private: template ())> FMT_CONSTEXPR value(T& x, custom_tag) { using value_type = remove_const_t; // T may overload operator& e.g. std::vector::reference in libc++. if (!is_constant_evaluated()) { custom.value = const_cast(&reinterpret_cast(x)); } else { custom.value = nullptr; #if defined(__cpp_if_constexpr) if constexpr (std::is_same*>::value) custom.value = const_cast(&x); #endif } custom.format = format_custom; } template ())> FMT_CONSTEXPR value(const T&, custom_tag) { // Cannot format an argument; to make type T formattable provide a // formatter specialization: https://fmt.dev/latest/api.html#udt. type_is_unformattable_for _; } // Formats an argument of a custom type, such as a user-defined class. template static void format_custom(void* arg, parse_context& parse_ctx, Context& ctx) { auto f = formatter(); parse_ctx.advance_to(f.parse(parse_ctx)); using qualified_type = conditional_t(), const T, T>; // format must be const for compatibility with std::format and compilation. const auto& cf = f; ctx.advance_to(cf.format(*static_cast(arg), ctx)); } }; enum { packed_arg_bits = 4 }; // Maximum number of arguments with packed types. enum { max_packed_args = 62 / packed_arg_bits }; enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; enum : unsigned long long { has_named_args_bit = 1ULL << 62 }; template struct is_output_iterator : std::false_type {}; template <> struct is_output_iterator : std::true_type {}; template struct is_output_iterator< It, T, enable_if_t&>()++), T>::value>> : std::true_type {}; template constexpr auto encode_types() -> unsigned long long { return 0; } template constexpr auto encode_types() -> unsigned long long { return static_cast(stored_type_constant::value) | (encode_types() << packed_arg_bits); } template constexpr auto make_descriptor() -> unsigned long long { return NUM_ARGS <= max_packed_args ? encode_types() : is_unpacked_bit | NUM_ARGS; } template using arg_t = conditional_t, basic_format_arg>; template struct named_arg_store { // args_[0].named_args points to named_args to avoid bloating format_args. arg_t args[1u + NUM_ARGS]; named_arg_info named_args[static_cast(NUM_NAMED_ARGS)]; template FMT_CONSTEXPR FMT_ALWAYS_INLINE named_arg_store(T&... values) : args{{named_args, NUM_NAMED_ARGS}, values...} { int arg_index = 0, named_arg_index = 0; FMT_APPLY_VARIADIC( init_named_arg(named_args, arg_index, named_arg_index, values)); } named_arg_store(named_arg_store&& rhs) { args[0] = {named_args, NUM_NAMED_ARGS}; for (size_t i = 1; i < sizeof(args) / sizeof(*args); ++i) args[i] = rhs.args[i]; for (size_t i = 0; i < NUM_NAMED_ARGS; ++i) named_args[i] = rhs.named_args[i]; } named_arg_store(const named_arg_store& rhs) = delete; auto operator=(const named_arg_store& rhs) -> named_arg_store& = delete; auto operator=(named_arg_store&& rhs) -> named_arg_store& = delete; operator const arg_t*() const { return args + 1; } }; // An array of references to arguments. It can be implicitly converted to // `basic_format_args` for passing into type-erased formatting functions // such as `vformat`. It is a plain struct to reduce binary size in debug mode. template struct format_arg_store { // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning. using type = conditional_t[max_of(1, NUM_ARGS)], named_arg_store>; type args; }; // TYPE can be different from type_constant, e.g. for __float128. template struct native_formatter { private: dynamic_format_specs specs_; public: using nonlocking = void; FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE); if (const_check(TYPE == type::char_type)) check_char_specs(specs_); return end; } template FMT_CONSTEXPR void set_debug_format(bool set = true) { specs_.set_type(set ? presentation_type::debug : presentation_type::none); } FMT_PRAGMA_CLANG(diagnostic ignored "-Wundefined-inline") template FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const -> decltype(ctx.out()); }; template struct locking : bool_constant::value == type::custom_type> {}; template struct locking>::nonlocking>> : std::false_type {}; template FMT_CONSTEXPR inline auto is_locking() -> bool { return locking::value; } template FMT_CONSTEXPR inline auto is_locking() -> bool { return locking::value || is_locking(); } FMT_API void vformat_to(buffer& buf, string_view fmt, format_args args, locale_ref loc = {}); #if FMT_WIN32 FMT_API void vprint_mojibake(FILE*, string_view, format_args, bool); #else // format_args is passed by reference since it is defined later. inline void vprint_mojibake(FILE*, string_view, const format_args&, bool) {} #endif } // namespace detail // The main public API. template FMT_CONSTEXPR void parse_context::do_check_arg_id(int arg_id) { // Argument id is only checked at compile time during parsing because // formatting has its own validation. if (detail::is_constant_evaluated() && use_constexpr_cast) { auto ctx = static_cast*>(this); if (arg_id >= ctx->num_args()) report_error("argument not found"); } } template FMT_CONSTEXPR void parse_context::check_dynamic_spec(int arg_id) { using detail::compile_parse_context; if (detail::is_constant_evaluated() && use_constexpr_cast) static_cast*>(this)->check_dynamic_spec(arg_id); } FMT_BEGIN_EXPORT // An output iterator that appends to a buffer. It is used instead of // back_insert_iterator to reduce symbol sizes and avoid dependency. template class basic_appender { protected: detail::buffer* container; public: using container_type = detail::buffer; FMT_CONSTEXPR basic_appender(detail::buffer& buf) : container(&buf) {} FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender& { container->push_back(c); return *this; } FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; } FMT_CONSTEXPR20 auto operator++() -> basic_appender& { return *this; } FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; } }; // A formatting argument. Context is a template parameter for the compiled API // where output can be unbuffered. template class basic_format_arg { private: detail::value value_; detail::type type_; friend class basic_format_args; using char_type = typename Context::char_type; public: class handle { private: detail::custom_value custom_; public: explicit handle(detail::custom_value custom) : custom_(custom) {} void format(parse_context& parse_ctx, Context& ctx) const { custom_.format(custom_.value, parse_ctx, ctx); } }; constexpr basic_format_arg() : type_(detail::type::none_type) {} basic_format_arg(const detail::named_arg_info* args, size_t size) : value_(args, size) {} template basic_format_arg(T&& val) : value_(val), type_(detail::stored_type_constant::value) {} constexpr explicit operator bool() const noexcept { return type_ != detail::type::none_type; } auto type() const -> detail::type { return type_; } /** * Visits an argument dispatching to the appropriate visit method based on * the argument type. For example, if the argument type is `double` then * `vis(value)` will be called with the value of type `double`. */ template FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) { using detail::map; switch (type_) { case detail::type::none_type: break; case detail::type::int_type: return vis(value_.int_value); case detail::type::uint_type: return vis(value_.uint_value); case detail::type::long_long_type: return vis(value_.long_long_value); case detail::type::ulong_long_type: return vis(value_.ulong_long_value); case detail::type::int128_type: return vis(map(value_.int128_value)); case detail::type::uint128_type: return vis(map(value_.uint128_value)); case detail::type::bool_type: return vis(value_.bool_value); case detail::type::char_type: return vis(value_.char_value); case detail::type::float_type: return vis(value_.float_value); case detail::type::double_type: return vis(value_.double_value); case detail::type::long_double_type: return vis(value_.long_double_value); case detail::type::cstring_type: return vis(value_.string.data); case detail::type::string_type: return vis(value_.string.str()); case detail::type::pointer_type: return vis(value_.pointer); case detail::type::custom_type: return vis(handle(value_.custom)); } return vis(monostate()); } auto format_custom(const char_type* parse_begin, parse_context& parse_ctx, Context& ctx) -> bool { if (type_ != detail::type::custom_type) return false; parse_ctx.advance_to(parse_begin); value_.custom.format(value_.custom.value, parse_ctx, ctx); return true; } }; /** * A view of a collection of formatting arguments. To avoid lifetime issues it * should only be used as a parameter type in type-erased functions such as * `vformat`: * * void vlog(fmt::string_view fmt, fmt::format_args args); // OK * fmt::format_args args = fmt::make_format_args(); // Dangling reference */ template class basic_format_args { private: // A descriptor that contains information about formatting arguments. // If the number of arguments is less or equal to max_packed_args then // argument types are passed in the descriptor. This reduces binary code size // per formatting function call. unsigned long long desc_; union { // If is_packed() returns true then argument values are stored in values_; // otherwise they are stored in args_. This is done to improve cache // locality and reduce compiled code size since storing larger objects // may require more code (at least on x86-64) even if the same amount of // data is actually copied to stack. It saves ~10% on the bloat test. const detail::value* values_; const basic_format_arg* args_; }; constexpr auto is_packed() const -> bool { return (desc_ & detail::is_unpacked_bit) == 0; } constexpr auto has_named_args() const -> bool { return (desc_ & detail::has_named_args_bit) != 0; } FMT_CONSTEXPR auto type(int index) const -> detail::type { int shift = index * detail::packed_arg_bits; unsigned mask = (1 << detail::packed_arg_bits) - 1; return static_cast((desc_ >> shift) & mask); } template using store = detail::format_arg_store; public: using format_arg = basic_format_arg; constexpr basic_format_args() : desc_(0), args_(nullptr) {} /// Constructs a `basic_format_args` object from `format_arg_store`. template constexpr FMT_ALWAYS_INLINE basic_format_args( const store& s) : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)), values_(s.args) {} template detail::max_packed_args)> constexpr basic_format_args(const store& s) : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)), args_(s.args) {} /// Constructs a `basic_format_args` object from a dynamic list of arguments. constexpr basic_format_args(const format_arg* args, int count, bool has_named = false) : desc_(detail::is_unpacked_bit | detail::to_unsigned(count) | (has_named ? +detail::has_named_args_bit : 0)), args_(args) {} /// Returns the argument with the specified id. FMT_CONSTEXPR auto get(int id) const -> format_arg { auto arg = format_arg(); if (!is_packed()) { if (id < max_size()) arg = args_[id]; return arg; } if (static_cast(id) >= detail::max_packed_args) return arg; arg.type_ = type(id); if (arg.type_ != detail::type::none_type) arg.value_ = values_[id]; return arg; } template auto get(basic_string_view name) const -> format_arg { int id = get_id(name); return id >= 0 ? get(id) : format_arg(); } template FMT_CONSTEXPR auto get_id(basic_string_view name) const -> int { if (!has_named_args()) return -1; const auto& named_args = (is_packed() ? values_[-1] : args_[-1].value_).named_args; for (size_t i = 0; i < named_args.size; ++i) { if (named_args.data[i].name == name) return named_args.data[i].id; } return -1; } auto max_size() const -> int { unsigned long long max_packed = detail::max_packed_args; return static_cast(is_packed() ? max_packed : desc_ & ~detail::is_unpacked_bit); } }; // A formatting context. class context { private: appender out_; format_args args_; FMT_NO_UNIQUE_ADDRESS locale_ref loc_; public: using char_type = char; ///< The character type for the output. using iterator = appender; using format_arg = basic_format_arg; enum { builtin_types = FMT_BUILTIN_TYPES }; /// Constructs a `context` object. References to the arguments are stored /// in the object so make sure they have appropriate lifetimes. FMT_CONSTEXPR context(iterator out, format_args args, locale_ref loc = {}) : out_(out), args_(args), loc_(loc) {} context(context&&) = default; context(const context&) = delete; void operator=(const context&) = delete; FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); } inline auto arg(string_view name) const -> format_arg { return args_.get(name); } FMT_CONSTEXPR auto arg_id(string_view name) const -> int { return args_.get_id(name); } auto args() const -> const format_args& { return args_; } // Returns an iterator to the beginning of the output range. FMT_CONSTEXPR auto out() const -> iterator { return out_; } // Advances the begin iterator to `it`. FMT_CONSTEXPR void advance_to(iterator) {} FMT_CONSTEXPR auto locale() const -> locale_ref { return loc_; } }; template struct runtime_format_string { basic_string_view str; }; /** * Creates a runtime format string. * * **Example**: * * // Check format string at runtime instead of compile-time. * fmt::print(fmt::runtime("{:d}"), "I am not a number"); */ inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; } /// A compile-time format string. Use `format_string` in the public API to /// prevent type deduction. template struct fstring { private: static constexpr int num_static_named_args = detail::count_static_named_args(); using checker = detail::format_string_checker< char, static_cast(sizeof...(T)), num_static_named_args, num_static_named_args != detail::count_named_args()>; using arg_pack = detail::arg_pack; public: string_view str; using t = fstring; // Reports a compile-time error if S is not a valid format string for T. template FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) { using namespace detail; static_assert(count<(is_view>::value && std::is_reference::value)...>() == 0, "passing views as lvalues is disallowed"); if (FMT_USE_CONSTEVAL) parse_format_string(s, checker(s, arg_pack())); #ifdef FMT_ENFORCE_COMPILE_STRING static_assert( FMT_USE_CONSTEVAL && sizeof(s) != 0, "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING"); #endif } template ::value)> FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S& s) : str(s) { auto sv = string_view(str); if (FMT_USE_CONSTEVAL) detail::parse_format_string(sv, checker(sv, arg_pack())); #ifdef FMT_ENFORCE_COMPILE_STRING static_assert( FMT_USE_CONSTEVAL && sizeof(s) != 0, "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING"); #endif } template ::value&& std::is_same::value)> FMT_ALWAYS_INLINE fstring(const S&) : str(S()) { FMT_CONSTEXPR auto sv = string_view(S()); FMT_CONSTEXPR int unused = (parse_format_string(sv, checker(sv, arg_pack())), 0); detail::ignore_unused(unused); } fstring(runtime_format_string<> fmt) : str(fmt.str) {} // Returning by reference generates better code in debug mode. FMT_ALWAYS_INLINE operator const string_view&() const { return str; } auto get() const -> string_view { return str; } }; template using format_string = typename fstring::t; template using is_formattable = bool_constant::value, int*, T>, Char>, void>::value>; #ifdef __cpp_concepts template concept formattable = is_formattable, Char>::value; #endif // A formatter specialization for natively supported types. template struct formatter::value != detail::type::custom_type>> : detail::native_formatter::value> { }; /** * Constructs an object that stores references to arguments and can be * implicitly converted to `format_args`. `Context` can be omitted in which case * it defaults to `context`. See `arg` for lifetime considerations. */ // Take arguments by lvalue references to avoid some lifetime issues, e.g. // auto args = make_format_args(std::string()); template (), unsigned long long DESC = detail::make_descriptor()> constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args) -> detail::format_arg_store { // Suppress warnings for pathological types convertible to detail::value. FMT_PRAGMA_GCC(diagnostic ignored "-Wconversion") return {{args...}}; } template using vargs = detail::format_arg_store(), detail::make_descriptor()>; /** * Returns a named argument to be used in a formatting function. * It should only be used in a call to a formatting function. * * **Example**: * * fmt::print("The answer is {answer}.", fmt::arg("answer", 42)); */ template inline auto arg(const Char* name, const T& arg) -> detail::named_arg { return {name, arg}; } /// Formats a string and writes the output to `out`. template , char>::value)> auto vformat_to(OutputIt&& out, string_view fmt, format_args args) -> remove_cvref_t { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, fmt, args, {}); return detail::get_iterator(buf, out); } /** * Formats `args` according to specifications in `fmt`, writes the result to * the output iterator `out` and returns the iterator past the end of the output * range. `format_to` does not append a terminating null character. * * **Example**: * * auto out = std::vector(); * fmt::format_to(std::back_inserter(out), "{}", 42); */ template , char>::value)> FMT_INLINE auto format_to(OutputIt&& out, format_string fmt, T&&... args) -> remove_cvref_t { return vformat_to(out, fmt.str, vargs{{args...}}); } template struct format_to_n_result { /// Iterator past the end of the output range. OutputIt out; /// Total (not truncated) output size. size_t size; }; template ::value)> auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); detail::vformat_to(buf, fmt, args, {}); return {buf.out(), buf.count()}; } /** * Formats `args` according to specifications in `fmt`, writes up to `n` * characters of the result to the output iterator `out` and returns the total * (not truncated) output size and the iterator past the end of the output * range. `format_to_n` does not append a terminating null character. */ template ::value)> FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string fmt, T&&... args) -> format_to_n_result { return vformat_to_n(out, n, fmt.str, vargs{{args...}}); } struct format_to_result { /// Pointer to just after the last successful write in the array. char* out; /// Specifies if the output was truncated. bool truncated; FMT_CONSTEXPR operator char*() const { // Report truncation to prevent silent data loss. if (truncated) report_error("output is truncated"); return out; } }; template auto vformat_to(char (&out)[N], string_view fmt, format_args args) -> format_to_result { auto result = vformat_to_n(out, N, fmt, args); return {result.out, result.size > N}; } template FMT_INLINE auto format_to(char (&out)[N], format_string fmt, T&&... args) -> format_to_result { auto result = vformat_to_n(out, N, fmt.str, vargs{{args...}}); return {result.out, result.size > N}; } /// Returns the number of chars in the output of `format(fmt, args...)`. template FMT_NODISCARD FMT_INLINE auto formatted_size(format_string fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); detail::vformat_to(buf, fmt.str, vargs{{args...}}, {}); return buf.count(); } FMT_API void vprint(string_view fmt, format_args args); FMT_API void vprint(FILE* f, string_view fmt, format_args args); FMT_API void vprintln(FILE* f, string_view fmt, format_args args); FMT_API void vprint_buffered(FILE* f, string_view fmt, format_args args); /** * Formats `args` according to specifications in `fmt` and writes the output * to `stdout`. * * **Example**: * * fmt::print("The answer is {}.", 42); */ template FMT_INLINE void print(format_string fmt, T&&... args) { vargs va = {{args...}}; if (detail::const_check(!detail::use_utf8)) return detail::vprint_mojibake(stdout, fmt.str, va, false); return detail::is_locking() ? vprint_buffered(stdout, fmt.str, va) : vprint(fmt.str, va); } /** * Formats `args` according to specifications in `fmt` and writes the * output to the file `f`. * * **Example**: * * fmt::print(stderr, "Don't {}!", "panic"); */ template FMT_INLINE void print(FILE* f, format_string fmt, T&&... args) { vargs va = {{args...}}; if (detail::const_check(!detail::use_utf8)) return detail::vprint_mojibake(f, fmt.str, va, false); return detail::is_locking() ? vprint_buffered(f, fmt.str, va) : vprint(f, fmt.str, va); } /// Formats `args` according to specifications in `fmt` and writes the output /// to the file `f` followed by a newline. template FMT_INLINE void println(FILE* f, format_string fmt, T&&... args) { vargs va = {{args...}}; return detail::const_check(detail::use_utf8) ? vprintln(f, fmt.str, va) : detail::vprint_mojibake(f, fmt.str, va, true); } /// Formats `args` according to specifications in `fmt` and writes the output /// to `stdout` followed by a newline. template FMT_INLINE void println(format_string fmt, T&&... args) { return fmt::println(stdout, fmt, static_cast(args)...); } FMT_PRAGMA_CLANG(diagnostic pop) FMT_PRAGMA_GCC(pop_options) FMT_END_EXPORT FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # include "format.h" #endif #endif // FMT_BASE_H_ aristocratos-btop-d43a485/include/fmt/chrono.h000066400000000000000000002271071517514752700214300ustar00rootroot00000000000000// Formatting library for C++ - chrono support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_CHRONO_H_ #define FMT_CHRONO_H_ #ifndef FMT_MODULE # include # include # include // std::isfinite # include // std::memcpy # include # include # include # include # include #endif #include "format.h" FMT_BEGIN_NAMESPACE // Enable safe chrono durations, unless explicitly disabled. #ifndef FMT_SAFE_DURATION_CAST # define FMT_SAFE_DURATION_CAST 1 #endif #if FMT_SAFE_DURATION_CAST // For conversion between std::chrono::durations without undefined // behaviour or erroneous results. // This is a stripped down version of duration_cast, for inclusion in fmt. // See https://github.com/pauldreik/safe_duration_cast // // Copyright Paul Dreik 2019 namespace safe_duration_cast { // DEPRECATED! template ::value && std::numeric_limits::is_signed == std::numeric_limits::is_signed)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; using F = std::numeric_limits; using T = std::numeric_limits; static_assert(F::is_integer, "From must be integral"); static_assert(T::is_integer, "To must be integral"); // A and B are both signed, or both unsigned. if (detail::const_check(F::digits <= T::digits)) { // From fits in To without any problem. } else { // From does not always fit in To, resort to a dynamic check. if (from < (T::min)() || from > (T::max)()) { // outside range. ec = 1; return {}; } } return static_cast(from); } /// Converts From to To, without loss. If the dynamic value of from /// can't be converted to To without loss, ec is set. template ::value && std::numeric_limits::is_signed != std::numeric_limits::is_signed)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; using F = std::numeric_limits; using T = std::numeric_limits; static_assert(F::is_integer, "From must be integral"); static_assert(T::is_integer, "To must be integral"); if (detail::const_check(F::is_signed && !T::is_signed)) { // From may be negative, not allowed! if (fmt::detail::is_negative(from)) { ec = 1; return {}; } // From is positive. Can it always fit in To? if (detail::const_check(F::digits > T::digits) && from > static_cast(detail::max_value())) { ec = 1; return {}; } } if (detail::const_check(!F::is_signed && T::is_signed && F::digits >= T::digits) && from > static_cast(detail::max_value())) { ec = 1; return {}; } return static_cast(from); // Lossless conversion. } template ::value)> FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec) -> To { ec = 0; return from; } // function // clang-format off /** * converts From to To if possible, otherwise ec is set. * * input | output * ---------------------------------|--------------- * NaN | NaN * Inf | Inf * normal, fits in output | converted (possibly lossy) * normal, does not fit in output | ec is set * subnormal | best effort * -Inf | -Inf */ // clang-format on template ::value)> FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; using T = std::numeric_limits; static_assert(std::is_floating_point::value, "From must be floating"); static_assert(std::is_floating_point::value, "To must be floating"); // catch the only happy case if (std::isfinite(from)) { if (from >= T::lowest() && from <= (T::max)()) { return static_cast(from); } // not within range. ec = 1; return {}; } // nan and inf will be preserved return static_cast(from); } // function template ::value)> FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To { ec = 0; static_assert(std::is_floating_point::value, "From must be floating"); return from; } /// Safe duration_cast between floating point durations template ::value), FMT_ENABLE_IF(std::is_floating_point::value)> auto safe_duration_cast(std::chrono::duration from, int& ec) -> To { using From = std::chrono::duration; ec = 0; // the basic idea is that we need to convert from count() in the from type // to count() in the To type, by multiplying it with this: struct Factor : std::ratio_divide {}; static_assert(Factor::num > 0, "num must be positive"); static_assert(Factor::den > 0, "den must be positive"); // the conversion is like this: multiply from.count() with Factor::num // /Factor::den and convert it to To::rep, all this without // overflow/underflow. let's start by finding a suitable type that can hold // both To, From and Factor::num using IntermediateRep = typename std::common_type::type; // force conversion of From::rep -> IntermediateRep to be safe, // even if it will never happen be narrowing in this context. IntermediateRep count = safe_float_conversion(from.count(), ec); if (ec) { return {}; } // multiply with Factor::num without overflow or underflow if (detail::const_check(Factor::num != 1)) { constexpr auto max1 = detail::max_value() / static_cast(Factor::num); if (count > max1) { ec = 1; return {}; } constexpr auto min1 = std::numeric_limits::lowest() / static_cast(Factor::num); if (count < min1) { ec = 1; return {}; } count *= static_cast(Factor::num); } // this can't go wrong, right? den>0 is checked earlier. if (detail::const_check(Factor::den != 1)) { using common_t = typename std::common_type::type; count /= static_cast(Factor::den); } // convert to the to type, safely using ToRep = typename To::rep; const ToRep tocount = safe_float_conversion(count, ec); if (ec) { return {}; } return To{tocount}; } } // namespace safe_duration_cast #endif namespace detail { // Check if std::chrono::utc_time is available. #ifdef FMT_USE_UTC_TIME // Use the provided definition. #elif defined(__cpp_lib_chrono) # define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L) #else # define FMT_USE_UTC_TIME 0 #endif #if FMT_USE_UTC_TIME using utc_clock = std::chrono::utc_clock; #else struct utc_clock { template void to_sys(T); }; #endif // Check if std::chrono::local_time is available. #ifdef FMT_USE_LOCAL_TIME // Use the provided definition. #elif defined(__cpp_lib_chrono) # define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L) #else # define FMT_USE_LOCAL_TIME 0 #endif #if FMT_USE_LOCAL_TIME using local_t = std::chrono::local_t; #else struct local_t {}; #endif } // namespace detail template using sys_time = std::chrono::time_point; template using utc_time = std::chrono::time_point; template using local_time = std::chrono::time_point; namespace detail { // Prevents expansion of a preceding token as a function-style macro. // Usage: f FMT_NOMACRO() #define FMT_NOMACRO template struct null {}; inline auto gmtime_r(...) -> null<> { return null<>(); } inline auto gmtime_s(...) -> null<> { return null<>(); } // It is defined here and not in ostream.h because the latter has expensive // includes. template class formatbuf : public StreamBuf { private: using char_type = typename StreamBuf::char_type; using streamsize = decltype(std::declval().sputn(nullptr, 0)); using int_type = typename StreamBuf::int_type; using traits_type = typename StreamBuf::traits_type; buffer& buffer_; public: explicit formatbuf(buffer& buf) : buffer_(buf) {} protected: // The put area is always empty. This makes the implementation simpler and has // the advantage that the streambuf and the buffer are always in sync and // sputc never writes into uninitialized memory. A disadvantage is that each // call to sputc always results in a (virtual) call to overflow. There is no // disadvantage here for sputn since this always results in a call to xsputn. auto overflow(int_type ch) -> int_type override { if (!traits_type::eq_int_type(ch, traits_type::eof())) buffer_.push_back(static_cast(ch)); return ch; } auto xsputn(const char_type* s, streamsize count) -> streamsize override { buffer_.append(s, s + count); return count; } }; inline auto get_classic_locale() -> const std::locale& { static const auto& locale = std::locale::classic(); return locale; } template struct codecvt_result { static constexpr size_t max_size = 32; CodeUnit buf[max_size]; CodeUnit* end; }; template void write_codecvt(codecvt_result& out, string_view in, const std::locale& loc) { FMT_PRAGMA_CLANG(diagnostic push) FMT_PRAGMA_CLANG(diagnostic ignored "-Wdeprecated") auto& f = std::use_facet>(loc); FMT_PRAGMA_CLANG(diagnostic pop) auto mb = std::mbstate_t(); const char* from_next = nullptr; auto result = f.in(mb, in.begin(), in.end(), from_next, std::begin(out.buf), std::end(out.buf), out.end); if (result != std::codecvt_base::ok) FMT_THROW(format_error("failed to format time")); } template auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc) -> OutputIt { if (const_check(detail::use_utf8) && loc != get_classic_locale()) { // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and // gcc-4. #if FMT_MSC_VERSION != 0 || \ (defined(__GLIBCXX__) && \ (!defined(_GLIBCXX_USE_DUAL_ABI) || _GLIBCXX_USE_DUAL_ABI == 0)) // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5 // and newer. using code_unit = wchar_t; #else using code_unit = char32_t; #endif using unit_t = codecvt_result; unit_t unit; write_codecvt(unit, in, loc); // In UTF-8 is used one to four one-byte code units. auto u = to_utf8>(); if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)})) FMT_THROW(format_error("failed to format time")); return copy(u.c_str(), u.c_str() + u.size(), out); } return copy(in.data(), in.data() + in.size(), out); } template ::value)> auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { codecvt_result unit; write_codecvt(unit, sv, loc); return copy(unit.buf, unit.end, out); } template ::value)> auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc) -> OutputIt { return write_encoded_tm_str(out, sv, loc); } template inline void do_write(buffer& buf, const std::tm& time, const std::locale& loc, char format, char modifier) { auto&& format_buf = formatbuf>(buf); auto&& os = std::basic_ostream(&format_buf); os.imbue(loc); const auto& facet = std::use_facet>(loc); auto end = facet.put(os, os, Char(' '), &time, format, modifier); if (end.failed()) FMT_THROW(format_error("failed to format time")); } template ::value)> auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt { auto&& buf = get_buffer(out); do_write(buf, time, loc, format, modifier); return get_iterator(buf, out); } template ::value)> auto write(OutputIt out, const std::tm& time, const std::locale& loc, char format, char modifier = 0) -> OutputIt { auto&& buf = basic_memory_buffer(); do_write(buf, time, loc, format, modifier); return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc); } template using is_similar_arithmetic_type = bool_constant<(std::is_integral::value && std::is_integral::value) || (std::is_floating_point::value && std::is_floating_point::value)>; FMT_NORETURN inline void throw_duration_error() { FMT_THROW(format_error("cannot format duration")); } // Cast one integral duration to another with an overflow check. template ::value&& std::is_integral::value)> auto duration_cast(std::chrono::duration from) -> To { #if !FMT_SAFE_DURATION_CAST return std::chrono::duration_cast(from); #else // The conversion factor: to.count() == factor * from.count(). using factor = std::ratio_divide; using common_rep = typename std::common_type::type; common_rep count = from.count(); // This conversion is lossless. // Multiply from.count() by factor and check for overflow. if (const_check(factor::num != 1)) { if (count > max_value() / factor::num) throw_duration_error(); const auto min = (std::numeric_limits::min)() / factor::num; if (const_check(!std::is_unsigned::value) && count < min) throw_duration_error(); count *= factor::num; } if (const_check(factor::den != 1)) count /= factor::den; int ec = 0; auto to = To(safe_duration_cast::lossless_integral_conversion( count, ec)); if (ec) throw_duration_error(); return to; #endif } template ::value&& std::is_floating_point::value)> auto duration_cast(std::chrono::duration from) -> To { #if FMT_SAFE_DURATION_CAST // Preserve infinity and NaN. if (!isfinite(from.count())) return static_cast(from.count()); // Throwing version of safe_duration_cast is only available for // integer to integer or float to float casts. int ec; To to = safe_duration_cast::safe_duration_cast(from, ec); if (ec) throw_duration_error(); return to; #else // Standard duration cast, may overflow. return std::chrono::duration_cast(from); #endif } template ::value)> auto duration_cast(std::chrono::duration from) -> To { // Mixed integer <-> float cast is not supported by safe duration_cast. return std::chrono::duration_cast(from); } template auto to_time_t(sys_time time_point) -> std::time_t { // Cannot use std::chrono::system_clock::to_time_t since this would first // require a cast to std::chrono::system_clock::time_point, which could // overflow. return detail::duration_cast>( time_point.time_since_epoch()) .count(); } } // namespace detail FMT_BEGIN_EXPORT /** * Converts given time since epoch as `std::time_t` value into calendar time, * expressed in Coordinated Universal Time (UTC). Unlike `std::gmtime`, this * function is thread-safe on most platforms. */ inline auto gmtime(std::time_t time) -> std::tm { struct dispatcher { std::time_t time_; std::tm tm_; inline dispatcher(std::time_t t) : time_(t) {} inline auto run() -> bool { using namespace fmt::detail; return handle(gmtime_r(&time_, &tm_)); } inline auto handle(std::tm* tm) -> bool { return tm != nullptr; } inline auto handle(detail::null<>) -> bool { using namespace fmt::detail; return fallback(gmtime_s(&tm_, &time_)); } inline auto fallback(int res) -> bool { return res == 0; } #if !FMT_MSC_VERSION inline auto fallback(detail::null<>) -> bool { std::tm* tm = std::gmtime(&time_); if (tm) tm_ = *tm; return tm != nullptr; } #endif }; auto gt = dispatcher(time); // Too big time values may be unsupported. if (!gt.run()) FMT_THROW(format_error("time_t value out of range")); return gt.tm_; } template inline auto gmtime(sys_time time_point) -> std::tm { return gmtime(detail::to_time_t(time_point)); } namespace detail { // Writes two-digit numbers a, b and c separated by sep to buf. // The method by Pavel Novikov based on // https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/. inline void write_digit2_separated(char* buf, unsigned a, unsigned b, unsigned c, char sep) { unsigned long long digits = a | (b << 24) | (static_cast(c) << 48); // Convert each value to BCD. // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b. // The difference is // y - x = a * 6 // a can be found from x: // a = floor(x / 10) // then // y = x + a * 6 = x + floor(x / 10) * 6 // floor(x / 10) is (x * 205) >> 11 (needs 16 bits). digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6; // Put low nibbles to high bytes and high nibbles to low bytes. digits = ((digits & 0x00f00000f00000f0) >> 4) | ((digits & 0x000f00000f00000f) << 8); auto usep = static_cast(sep); // Add ASCII '0' to each digit byte and insert separators. digits |= 0x3030003030003030 | (usep << 16) | (usep << 40); constexpr size_t len = 8; if (const_check(is_big_endian())) { char tmp[len]; std::memcpy(tmp, &digits, len); std::reverse_copy(tmp, tmp + len, buf); } else { std::memcpy(buf, &digits, len); } } template FMT_CONSTEXPR inline auto get_units() -> const char* { if (std::is_same::value) return "as"; if (std::is_same::value) return "fs"; if (std::is_same::value) return "ps"; if (std::is_same::value) return "ns"; if (std::is_same::value) return detail::use_utf8 ? "ยตs" : "us"; if (std::is_same::value) return "ms"; if (std::is_same::value) return "cs"; if (std::is_same::value) return "ds"; if (std::is_same>::value) return "s"; if (std::is_same::value) return "das"; if (std::is_same::value) return "hs"; if (std::is_same::value) return "ks"; if (std::is_same::value) return "Ms"; if (std::is_same::value) return "Gs"; if (std::is_same::value) return "Ts"; if (std::is_same::value) return "Ps"; if (std::is_same::value) return "Es"; if (std::is_same>::value) return "min"; if (std::is_same>::value) return "h"; if (std::is_same>::value) return "d"; return nullptr; } enum class numeric_system { standard, // Alternative numeric system, e.g. ๅไบŒ instead of 12 in ja_JP locale. alternative }; // Glibc extensions for formatting numeric values. enum class pad_type { // Pad a numeric result string with zeros (the default). zero, // Do not pad a numeric result string. none, // Pad a numeric result string with spaces. space, }; template auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt { if (pad == pad_type::none) return out; return detail::fill_n(out, width, pad == pad_type::space ? ' ' : '0'); } template auto write_padding(OutputIt out, pad_type pad) -> OutputIt { if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0'; return out; } // Parses a put_time-like format string and invokes handler actions. template FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end, Handler&& handler) -> const Char* { if (begin == end || *begin == '}') return begin; if (*begin != '%') FMT_THROW(format_error("invalid format")); auto ptr = begin; while (ptr != end) { pad_type pad = pad_type::zero; auto c = *ptr; if (c == '}') break; if (c != '%') { ++ptr; continue; } if (begin != ptr) handler.on_text(begin, ptr); ++ptr; // consume '%' if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr; switch (c) { case '_': pad = pad_type::space; ++ptr; break; case '-': pad = pad_type::none; ++ptr; break; } if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case '%': handler.on_text(ptr - 1, ptr); break; case 'n': { const Char newline[] = {'\n'}; handler.on_text(newline, newline + 1); break; } case 't': { const Char tab[] = {'\t'}; handler.on_text(tab, tab + 1); break; } // Year: case 'Y': handler.on_year(numeric_system::standard, pad); break; case 'y': handler.on_short_year(numeric_system::standard); break; case 'C': handler.on_century(numeric_system::standard); break; case 'G': handler.on_iso_week_based_year(); break; case 'g': handler.on_iso_week_based_short_year(); break; // Day of the week: case 'a': handler.on_abbr_weekday(); break; case 'A': handler.on_full_weekday(); break; case 'w': handler.on_dec0_weekday(numeric_system::standard); break; case 'u': handler.on_dec1_weekday(numeric_system::standard); break; // Month: case 'b': case 'h': handler.on_abbr_month(); break; case 'B': handler.on_full_month(); break; case 'm': handler.on_dec_month(numeric_system::standard, pad); break; // Day of the year/month: case 'U': handler.on_dec0_week_of_year(numeric_system::standard, pad); break; case 'W': handler.on_dec1_week_of_year(numeric_system::standard, pad); break; case 'V': handler.on_iso_week_of_year(numeric_system::standard, pad); break; case 'j': handler.on_day_of_year(pad); break; case 'd': handler.on_day_of_month(numeric_system::standard, pad); break; case 'e': handler.on_day_of_month(numeric_system::standard, pad_type::space); break; // Hour, minute, second: case 'H': handler.on_24_hour(numeric_system::standard, pad); break; case 'I': handler.on_12_hour(numeric_system::standard, pad); break; case 'M': handler.on_minute(numeric_system::standard, pad); break; case 'S': handler.on_second(numeric_system::standard, pad); break; // Other: case 'c': handler.on_datetime(numeric_system::standard); break; case 'x': handler.on_loc_date(numeric_system::standard); break; case 'X': handler.on_loc_time(numeric_system::standard); break; case 'D': handler.on_us_date(); break; case 'F': handler.on_iso_date(); break; case 'r': handler.on_12_hour_time(); break; case 'R': handler.on_24_hour_time(); break; case 'T': handler.on_iso_time(); break; case 'p': handler.on_am_pm(); break; case 'Q': handler.on_duration_value(); break; case 'q': handler.on_duration_unit(); break; case 'z': handler.on_utc_offset(numeric_system::standard); break; case 'Z': handler.on_tz_name(); break; // Alternative representation: case 'E': { if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case 'Y': handler.on_year(numeric_system::alternative, pad); break; case 'y': handler.on_offset_year(); break; case 'C': handler.on_century(numeric_system::alternative); break; case 'c': handler.on_datetime(numeric_system::alternative); break; case 'x': handler.on_loc_date(numeric_system::alternative); break; case 'X': handler.on_loc_time(numeric_system::alternative); break; case 'z': handler.on_utc_offset(numeric_system::alternative); break; default: FMT_THROW(format_error("invalid format")); } break; } case 'O': if (ptr == end) FMT_THROW(format_error("invalid format")); c = *ptr++; switch (c) { case 'y': handler.on_short_year(numeric_system::alternative); break; case 'm': handler.on_dec_month(numeric_system::alternative, pad); break; case 'U': handler.on_dec0_week_of_year(numeric_system::alternative, pad); break; case 'W': handler.on_dec1_week_of_year(numeric_system::alternative, pad); break; case 'V': handler.on_iso_week_of_year(numeric_system::alternative, pad); break; case 'd': handler.on_day_of_month(numeric_system::alternative, pad); break; case 'e': handler.on_day_of_month(numeric_system::alternative, pad_type::space); break; case 'w': handler.on_dec0_weekday(numeric_system::alternative); break; case 'u': handler.on_dec1_weekday(numeric_system::alternative); break; case 'H': handler.on_24_hour(numeric_system::alternative, pad); break; case 'I': handler.on_12_hour(numeric_system::alternative, pad); break; case 'M': handler.on_minute(numeric_system::alternative, pad); break; case 'S': handler.on_second(numeric_system::alternative, pad); break; case 'z': handler.on_utc_offset(numeric_system::alternative); break; default: FMT_THROW(format_error("invalid format")); } break; default: FMT_THROW(format_error("invalid format")); } begin = ptr; } if (begin != ptr) handler.on_text(begin, ptr); return ptr; } template struct null_chrono_spec_handler { FMT_CONSTEXPR void unsupported() { static_cast(this)->unsupported(); } FMT_CONSTEXPR void on_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_offset_year() { unsupported(); } FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); } FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); } FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); } FMT_CONSTEXPR void on_full_weekday() { unsupported(); } FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_abbr_month() { unsupported(); } FMT_CONSTEXPR void on_full_month() { unsupported(); } FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_day_of_year(pad_type) { unsupported(); } FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) { unsupported(); } FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_us_date() { unsupported(); } FMT_CONSTEXPR void on_iso_date() { unsupported(); } FMT_CONSTEXPR void on_12_hour_time() { unsupported(); } FMT_CONSTEXPR void on_24_hour_time() { unsupported(); } FMT_CONSTEXPR void on_iso_time() { unsupported(); } FMT_CONSTEXPR void on_am_pm() { unsupported(); } FMT_CONSTEXPR void on_duration_value() { unsupported(); } FMT_CONSTEXPR void on_duration_unit() { unsupported(); } FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); } FMT_CONSTEXPR void on_tz_name() { unsupported(); } }; class tm_format_checker : public null_chrono_spec_handler { private: bool has_timezone_ = false; public: constexpr explicit tm_format_checker(bool has_timezone) : has_timezone_(has_timezone) {} FMT_NORETURN inline void unsupported() { FMT_THROW(format_error("no format")); } template FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR void on_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_short_year(numeric_system) {} FMT_CONSTEXPR void on_offset_year() {} FMT_CONSTEXPR void on_century(numeric_system) {} FMT_CONSTEXPR void on_iso_week_based_year() {} FMT_CONSTEXPR void on_iso_week_based_short_year() {} FMT_CONSTEXPR void on_abbr_weekday() {} FMT_CONSTEXPR void on_full_weekday() {} FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {} FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {} FMT_CONSTEXPR void on_abbr_month() {} FMT_CONSTEXPR void on_full_month() {} FMT_CONSTEXPR void on_dec_month(numeric_system, pad_type) {} FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_iso_week_of_year(numeric_system, pad_type) {} FMT_CONSTEXPR void on_day_of_year(pad_type) {} FMT_CONSTEXPR void on_day_of_month(numeric_system, pad_type) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} FMT_CONSTEXPR void on_datetime(numeric_system) {} FMT_CONSTEXPR void on_loc_date(numeric_system) {} FMT_CONSTEXPR void on_loc_time(numeric_system) {} FMT_CONSTEXPR void on_us_date() {} FMT_CONSTEXPR void on_iso_date() {} FMT_CONSTEXPR void on_12_hour_time() {} FMT_CONSTEXPR void on_24_hour_time() {} FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_utc_offset(numeric_system) { if (!has_timezone_) FMT_THROW(format_error("no timezone")); } FMT_CONSTEXPR void on_tz_name() { if (!has_timezone_) FMT_THROW(format_error("no timezone")); } }; inline auto tm_wday_full_name(int wday) -> const char* { static constexpr const char* full_name_list[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}; return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?"; } inline auto tm_wday_short_name(int wday) -> const char* { static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???"; } inline auto tm_mon_full_name(int mon) -> const char* { static constexpr const char* full_name_list[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"}; return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?"; } inline auto tm_mon_short_name(int mon) -> const char* { static constexpr const char* short_name_list[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", }; return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???"; } template struct has_tm_gmtoff : std::false_type {}; template struct has_tm_gmtoff> : std::true_type {}; template struct has_tm_zone : std::false_type {}; template struct has_tm_zone> : std::true_type {}; template ::value)> auto set_tm_zone(T& time, char* tz) -> bool { time.tm_zone = tz; return true; } template ::value)> auto set_tm_zone(T&, char*) -> bool { return false; } inline auto utc() -> char* { static char tz[] = "UTC"; return tz; } // Converts value to Int and checks that it's in the range [0, upper). template ::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { if (!std::is_unsigned::value && (value < 0 || to_unsigned(value) > to_unsigned(upper))) { FMT_THROW(format_error("chrono value is out of range")); } return static_cast(value); } template ::value)> inline auto to_nonnegative_int(T value, Int upper) -> Int { auto int_value = static_cast(value); if (int_value < 0 || value > static_cast(upper)) FMT_THROW(format_error("invalid value")); return int_value; } constexpr auto pow10(std::uint32_t n) -> long long { return n == 0 ? 1 : 10 * pow10(n - 1); } // Counts the number of fractional digits in the range [0, 18] according to the // C++20 spec. If more than 18 fractional digits are required then returns 6 for // microseconds precision. template () / 10)> struct count_fractional_digits { static constexpr int value = Num % Den == 0 ? N : count_fractional_digits::value; }; // Base case that doesn't instantiate any more templates // in order to avoid overflow. template struct count_fractional_digits { static constexpr int value = (Num % Den == 0) ? N : 6; }; // Format subseconds which are given as an integer type with an appropriate // number of digits. template void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) { constexpr auto num_fractional_digits = count_fractional_digits::value; using subsecond_precision = std::chrono::duration< typename std::common_type::type, std::ratio<1, pow10(num_fractional_digits)>>; const auto fractional = d - detail::duration_cast(d); const auto subseconds = std::chrono::treat_as_floating_point< typename subsecond_precision::rep>::value ? fractional.count() : detail::duration_cast(fractional).count(); auto n = static_cast>(subseconds); const int num_digits = count_digits(n); int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits); if (precision < 0) { FMT_ASSERT(!std::is_floating_point::value, ""); if (std::ratio_less::value) { *out++ = '.'; out = detail::fill_n(out, leading_zeroes, '0'); out = format_decimal(out, n, num_digits); } } else if (precision > 0) { *out++ = '.'; leading_zeroes = min_of(leading_zeroes, precision); int remaining = precision - leading_zeroes; out = detail::fill_n(out, leading_zeroes, '0'); if (remaining < num_digits) { int num_truncated_digits = num_digits - remaining; n /= to_unsigned(pow10(to_unsigned(num_truncated_digits))); if (n != 0) out = format_decimal(out, n, remaining); return; } if (n != 0) { out = format_decimal(out, n, num_digits); remaining -= num_digits; } out = detail::fill_n(out, remaining, '0'); } } // Format subseconds which are given as a floating point type with an // appropriate number of digits. We cannot pass the Duration here, as we // explicitly need to pass the Rep value in the duration_formatter. template void write_floating_seconds(memory_buffer& buf, Duration duration, int num_fractional_digits = -1) { using rep = typename Duration::rep; FMT_ASSERT(std::is_floating_point::value, ""); auto val = duration.count(); if (num_fractional_digits < 0) { // For `std::round` with fallback to `round`: // On some toolchains `std::round` is not available (e.g. GCC 6). using namespace std; num_fractional_digits = count_fractional_digits::value; if (num_fractional_digits < 6 && static_cast(round(val)) != val) num_fractional_digits = 6; } fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"), std::fmod(val * static_cast(Duration::period::num) / static_cast(Duration::period::den), static_cast(60)), num_fractional_digits); } template class tm_writer { private: static constexpr int days_per_week = 7; const std::locale& loc_; bool is_classic_; OutputIt out_; const Duration* subsecs_; const std::tm& tm_; auto tm_sec() const noexcept -> int { FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, ""); return tm_.tm_sec; } auto tm_min() const noexcept -> int { FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, ""); return tm_.tm_min; } auto tm_hour() const noexcept -> int { FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, ""); return tm_.tm_hour; } auto tm_mday() const noexcept -> int { FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, ""); return tm_.tm_mday; } auto tm_mon() const noexcept -> int { FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, ""); return tm_.tm_mon; } auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; } auto tm_wday() const noexcept -> int { FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, ""); return tm_.tm_wday; } auto tm_yday() const noexcept -> int { FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, ""); return tm_.tm_yday; } auto tm_hour12() const noexcept -> int { auto h = tm_hour(); auto z = h < 12 ? h : h - 12; return z == 0 ? 12 : z; } // POSIX and the C Standard are unclear or inconsistent about what %C and %y // do if the year is negative or exceeds 9999. Use the convention that %C // concatenated with %y yields the same output as %Y, and that %Y contains at // least 4 characters, with more only if necessary. auto split_year_lower(long long year) const noexcept -> int { auto l = year % 100; if (l < 0) l = -l; // l in [0, 99] return static_cast(l); } // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date. auto iso_year_weeks(long long curr_year) const noexcept -> int { auto prev_year = curr_year - 1; auto curr_p = (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) % days_per_week; auto prev_p = (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) % days_per_week; return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0); } auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int { return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) / days_per_week; } auto tm_iso_week_year() const noexcept -> long long { auto year = tm_year(); auto w = iso_week_num(tm_yday(), tm_wday()); if (w < 1) return year - 1; if (w > iso_year_weeks(year)) return year + 1; return year; } auto tm_iso_week_of_year() const noexcept -> int { auto year = tm_year(); auto w = iso_week_num(tm_yday(), tm_wday()); if (w < 1) return iso_year_weeks(year - 1); if (w > iso_year_weeks(year)) return 1; return w; } void write1(int value) { *out_++ = static_cast('0' + to_unsigned(value) % 10); } void write2(int value) { const char* d = digits2(to_unsigned(value) % 100); *out_++ = *d++; *out_++ = *d; } void write2(int value, pad_type pad) { unsigned int v = to_unsigned(value) % 100; if (v >= 10) { const char* d = digits2(v); *out_++ = *d++; *out_++ = *d; } else { out_ = detail::write_padding(out_, pad); *out_++ = static_cast('0' + v); } } void write_year_extended(long long year, pad_type pad) { // At least 4 characters. int width = 4; bool negative = year < 0; if (negative) { year = 0 - year; --width; } uint32_or_64_or_128_t n = to_unsigned(year); const int num_digits = count_digits(n); if (negative && pad == pad_type::zero) *out_++ = '-'; if (width > num_digits) out_ = detail::write_padding(out_, pad, width - num_digits); if (negative && pad != pad_type::zero) *out_++ = '-'; out_ = format_decimal(out_, n, num_digits); } void write_year(long long year, pad_type pad) { write_year_extended(year, pad); } void write_utc_offset(long long offset, numeric_system ns) { if (offset < 0) { *out_++ = '-'; offset = -offset; } else { *out_++ = '+'; } offset /= 60; write2(static_cast(offset / 60)); if (ns != numeric_system::standard) *out_++ = ':'; write2(static_cast(offset % 60)); } template ::value)> void format_utc_offset(const T& tm, numeric_system ns) { write_utc_offset(tm.tm_gmtoff, ns); } template ::value)> void format_utc_offset(const T&, numeric_system ns) { write_utc_offset(0, ns); } template ::value)> void format_tz_name(const T& tm) { out_ = write_tm_str(out_, tm.tm_zone, loc_); } template ::value)> void format_tz_name(const T&) { out_ = std::copy_n(utc(), 3, out_); } void format_localized(char format, char modifier = 0) { out_ = write(out_, tm_, loc_, format, modifier); } public: tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm, const Duration* subsecs = nullptr) : loc_(loc), is_classic_(loc_ == get_classic_locale()), out_(out), subsecs_(subsecs), tm_(tm) {} auto out() const -> OutputIt { return out_; } FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) { out_ = copy(begin, end, out_); } void on_abbr_weekday() { if (is_classic_) out_ = write(out_, tm_wday_short_name(tm_wday())); else format_localized('a'); } void on_full_weekday() { if (is_classic_) out_ = write(out_, tm_wday_full_name(tm_wday())); else format_localized('A'); } void on_dec0_weekday(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday()); format_localized('w', 'O'); } void on_dec1_weekday(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write1(wday == 0 ? days_per_week : wday); } else { format_localized('u', 'O'); } } void on_abbr_month() { if (is_classic_) out_ = write(out_, tm_mon_short_name(tm_mon())); else format_localized('b'); } void on_full_month() { if (is_classic_) out_ = write(out_, tm_mon_full_name(tm_mon())); else format_localized('B'); } void on_datetime(numeric_system ns) { if (is_classic_) { on_abbr_weekday(); *out_++ = ' '; on_abbr_month(); *out_++ = ' '; on_day_of_month(numeric_system::standard, pad_type::space); *out_++ = ' '; on_iso_time(); *out_++ = ' '; on_year(numeric_system::standard, pad_type::space); } else { format_localized('c', ns == numeric_system::standard ? '\0' : 'E'); } } void on_loc_date(numeric_system ns) { if (is_classic_) on_us_date(); else format_localized('x', ns == numeric_system::standard ? '\0' : 'E'); } void on_loc_time(numeric_system ns) { if (is_classic_) on_iso_time(); else format_localized('X', ns == numeric_system::standard ? '\0' : 'E'); } void on_us_date() { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), to_unsigned(split_year_lower(tm_year())), '/'); out_ = copy(std::begin(buf), std::end(buf), out_); } void on_iso_date() { auto year = tm_year(); char buf[10]; size_t offset = 0; if (year >= 0 && year < 10000) { write2digits(buf, static_cast(year / 100)); } else { offset = 4; write_year_extended(year, pad_type::zero); year = 0; } write_digit2_separated(buf + 2, static_cast(year % 100), to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()), '-'); out_ = copy(std::begin(buf) + offset, std::end(buf), out_); } void on_utc_offset(numeric_system ns) { format_utc_offset(tm_, ns); } void on_tz_name() { format_tz_name(tm_); } void on_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write_year(tm_year(), pad); format_localized('Y', 'E'); } void on_short_year(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) return write2(split_year_lower(tm_year())); format_localized('y', 'O'); } void on_offset_year() { if (is_classic_) return write2(split_year_lower(tm_year())); format_localized('y', 'E'); } void on_century(numeric_system ns) { if (is_classic_ || ns == numeric_system::standard) { auto year = tm_year(); auto upper = year / 100; if (year >= -99 && year < 0) { // Zero upper on negative year. *out_++ = '-'; *out_++ = '0'; } else if (upper >= 0 && upper < 100) { write2(static_cast(upper)); } else { out_ = write(out_, upper); } } else { format_localized('C', 'E'); } } void on_dec_month(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_mon() + 1, pad); format_localized('m', 'O'); } void on_dec0_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week, pad); format_localized('U', 'O'); } void on_dec1_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) { auto wday = tm_wday(); write2((tm_yday() + days_per_week - (wday == 0 ? (days_per_week - 1) : (wday - 1))) / days_per_week, pad); } else { format_localized('W', 'O'); } } void on_iso_week_of_year(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_iso_week_of_year(), pad); format_localized('V', 'O'); } void on_iso_week_based_year() { write_year(tm_iso_week_year(), pad_type::zero); } void on_iso_week_based_short_year() { write2(split_year_lower(tm_iso_week_year())); } void on_day_of_year(pad_type pad) { auto yday = tm_yday() + 1; auto digit1 = yday / 100; if (digit1 != 0) write1(digit1); else out_ = detail::write_padding(out_, pad); write2(yday % 100, pad); } void on_day_of_month(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday(), pad); format_localized('d', 'O'); } void on_24_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour(), pad); format_localized('H', 'O'); } void on_12_hour(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_hour12(), pad); format_localized('I', 'O'); } void on_minute(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) return write2(tm_min(), pad); format_localized('M', 'O'); } void on_second(numeric_system ns, pad_type pad) { if (is_classic_ || ns == numeric_system::standard) { write2(tm_sec(), pad); if (subsecs_) { if (std::is_floating_point::value) { auto buf = memory_buffer(); write_floating_seconds(buf, *subsecs_); if (buf.size() > 1) { // Remove the leading "0", write something like ".123". out_ = copy(buf.begin() + 1, buf.end(), out_); } } else { write_fractional_seconds(out_, *subsecs_); } } } else { // Currently no formatting of subseconds when a locale is set. format_localized('S', 'O'); } } void on_12_hour_time() { if (is_classic_) { char buf[8]; write_digit2_separated(buf, to_unsigned(tm_hour12()), to_unsigned(tm_min()), to_unsigned(tm_sec()), ':'); out_ = copy(std::begin(buf), std::end(buf), out_); *out_++ = ' '; on_am_pm(); } else { format_localized('r'); } } void on_24_hour_time() { write2(tm_hour()); *out_++ = ':'; write2(tm_min()); } void on_iso_time() { on_24_hour_time(); *out_++ = ':'; on_second(numeric_system::standard, pad_type::zero); } void on_am_pm() { if (is_classic_) { *out_++ = tm_hour() < 12 ? 'A' : 'P'; *out_++ = 'M'; } else { format_localized('p'); } } // These apply to chrono durations but not tm. void on_duration_value() {} void on_duration_unit() {} }; struct chrono_format_checker : null_chrono_spec_handler { bool has_precision_integral = false; FMT_NORETURN inline void unsupported() { FMT_THROW(format_error("no date")); } template FMT_CONSTEXPR void on_text(const Char*, const Char*) {} FMT_CONSTEXPR void on_day_of_year(pad_type) {} FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {} FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {} FMT_CONSTEXPR void on_second(numeric_system, pad_type) {} FMT_CONSTEXPR void on_12_hour_time() {} FMT_CONSTEXPR void on_24_hour_time() {} FMT_CONSTEXPR void on_iso_time() {} FMT_CONSTEXPR void on_am_pm() {} FMT_CONSTEXPR void on_duration_value() const { if (has_precision_integral) FMT_THROW(format_error("precision not allowed for this argument type")); } FMT_CONSTEXPR void on_duration_unit() {} }; template ::value&& has_isfinite::value)> inline auto isfinite(T) -> bool { return true; } template ::value)> inline auto mod(T x, int y) -> T { return x % static_cast(y); } template ::value)> inline auto mod(T x, int y) -> T { return std::fmod(x, static_cast(y)); } // If T is an integral type, maps T to its unsigned counterpart, otherwise // leaves it unchanged (unlike std::make_unsigned). template ::value> struct make_unsigned_or_unchanged { using type = T; }; template struct make_unsigned_or_unchanged { using type = typename std::make_unsigned::type; }; template ::value)> inline auto get_milliseconds(std::chrono::duration d) -> std::chrono::duration { // This may overflow and/or the result may not fit in the target type. #if FMT_SAFE_DURATION_CAST using common_seconds_type = typename std::common_type::type; auto d_as_common = detail::duration_cast(d); auto d_as_whole_seconds = detail::duration_cast(d_as_common); // This conversion should be nonproblematic. auto diff = d_as_common - d_as_whole_seconds; auto ms = detail::duration_cast>(diff); return ms; #else auto s = detail::duration_cast(d); return detail::duration_cast(d - s); #endif } template ::value)> auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt { return write(out, val); } template ::value)> auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt { auto specs = format_specs(); specs.precision = precision; specs.set_type(precision >= 0 ? presentation_type::fixed : presentation_type::general); return write(out, val, specs); } template auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt { return copy(unit.begin(), unit.end(), out); } template auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt { // This works when wchar_t is UTF-32 because units only contain characters // that have the same representation in UTF-16 and UTF-32. utf8_to_utf16 u(unit); return copy(u.c_str(), u.c_str() + u.size(), out); } template auto format_duration_unit(OutputIt out) -> OutputIt { if (const char* unit = get_units()) return copy_unit(string_view(unit), out, Char()); *out++ = '['; out = write(out, Period::num); if (const_check(Period::den != 1)) { *out++ = '/'; out = write(out, Period::den); } *out++ = ']'; *out++ = 's'; return out; } class get_locale { private: union { std::locale locale_; }; bool has_locale_ = false; public: inline get_locale(bool localized, locale_ref loc) : has_locale_(localized) { if (localized) ::new (&locale_) std::locale(loc.template get()); } inline ~get_locale() { if (has_locale_) locale_.~locale(); } inline operator const std::locale&() const { return has_locale_ ? locale_ : get_classic_locale(); } }; template struct duration_formatter { using iterator = basic_appender; iterator out; // rep is unsigned to avoid overflow. using rep = conditional_t::value && sizeof(Rep) < sizeof(int), unsigned, typename make_unsigned_or_unchanged::type>; rep val; int precision; locale_ref locale; bool localized = false; using seconds = std::chrono::duration; seconds s; using milliseconds = std::chrono::duration; bool negative; using tm_writer_type = tm_writer; duration_formatter(iterator o, std::chrono::duration d, locale_ref loc) : out(o), val(static_cast(d.count())), locale(loc), negative(false) { if (d.count() < 0) { val = 0 - val; negative = true; } // this may overflow and/or the result may not fit in the // target type. // might need checked conversion (rep!=Rep) s = detail::duration_cast(std::chrono::duration(val)); } // returns true if nan or inf, writes to out. auto handle_nan_inf() -> bool { if (isfinite(val)) return false; if (isnan(val)) { write_nan(); return true; } // must be +-inf if (val > 0) std::copy_n("inf", 3, out); else std::copy_n("-inf", 4, out); return true; } auto days() const -> Rep { return static_cast(s.count() / 86400); } auto hour() const -> Rep { return static_cast(mod((s.count() / 3600), 24)); } auto hour12() const -> Rep { Rep hour = static_cast(mod((s.count() / 3600), 12)); return hour <= 0 ? 12 : hour; } auto minute() const -> Rep { return static_cast(mod((s.count() / 60), 60)); } auto second() const -> Rep { return static_cast(mod(s.count(), 60)); } auto time() const -> std::tm { auto time = std::tm(); time.tm_hour = to_nonnegative_int(hour(), 24); time.tm_min = to_nonnegative_int(minute(), 60); time.tm_sec = to_nonnegative_int(second(), 60); return time; } void write_sign() { if (!negative) return; *out++ = '-'; negative = false; } void write(Rep value, int width, pad_type pad = pad_type::zero) { write_sign(); if (isnan(value)) return write_nan(); uint32_or_64_or_128_t n = to_unsigned(to_nonnegative_int(value, max_value())); int num_digits = detail::count_digits(n); if (width > num_digits) { out = detail::write_padding(out, pad, width - num_digits); } out = format_decimal(out, n, num_digits); } void write_nan() { std::copy_n("nan", 3, out); } template void format_tm(const tm& time, Callback cb, Args... args) { if (isnan(val)) return write_nan(); get_locale loc(localized, locale); auto w = tm_writer_type(loc, out, time); (w.*cb)(args...); out = w.out(); } void on_text(const Char* begin, const Char* end) { copy(begin, end, out); } // These are not implemented because durations don't have date information. void on_abbr_weekday() {} void on_full_weekday() {} void on_dec0_weekday(numeric_system) {} void on_dec1_weekday(numeric_system) {} void on_abbr_month() {} void on_full_month() {} void on_datetime(numeric_system) {} void on_loc_date(numeric_system) {} void on_loc_time(numeric_system) {} void on_us_date() {} void on_iso_date() {} void on_utc_offset(numeric_system) {} void on_tz_name() {} void on_year(numeric_system, pad_type) {} void on_short_year(numeric_system) {} void on_offset_year() {} void on_century(numeric_system) {} void on_iso_week_based_year() {} void on_iso_week_based_short_year() {} void on_dec_month(numeric_system, pad_type) {} void on_dec0_week_of_year(numeric_system, pad_type) {} void on_dec1_week_of_year(numeric_system, pad_type) {} void on_iso_week_of_year(numeric_system, pad_type) {} void on_day_of_month(numeric_system, pad_type) {} void on_day_of_year(pad_type) { if (handle_nan_inf()) return; write(days(), 0); } void on_24_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(hour(), 2, pad); auto time = tm(); time.tm_hour = to_nonnegative_int(hour(), 24); format_tm(time, &tm_writer_type::on_24_hour, ns, pad); } void on_12_hour(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(hour12(), 2, pad); auto time = tm(); time.tm_hour = to_nonnegative_int(hour12(), 12); format_tm(time, &tm_writer_type::on_12_hour, ns, pad); } void on_minute(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) return write(minute(), 2, pad); auto time = tm(); time.tm_min = to_nonnegative_int(minute(), 60); format_tm(time, &tm_writer_type::on_minute, ns, pad); } void on_second(numeric_system ns, pad_type pad) { if (handle_nan_inf()) return; if (ns == numeric_system::standard) { if (std::is_floating_point::value) { auto buf = memory_buffer(); write_floating_seconds(buf, std::chrono::duration(val), precision); if (negative) *out++ = '-'; if (buf.size() < 2 || buf[1] == '.') out = detail::write_padding(out, pad); out = copy(buf.begin(), buf.end(), out); } else { write(second(), 2, pad); write_fractional_seconds( out, std::chrono::duration(val), precision); } return; } auto time = tm(); time.tm_sec = to_nonnegative_int(second(), 60); format_tm(time, &tm_writer_type::on_second, ns, pad); } void on_12_hour_time() { if (handle_nan_inf()) return; format_tm(time(), &tm_writer_type::on_12_hour_time); } void on_24_hour_time() { if (handle_nan_inf()) { *out++ = ':'; handle_nan_inf(); return; } write(hour(), 2); *out++ = ':'; write(minute(), 2); } void on_iso_time() { on_24_hour_time(); *out++ = ':'; if (handle_nan_inf()) return; on_second(numeric_system::standard, pad_type::zero); } void on_am_pm() { if (handle_nan_inf()) return; format_tm(time(), &tm_writer_type::on_am_pm); } void on_duration_value() { if (handle_nan_inf()) return; write_sign(); out = format_duration_value(out, val, precision); } void on_duration_unit() { out = format_duration_unit(out); } }; } // namespace detail #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907 using weekday = std::chrono::weekday; using day = std::chrono::day; using month = std::chrono::month; using year = std::chrono::year; using year_month_day = std::chrono::year_month_day; #else // A fallback version of weekday. class weekday { private: unsigned char value_; public: weekday() = default; constexpr explicit weekday(unsigned wd) noexcept : value_(static_cast(wd != 7 ? wd : 0)) {} constexpr auto c_encoding() const noexcept -> unsigned { return value_; } }; class day { private: unsigned char value_; public: day() = default; constexpr explicit day(unsigned d) noexcept : value_(static_cast(d)) {} constexpr explicit operator unsigned() const noexcept { return value_; } }; class month { private: unsigned char value_; public: month() = default; constexpr explicit month(unsigned m) noexcept : value_(static_cast(m)) {} constexpr explicit operator unsigned() const noexcept { return value_; } }; class year { private: int value_; public: year() = default; constexpr explicit year(int y) noexcept : value_(y) {} constexpr explicit operator int() const noexcept { return value_; } }; class year_month_day { private: fmt::year year_; fmt::month month_; fmt::day day_; public: year_month_day() = default; constexpr year_month_day(const year& y, const month& m, const day& d) noexcept : year_(y), month_(m), day_(d) {} constexpr auto year() const noexcept -> fmt::year { return year_; } constexpr auto month() const noexcept -> fmt::month { return month_; } constexpr auto day() const noexcept -> fmt::day { return day_; } }; #endif // __cpp_lib_chrono >= 201907 template struct formatter : private formatter { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it != end && *it == 'L') { ++it; this->set_localized(); } use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter::parse(ctx) : it; } template auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_wday = static_cast(wd.c_encoding()); if (use_tm_formatter_) return formatter::format(time, ctx); detail::get_locale loc(this->localized(), ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_abbr_weekday(); return w.out(); } }; template struct formatter : private formatter { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter::parse(ctx) : it; } template auto format(day d, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_mday = static_cast(static_cast(d)); if (use_tm_formatter_) return formatter::format(time, ctx); detail::get_locale loc(false, ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_day_of_month(detail::numeric_system::standard, detail::pad_type::zero); return w.out(); } }; template struct formatter : private formatter { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it != end && *it == 'L') { ++it; this->set_localized(); } use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter::parse(ctx) : it; } template auto format(month m, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_mon = static_cast(static_cast(m)) - 1; if (use_tm_formatter_) return formatter::format(time, ctx); detail::get_locale loc(this->localized(), ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_abbr_month(); return w.out(); } }; template struct formatter : private formatter { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter::parse(ctx) : it; } template auto format(year y, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_year = static_cast(y) - 1900; if (use_tm_formatter_) return formatter::format(time, ctx); detail::get_locale loc(false, ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_year(detail::numeric_system::standard, detail::pad_type::zero); return w.out(); } }; template struct formatter : private formatter { private: bool use_tm_formatter_ = false; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); use_tm_formatter_ = it != end && *it != '}'; return use_tm_formatter_ ? formatter::parse(ctx) : it; } template auto format(year_month_day val, FormatContext& ctx) const -> decltype(ctx.out()) { auto time = std::tm(); time.tm_year = static_cast(val.year()) - 1900; time.tm_mon = static_cast(static_cast(val.month())) - 1; time.tm_mday = static_cast(static_cast(val.day())); if (use_tm_formatter_) return formatter::format(time, ctx); detail::get_locale loc(true, ctx.locale()); auto w = detail::tm_writer(loc, ctx.out(), time); w.on_iso_date(); return w.out(); } }; template struct formatter, Char> { private: format_specs specs_; detail::arg_ref width_ref_; detail::arg_ref precision_ref_; basic_string_view fmt_; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; Char c = *it; if ((c >= '0' && c <= '9') || c == '{') { it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it == end) return it; } auto checker = detail::chrono_format_checker(); if (*it == '.') { checker.has_precision_integral = !std::is_floating_point::value; it = detail::parse_precision(it, end, specs_, precision_ref_, ctx); } if (it != end && *it == 'L') { specs_.set_localized(); ++it; } end = detail::parse_chrono_format(it, end, checker); fmt_ = {it, detail::to_unsigned(end - it)}; return end; } template auto format(std::chrono::duration d, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; auto precision = specs.precision; specs.precision = -1; auto begin = fmt_.begin(), end = fmt_.end(); // As a possible future optimization, we could avoid extra copying if width // is not specified. auto buf = basic_memory_buffer(); auto out = basic_appender(buf); detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), precision, precision_ref_, ctx); if (begin == end || *begin == '}') { out = detail::format_duration_value(out, d.count(), precision); detail::format_duration_unit(out); } else { auto f = detail::duration_formatter(out, d, ctx.locale()); f.precision = precision; f.localized = specs_.localized(); detail::parse_chrono_format(begin, end, f); } return detail::write( ctx.out(), basic_string_view(buf.data(), buf.size()), specs); } }; template struct formatter { private: format_specs specs_; detail::arg_ref width_ref_; basic_string_view fmt_ = detail::string_literal(); protected: auto localized() const -> bool { return specs_.localized(); } FMT_CONSTEXPR void set_localized() { specs_.set_localized(); } FMT_CONSTEXPR auto do_parse(parse_context& ctx, bool has_timezone) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it == end || *it == '}') return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; Char c = *it; if ((c >= '0' && c <= '9') || c == '{') { it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it == end) return it; } if (*it == 'L') { specs_.set_localized(); ++it; } end = detail::parse_chrono_format(it, end, detail::tm_format_checker(has_timezone)); // Replace the default format string only if the new spec is not empty. if (end != it) fmt_ = {it, detail::to_unsigned(end - it)}; return end; } template auto do_format(const std::tm& tm, FormatContext& ctx, const Duration* subsecs) const -> decltype(ctx.out()) { auto specs = specs_; auto buf = basic_memory_buffer(); auto out = basic_appender(buf); detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); auto loc_ref = specs.localized() ? ctx.locale() : locale_ref(); detail::get_locale loc(static_cast(loc_ref), loc_ref); auto w = detail::tm_writer, Char, Duration>( loc, out, tm, subsecs); detail::parse_chrono_format(fmt_.begin(), fmt_.end(), w); return detail::write( ctx.out(), basic_string_view(buf.data(), buf.size()), specs); } public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return do_parse(ctx, detail::has_tm_gmtoff::value); } template auto format(const std::tm& tm, FormatContext& ctx) const -> decltype(ctx.out()) { return do_format(tm, ctx, nullptr); } }; // DEPRECATED! Reversed order of template parameters. template struct formatter, Char> : private formatter { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return this->do_parse(ctx, true); } template auto format(sys_time val, FormatContext& ctx) const -> decltype(ctx.out()) { std::tm tm = gmtime(val); using period = typename Duration::period; if (detail::const_check( period::num == 1 && period::den == 1 && !std::is_floating_point::value)) { detail::set_tm_zone(tm, detail::utc()); return formatter::format(tm, ctx); } Duration epoch = val.time_since_epoch(); Duration subsecs = detail::duration_cast( epoch - detail::duration_cast(epoch)); if (subsecs.count() < 0) { auto second = detail::duration_cast(std::chrono::seconds(1)); if (tm.tm_sec != 0) { --tm.tm_sec; } else { tm = gmtime(val - second); detail::set_tm_zone(tm, detail::utc()); } subsecs += second; } return formatter::do_format(tm, ctx, &subsecs); } }; template struct formatter, Char> : formatter, Char> { template auto format(utc_time val, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter, Char>::format( detail::utc_clock::to_sys(val), ctx); } }; template struct formatter, Char> : private formatter { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return this->do_parse(ctx, false); } template auto format(local_time val, FormatContext& ctx) const -> decltype(ctx.out()) { auto time_since_epoch = val.time_since_epoch(); auto seconds_since_epoch = detail::duration_cast(time_since_epoch); // Use gmtime to prevent time zone conversion since local_time has an // unspecified time zone. std::tm t = gmtime(seconds_since_epoch.count()); using period = typename Duration::period; if (period::num == 1 && period::den == 1 && !std::is_floating_point::value) { return formatter::format(t, ctx); } auto subsecs = detail::duration_cast(time_since_epoch - seconds_since_epoch); return formatter::do_format(t, ctx, &subsecs); } }; FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_CHRONO_H_ aristocratos-btop-d43a485/include/fmt/color.h000066400000000000000000000571141517514752700212550ustar00rootroot00000000000000// Formatting library for C++ - color support // // Copyright (c) 2018 - present, Victor Zverovich and fmt contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_COLOR_H_ #define FMT_COLOR_H_ #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT enum class color : uint32_t { alice_blue = 0xF0F8FF, // rgb(240,248,255) antique_white = 0xFAEBD7, // rgb(250,235,215) aqua = 0x00FFFF, // rgb(0,255,255) aquamarine = 0x7FFFD4, // rgb(127,255,212) azure = 0xF0FFFF, // rgb(240,255,255) beige = 0xF5F5DC, // rgb(245,245,220) bisque = 0xFFE4C4, // rgb(255,228,196) black = 0x000000, // rgb(0,0,0) blanched_almond = 0xFFEBCD, // rgb(255,235,205) blue = 0x0000FF, // rgb(0,0,255) blue_violet = 0x8A2BE2, // rgb(138,43,226) brown = 0xA52A2A, // rgb(165,42,42) burly_wood = 0xDEB887, // rgb(222,184,135) cadet_blue = 0x5F9EA0, // rgb(95,158,160) chartreuse = 0x7FFF00, // rgb(127,255,0) chocolate = 0xD2691E, // rgb(210,105,30) coral = 0xFF7F50, // rgb(255,127,80) cornflower_blue = 0x6495ED, // rgb(100,149,237) cornsilk = 0xFFF8DC, // rgb(255,248,220) crimson = 0xDC143C, // rgb(220,20,60) cyan = 0x00FFFF, // rgb(0,255,255) dark_blue = 0x00008B, // rgb(0,0,139) dark_cyan = 0x008B8B, // rgb(0,139,139) dark_golden_rod = 0xB8860B, // rgb(184,134,11) dark_gray = 0xA9A9A9, // rgb(169,169,169) dark_green = 0x006400, // rgb(0,100,0) dark_khaki = 0xBDB76B, // rgb(189,183,107) dark_magenta = 0x8B008B, // rgb(139,0,139) dark_olive_green = 0x556B2F, // rgb(85,107,47) dark_orange = 0xFF8C00, // rgb(255,140,0) dark_orchid = 0x9932CC, // rgb(153,50,204) dark_red = 0x8B0000, // rgb(139,0,0) dark_salmon = 0xE9967A, // rgb(233,150,122) dark_sea_green = 0x8FBC8F, // rgb(143,188,143) dark_slate_blue = 0x483D8B, // rgb(72,61,139) dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) dark_turquoise = 0x00CED1, // rgb(0,206,209) dark_violet = 0x9400D3, // rgb(148,0,211) deep_pink = 0xFF1493, // rgb(255,20,147) deep_sky_blue = 0x00BFFF, // rgb(0,191,255) dim_gray = 0x696969, // rgb(105,105,105) dodger_blue = 0x1E90FF, // rgb(30,144,255) fire_brick = 0xB22222, // rgb(178,34,34) floral_white = 0xFFFAF0, // rgb(255,250,240) forest_green = 0x228B22, // rgb(34,139,34) fuchsia = 0xFF00FF, // rgb(255,0,255) gainsboro = 0xDCDCDC, // rgb(220,220,220) ghost_white = 0xF8F8FF, // rgb(248,248,255) gold = 0xFFD700, // rgb(255,215,0) golden_rod = 0xDAA520, // rgb(218,165,32) gray = 0x808080, // rgb(128,128,128) green = 0x008000, // rgb(0,128,0) green_yellow = 0xADFF2F, // rgb(173,255,47) honey_dew = 0xF0FFF0, // rgb(240,255,240) hot_pink = 0xFF69B4, // rgb(255,105,180) indian_red = 0xCD5C5C, // rgb(205,92,92) indigo = 0x4B0082, // rgb(75,0,130) ivory = 0xFFFFF0, // rgb(255,255,240) khaki = 0xF0E68C, // rgb(240,230,140) lavender = 0xE6E6FA, // rgb(230,230,250) lavender_blush = 0xFFF0F5, // rgb(255,240,245) lawn_green = 0x7CFC00, // rgb(124,252,0) lemon_chiffon = 0xFFFACD, // rgb(255,250,205) light_blue = 0xADD8E6, // rgb(173,216,230) light_coral = 0xF08080, // rgb(240,128,128) light_cyan = 0xE0FFFF, // rgb(224,255,255) light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) light_gray = 0xD3D3D3, // rgb(211,211,211) light_green = 0x90EE90, // rgb(144,238,144) light_pink = 0xFFB6C1, // rgb(255,182,193) light_salmon = 0xFFA07A, // rgb(255,160,122) light_sea_green = 0x20B2AA, // rgb(32,178,170) light_sky_blue = 0x87CEFA, // rgb(135,206,250) light_slate_gray = 0x778899, // rgb(119,136,153) light_steel_blue = 0xB0C4DE, // rgb(176,196,222) light_yellow = 0xFFFFE0, // rgb(255,255,224) lime = 0x00FF00, // rgb(0,255,0) lime_green = 0x32CD32, // rgb(50,205,50) linen = 0xFAF0E6, // rgb(250,240,230) magenta = 0xFF00FF, // rgb(255,0,255) maroon = 0x800000, // rgb(128,0,0) medium_aquamarine = 0x66CDAA, // rgb(102,205,170) medium_blue = 0x0000CD, // rgb(0,0,205) medium_orchid = 0xBA55D3, // rgb(186,85,211) medium_purple = 0x9370DB, // rgb(147,112,219) medium_sea_green = 0x3CB371, // rgb(60,179,113) medium_slate_blue = 0x7B68EE, // rgb(123,104,238) medium_spring_green = 0x00FA9A, // rgb(0,250,154) medium_turquoise = 0x48D1CC, // rgb(72,209,204) medium_violet_red = 0xC71585, // rgb(199,21,133) midnight_blue = 0x191970, // rgb(25,25,112) mint_cream = 0xF5FFFA, // rgb(245,255,250) misty_rose = 0xFFE4E1, // rgb(255,228,225) moccasin = 0xFFE4B5, // rgb(255,228,181) navajo_white = 0xFFDEAD, // rgb(255,222,173) navy = 0x000080, // rgb(0,0,128) old_lace = 0xFDF5E6, // rgb(253,245,230) olive = 0x808000, // rgb(128,128,0) olive_drab = 0x6B8E23, // rgb(107,142,35) orange = 0xFFA500, // rgb(255,165,0) orange_red = 0xFF4500, // rgb(255,69,0) orchid = 0xDA70D6, // rgb(218,112,214) pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) pale_green = 0x98FB98, // rgb(152,251,152) pale_turquoise = 0xAFEEEE, // rgb(175,238,238) pale_violet_red = 0xDB7093, // rgb(219,112,147) papaya_whip = 0xFFEFD5, // rgb(255,239,213) peach_puff = 0xFFDAB9, // rgb(255,218,185) peru = 0xCD853F, // rgb(205,133,63) pink = 0xFFC0CB, // rgb(255,192,203) plum = 0xDDA0DD, // rgb(221,160,221) powder_blue = 0xB0E0E6, // rgb(176,224,230) purple = 0x800080, // rgb(128,0,128) rebecca_purple = 0x663399, // rgb(102,51,153) red = 0xFF0000, // rgb(255,0,0) rosy_brown = 0xBC8F8F, // rgb(188,143,143) royal_blue = 0x4169E1, // rgb(65,105,225) saddle_brown = 0x8B4513, // rgb(139,69,19) salmon = 0xFA8072, // rgb(250,128,114) sandy_brown = 0xF4A460, // rgb(244,164,96) sea_green = 0x2E8B57, // rgb(46,139,87) sea_shell = 0xFFF5EE, // rgb(255,245,238) sienna = 0xA0522D, // rgb(160,82,45) silver = 0xC0C0C0, // rgb(192,192,192) sky_blue = 0x87CEEB, // rgb(135,206,235) slate_blue = 0x6A5ACD, // rgb(106,90,205) slate_gray = 0x708090, // rgb(112,128,144) snow = 0xFFFAFA, // rgb(255,250,250) spring_green = 0x00FF7F, // rgb(0,255,127) steel_blue = 0x4682B4, // rgb(70,130,180) tan = 0xD2B48C, // rgb(210,180,140) teal = 0x008080, // rgb(0,128,128) thistle = 0xD8BFD8, // rgb(216,191,216) tomato = 0xFF6347, // rgb(255,99,71) turquoise = 0x40E0D0, // rgb(64,224,208) violet = 0xEE82EE, // rgb(238,130,238) wheat = 0xF5DEB3, // rgb(245,222,179) white = 0xFFFFFF, // rgb(255,255,255) white_smoke = 0xF5F5F5, // rgb(245,245,245) yellow = 0xFFFF00, // rgb(255,255,0) yellow_green = 0x9ACD32 // rgb(154,205,50) }; // enum class color enum class terminal_color : uint8_t { black = 30, red, green, yellow, blue, magenta, cyan, white, bright_black = 90, bright_red, bright_green, bright_yellow, bright_blue, bright_magenta, bright_cyan, bright_white }; enum class emphasis : uint8_t { bold = 1, faint = 1 << 1, italic = 1 << 2, underline = 1 << 3, blink = 1 << 4, reverse = 1 << 5, conceal = 1 << 6, strikethrough = 1 << 7, }; // rgb is a struct for red, green and blue colors. // Using the name "rgb" makes some editors show the color in a tooltip. struct rgb { constexpr rgb() : r(0), g(0), b(0) {} constexpr rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {} constexpr rgb(uint32_t hex) : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {} constexpr rgb(color hex) : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF), b(uint32_t(hex) & 0xFF) {} uint8_t r; uint8_t g; uint8_t b; }; namespace detail { // A bit-packed variant of an RGB color, a terminal color, or unset color. // see text_style for the bit-packing scheme. struct color_type { constexpr color_type() noexcept = default; constexpr color_type(color rgb_color) noexcept : value_(static_cast(rgb_color) | (1 << 24)) {} constexpr color_type(rgb rgb_color) noexcept : color_type(static_cast( (static_cast(rgb_color.r) << 16) | (static_cast(rgb_color.g) << 8) | rgb_color.b)) {} constexpr color_type(terminal_color term_color) noexcept : value_(static_cast(term_color) | (3 << 24)) {} constexpr auto is_terminal_color() const noexcept -> bool { return (value_ & (1 << 25)) != 0; } constexpr auto value() const noexcept -> uint32_t { return value_ & 0xFFFFFF; } constexpr color_type(uint32_t value) noexcept : value_(value) {} uint32_t value_ = 0; }; } // namespace detail /// A text style consisting of foreground and background colors and emphasis. class text_style { // The information is packed as follows: // โ”Œโ”€โ”€โ” // โ”‚ 0โ”‚โ”€โ” // โ”‚..โ”‚ โ”œโ”€โ”€ foreground color value // โ”‚23โ”‚โ”€โ”˜ // โ”œโ”€โ”€โ”ค // โ”‚24โ”‚โ”€โ”ฌโ”€โ”€ discriminator for the above value. 00 if unset, 01 if it's // โ”‚25โ”‚โ”€โ”˜ an RGB color, or 11 if it's a terminal color (10 is unused) // โ”œโ”€โ”€โ”ค // โ”‚26โ”‚โ”€โ”€โ”€โ”€ overflow bit, always zero (see below) // โ”œโ”€โ”€โ”ค // โ”‚27โ”‚โ”€โ” // โ”‚..โ”‚ โ”‚ // โ”‚50โ”‚ โ”‚ // โ”œโ”€โ”€โ”ค โ”‚ // โ”‚51โ”‚ โ”œโ”€โ”€ background color (same format as the foreground color) // โ”‚52โ”‚ โ”‚ // โ”œโ”€โ”€โ”ค โ”‚ // โ”‚53โ”‚โ”€โ”˜ // โ”œโ”€โ”€โ”ค // โ”‚54โ”‚โ”€โ” // โ”‚..โ”‚ โ”œโ”€โ”€ emphases // โ”‚61โ”‚โ”€โ”˜ // โ”œโ”€โ”€โ”ค // โ”‚62โ”‚โ”€โ”ฌโ”€โ”€ unused // โ”‚63โ”‚โ”€โ”˜ // โ””โ”€โ”€โ”˜ // The overflow bits are there to make operator|= efficient. // When ORing, we must throw if, for either the foreground or background, // one style specifies a terminal color and the other specifies any color // (terminal or RGB); in other words, if one discriminator is 11 and the // other is 11 or 01. // // We do that check by adding the styles. Consider what adding does to each // possible pair of discriminators: // 00 + 00 = 000 // 01 + 00 = 001 // 11 + 00 = 011 // 01 + 01 = 010 // 11 + 01 = 100 (!!) // 11 + 11 = 110 (!!) // In the last two cases, the ones we want to catch, the third bitโ€”โ€”the // overflow bitโ€”โ€”is set. Bingo. // // We must take into account the possible carry bit from the bits // before the discriminator. The only potentially problematic case is // 11 + 00 = 011 (a carry bit would make it 100, not good!), but a carry // bit is impossible in that case, because 00 (unset color) means the // 24 bits that precede the discriminator are all zero. // // This test can be applied to both colors simultaneously. public: FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept : style_(static_cast(em) << 54) {} FMT_CONSTEXPR auto operator|=(text_style rhs) -> text_style& { if (((style_ + rhs.style_) & ((1ULL << 26) | (1ULL << 53))) != 0) report_error("can't OR a terminal color"); style_ |= rhs.style_; return *this; } friend FMT_CONSTEXPR auto operator|(text_style lhs, text_style rhs) -> text_style { return lhs |= rhs; } FMT_CONSTEXPR auto operator==(text_style rhs) const noexcept -> bool { return style_ == rhs.style_; } FMT_CONSTEXPR auto operator!=(text_style rhs) const noexcept -> bool { return !(*this == rhs); } FMT_CONSTEXPR auto has_foreground() const noexcept -> bool { return (style_ & (1 << 24)) != 0; } FMT_CONSTEXPR auto has_background() const noexcept -> bool { return (style_ & (1ULL << 51)) != 0; } FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool { return (style_ >> 54) != 0; } FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type { FMT_ASSERT(has_foreground(), "no foreground specified for this style"); return style_ & 0x3FFFFFF; } FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type { FMT_ASSERT(has_background(), "no background specified for this style"); return (style_ >> 27) & 0x3FFFFFF; } FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis { FMT_ASSERT(has_emphasis(), "no emphasis specified for this style"); return static_cast(style_ >> 54); } private: FMT_CONSTEXPR text_style(uint64_t style) noexcept : style_(style) {} friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept -> text_style; friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept -> text_style; uint64_t style_ = 0; }; /// Creates a text style from the foreground (text) color. FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept -> text_style { return foreground.value_; } /// Creates a text style from the background color. FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept -> text_style { return static_cast(background.value_) << 27; } FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept -> text_style { return text_style(lhs) | rhs; } namespace detail { template struct ansi_color_escape { FMT_CONSTEXPR ansi_color_escape(color_type text_color, const char* esc) noexcept { // If we have a terminal color, we need to output another escape code // sequence. if (text_color.is_terminal_color()) { bool is_background = esc == string_view("\x1b[48;2;"); uint32_t value = text_color.value(); // Background ASCII codes are the same as the foreground ones but with // 10 more. if (is_background) value += 10u; buffer[size++] = static_cast('\x1b'); buffer[size++] = static_cast('['); if (value >= 100u) { buffer[size++] = static_cast('1'); value %= 100u; } buffer[size++] = static_cast('0' + value / 10u); buffer[size++] = static_cast('0' + value % 10u); buffer[size++] = static_cast('m'); return; } for (int i = 0; i < 7; i++) { buffer[i] = static_cast(esc[i]); } rgb color(text_color.value()); to_esc(color.r, buffer + 7, ';'); to_esc(color.g, buffer + 11, ';'); to_esc(color.b, buffer + 15, 'm'); size = 19; } FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept { uint8_t em_codes[num_emphases] = {}; if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1; if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2; if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3; if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4; if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5; if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7; if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8; if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9; buffer[size++] = static_cast('\x1b'); buffer[size++] = static_cast('['); for (size_t i = 0; i < num_emphases; ++i) { if (!em_codes[i]) continue; buffer[size++] = static_cast('0' + em_codes[i]); buffer[size++] = static_cast(';'); } buffer[size - 1] = static_cast('m'); } FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; } FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; } FMT_CONSTEXPR auto end() const noexcept -> const Char* { return buffer + size; } private: static constexpr size_t num_emphases = 8; Char buffer[7u + 4u * num_emphases]; size_t size = 0; static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out, char delimiter) noexcept { out[0] = static_cast('0' + c / 100); out[1] = static_cast('0' + c / 10 % 10); out[2] = static_cast('0' + c % 10); out[3] = static_cast(delimiter); } static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept -> bool { return static_cast(em) & static_cast(mask); } }; template FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept -> ansi_color_escape { return ansi_color_escape(foreground, "\x1b[38;2;"); } template FMT_CONSTEXPR auto make_background_color(color_type background) noexcept -> ansi_color_escape { return ansi_color_escape(background, "\x1b[48;2;"); } template FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept -> ansi_color_escape { return ansi_color_escape(em); } template inline void reset_color(buffer& buffer) { auto reset_color = string_view("\x1b[0m"); buffer.append(reset_color.begin(), reset_color.end()); } template struct styled_arg : view { const T& value; text_style style; styled_arg(const T& v, text_style s) : value(v), style(s) {} }; template void vformat_to(buffer& buf, text_style ts, basic_string_view fmt, basic_format_args> args) { if (ts.has_emphasis()) { auto emphasis = make_emphasis(ts.get_emphasis()); buf.append(emphasis.begin(), emphasis.end()); } if (ts.has_foreground()) { auto foreground = make_foreground_color(ts.get_foreground()); buf.append(foreground.begin(), foreground.end()); } if (ts.has_background()) { auto background = make_background_color(ts.get_background()); buf.append(background.begin(), background.end()); } vformat_to(buf, fmt, args); if (ts != text_style()) reset_color(buf); } } // namespace detail inline void vprint(FILE* f, text_style ts, string_view fmt, format_args args) { auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size())); } /** * Formats a string and prints it to the specified file stream using ANSI * escape sequences to specify text formatting. * * **Example**: * * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), * "Elapsed time: {0:.2f} seconds", 1.23); */ template void print(FILE* f, text_style ts, format_string fmt, T&&... args) { vprint(f, ts, fmt.str, vargs{{args...}}); } /** * Formats a string and prints it to stdout using ANSI escape sequences to * specify text formatting. * * **Example**: * * fmt::print(fmt::emphasis::bold | fg(fmt::color::red), * "Elapsed time: {0:.2f} seconds", 1.23); */ template void print(text_style ts, format_string fmt, T&&... args) { return print(stdout, ts, fmt, std::forward(args)...); } inline auto vformat(text_style ts, string_view fmt, format_args args) -> std::string { auto buf = memory_buffer(); detail::vformat_to(buf, ts, fmt, args); return fmt::to_string(buf); } /** * Formats arguments and returns the result as a string using ANSI escape * sequences to specify text formatting. * * **Example**: * * ``` * #include * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red), * "The answer is {}", 42); * ``` */ template inline auto format(text_style ts, format_string fmt, T&&... args) -> std::string { return fmt::vformat(ts, fmt.str, vargs{{args...}}); } /// Formats a string with the given text_style and writes the output to `out`. template ::value)> auto vformat_to(OutputIt out, text_style ts, string_view fmt, format_args args) -> OutputIt { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, ts, fmt, args); return detail::get_iterator(buf, out); } /** * Formats arguments with the given text style, writes the result to the output * iterator `out` and returns the iterator past the end of the output range. * * **Example**: * * std::vector out; * fmt::format_to(std::back_inserter(out), * fmt::emphasis::bold | fg(fmt::color::red), "{}", 42); */ template ::value)> inline auto format_to(OutputIt out, text_style ts, format_string fmt, T&&... args) -> OutputIt { return vformat_to(out, ts, fmt.str, vargs{{args...}}); } template struct formatter, Char> : formatter { template auto format(const detail::styled_arg& arg, FormatContext& ctx) const -> decltype(ctx.out()) { const auto& ts = arg.style; auto out = ctx.out(); bool has_style = false; if (ts.has_emphasis()) { has_style = true; auto emphasis = detail::make_emphasis(ts.get_emphasis()); out = detail::copy(emphasis.begin(), emphasis.end(), out); } if (ts.has_foreground()) { has_style = true; auto foreground = detail::make_foreground_color(ts.get_foreground()); out = detail::copy(foreground.begin(), foreground.end(), out); } if (ts.has_background()) { has_style = true; auto background = detail::make_background_color(ts.get_background()); out = detail::copy(background.begin(), background.end(), out); } out = formatter::format(arg.value, ctx); if (has_style) { auto reset_color = string_view("\x1b[0m"); out = detail::copy(reset_color.begin(), reset_color.end(), out); } return out; } }; /** * Returns an argument that will be formatted using ANSI escape sequences, * to be used in a formatting function. * * **Example**: * * fmt::print("Elapsed time: {0:.2f} seconds", * fmt::styled(1.23, fmt::fg(fmt::color::green) | * fmt::bg(fmt::color::blue))); */ template FMT_CONSTEXPR auto styled(const T& value, text_style ts) -> detail::styled_arg> { return detail::styled_arg>{value, ts}; } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_COLOR_H_ aristocratos-btop-d43a485/include/fmt/compile.h000066400000000000000000000477671517514752700216040ustar00rootroot00000000000000// Formatting library for C++ - experimental format string compilation // // Copyright (c) 2012 - present, Victor Zverovich and fmt contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_COMPILE_H_ #define FMT_COMPILE_H_ #ifndef FMT_MODULE # include // std::back_inserter #endif #include "format.h" FMT_BEGIN_NAMESPACE // A compile-time string which is compiled into fast formatting code. FMT_EXPORT class compiled_string {}; template struct is_compiled_string : std::is_base_of {}; /** * Converts a string literal `s` into a format string that will be parsed at * compile time and converted into efficient formatting code. Requires C++17 * `constexpr if` compiler support. * * **Example**: * * // Converts 42 into std::string using the most efficient method and no * // runtime format string processing. * std::string s = fmt::format(FMT_COMPILE("{}"), 42); */ #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) # define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string) #else # define FMT_COMPILE(s) FMT_STRING(s) #endif /** * Converts a string literal into a format string that will be parsed at * compile time and converted into efficient formatting code. Requires support * for class types in constant template parameters (a C++20 feature). * * **Example**: * * // Converts 42 into std::string using the most efficient method and no * // runtime format string processing. * using namespace fmt::literals; * std::string s = fmt::format("{}"_cf, 42); */ #if FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { template constexpr auto operator""_cf() { return FMT_COMPILE(Str.data); } } // namespace literals #endif namespace detail { template constexpr auto first(const T& value, const Tail&...) -> const T& { return value; } #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) template struct type_list {}; // Returns a reference to the argument at index N from [first, rest...]. template constexpr auto get([[maybe_unused]] const T& first, [[maybe_unused]] const Args&... rest) -> const auto& { static_assert(N < 1 + sizeof...(Args), "index is out of bounds"); if constexpr (N == 0) return first; else return detail::get(rest...); } # if FMT_USE_NONTYPE_TEMPLATE_ARGS template constexpr auto get_arg_index_by_name(basic_string_view name) -> int { if constexpr (is_static_named_arg()) { if (name == T::name) return N; } if constexpr (sizeof...(Args) > 0) return get_arg_index_by_name(name); (void)name; // Workaround an MSVC bug about "unused" parameter. return -1; } # endif template FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view name) -> int { # if FMT_USE_NONTYPE_TEMPLATE_ARGS if constexpr (sizeof...(Args) > 0) return get_arg_index_by_name<0, Args...>(name); # endif (void)name; return -1; } template constexpr auto get_arg_index_by_name(basic_string_view name, type_list) -> int { return get_arg_index_by_name(name); } template struct get_type_impl; template struct get_type_impl> { using type = remove_cvref_t(std::declval()...))>; }; template using get_type = typename get_type_impl::type; template struct is_compiled_format : std::false_type {}; template struct text { basic_string_view data; using char_type = Char; template constexpr auto format(OutputIt out, const T&...) const -> OutputIt { return write(out, data); } }; template struct is_compiled_format> : std::true_type {}; template constexpr auto make_text(basic_string_view s, size_t pos, size_t size) -> text { return {{&s[pos], size}}; } template struct code_unit { Char value; using char_type = Char; template constexpr auto format(OutputIt out, const T&...) const -> OutputIt { *out++ = value; return out; } }; // This ensures that the argument type is convertible to `const T&`. template constexpr auto get_arg_checked(const Args&... args) -> const T& { const auto& arg = detail::get(args...); if constexpr (detail::is_named_arg>()) { return arg.value; } else { return arg; } } template struct is_compiled_format> : std::true_type {}; // A replacement field that refers to argument N. template struct field { using char_type = Char; template constexpr auto format(OutputIt out, const T&... args) const -> OutputIt { const V& arg = get_arg_checked(args...); if constexpr (std::is_convertible>::value) { auto s = basic_string_view(arg); return copy(s.begin(), s.end(), out); } else { return write(out, arg); } } }; template struct is_compiled_format> : std::true_type {}; // A replacement field that refers to argument with name. template struct runtime_named_field { using char_type = Char; basic_string_view name; template constexpr static auto try_format_argument( OutputIt& out, // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9 [[maybe_unused]] basic_string_view arg_name, const T& arg) -> bool { if constexpr (is_named_arg::type>::value) { if (arg_name == arg.name) { out = write(out, arg.value); return true; } } return false; } template constexpr auto format(OutputIt out, const T&... args) const -> OutputIt { bool found = (try_format_argument(out, name, args) || ...); if (!found) { FMT_THROW(format_error("argument with specified name is not found")); } return out; } }; template struct is_compiled_format> : std::true_type {}; // A replacement field that refers to argument N and has format specifiers. template struct spec_field { using char_type = Char; formatter fmt; template constexpr FMT_INLINE auto format(OutputIt out, const T&... args) const -> OutputIt { const auto& vargs = fmt::make_format_args>(args...); basic_format_context ctx(out, vargs); return fmt.format(get_arg_checked(args...), ctx); } }; template struct is_compiled_format> : std::true_type {}; template struct concat { L lhs; R rhs; using char_type = typename L::char_type; template constexpr auto format(OutputIt out, const T&... args) const -> OutputIt { out = lhs.format(out, args...); return rhs.format(out, args...); } }; template struct is_compiled_format> : std::true_type {}; template constexpr auto make_concat(L lhs, R rhs) -> concat { return {lhs, rhs}; } struct unknown_format {}; template constexpr auto parse_text(basic_string_view str, size_t pos) -> size_t { for (size_t size = str.size(); pos != size; ++pos) { if (str[pos] == '{' || str[pos] == '}') break; } return pos; } template constexpr auto compile_format_string(S fmt); template constexpr auto parse_tail(T head, S fmt) { if constexpr (POS != basic_string_view(fmt).size()) { constexpr auto tail = compile_format_string(fmt); if constexpr (std::is_same, unknown_format>()) return tail; else return make_concat(head, tail); } else { return head; } } template struct parse_specs_result { formatter fmt; size_t end; int next_arg_id; }; enum { manual_indexing_id = -1 }; template constexpr auto parse_specs(basic_string_view str, size_t pos, int next_arg_id) -> parse_specs_result { str.remove_prefix(pos); auto ctx = compile_parse_context(str, max_value(), nullptr, next_arg_id); auto f = formatter(); auto end = f.parse(ctx); return {f, pos + fmt::detail::to_unsigned(end - str.data()), next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()}; } template struct arg_id_handler { arg_id_kind kind; arg_ref arg_id; constexpr auto on_auto() -> int { FMT_ASSERT(false, "handler cannot be used with automatic indexing"); return 0; } constexpr auto on_index(int id) -> int { kind = arg_id_kind::index; arg_id = arg_ref(id); return 0; } constexpr auto on_name(basic_string_view id) -> int { kind = arg_id_kind::name; arg_id = arg_ref(id); return 0; } }; template struct parse_arg_id_result { arg_id_kind kind; arg_ref arg_id; const Char* arg_id_end; }; template constexpr auto parse_arg_id(const Char* begin, const Char* end) { auto handler = arg_id_handler{arg_id_kind::none, arg_ref{}}; auto arg_id_end = parse_arg_id(begin, end, handler); return parse_arg_id_result{handler.kind, handler.arg_id, arg_id_end}; } template struct field_type { using type = remove_cvref_t; }; template struct field_type::value>> { using type = remove_cvref_t; }; template constexpr auto parse_replacement_field_then_tail(S fmt) { using char_type = typename S::char_type; constexpr auto str = basic_string_view(fmt); constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type(); if constexpr (c == '}') { return parse_tail( field::type, ARG_INDEX>(), fmt); } else if constexpr (c != ':') { FMT_THROW(format_error("expected ':'")); } else { constexpr auto result = parse_specs::type>( str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID); if constexpr (result.end >= str.size() || str[result.end] != '}') { FMT_THROW(format_error("expected '}'")); return 0; } else { return parse_tail( spec_field::type, ARG_INDEX>{ result.fmt}, fmt); } } } // Compiles a non-empty format string and returns the compiled representation // or unknown_format() on unrecognized input. template constexpr auto compile_format_string(S fmt) { using char_type = typename S::char_type; constexpr auto str = basic_string_view(fmt); if constexpr (str[POS] == '{') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '{' in format string")); if constexpr (str[POS + 1] == '{') { return parse_tail(make_text(str, POS, 1), fmt); } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') { static_assert(ID != manual_indexing_id, "cannot switch from manual to automatic argument indexing"); constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail, Args, POS + 1, ID, next_id>(fmt); } else { constexpr auto arg_id_result = parse_arg_id(str.data() + POS + 1, str.data() + str.size()); constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data(); constexpr char_type c = arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type(); static_assert(c == '}' || c == ':', "missing '}' in format string"); if constexpr (arg_id_result.kind == arg_id_kind::index) { static_assert( ID == manual_indexing_id || ID == 0, "cannot switch from automatic to manual argument indexing"); constexpr auto arg_index = arg_id_result.arg_id.index; return parse_replacement_field_then_tail, Args, arg_id_end_pos, arg_index, manual_indexing_id>( fmt); } else if constexpr (arg_id_result.kind == arg_id_kind::name) { constexpr auto arg_index = get_arg_index_by_name(arg_id_result.arg_id.name, Args{}); if constexpr (arg_index >= 0) { constexpr auto next_id = ID != manual_indexing_id ? ID + 1 : manual_indexing_id; return parse_replacement_field_then_tail< decltype(get_type::value), Args, arg_id_end_pos, arg_index, next_id>(fmt); } else if constexpr (c == '}') { return parse_tail( runtime_named_field{arg_id_result.arg_id.name}, fmt); } else if constexpr (c == ':') { return unknown_format(); // no type info for specs parsing } } } } else if constexpr (str[POS] == '}') { if constexpr (POS + 1 == str.size()) FMT_THROW(format_error("unmatched '}' in format string")); return parse_tail(make_text(str, POS, 1), fmt); } else { constexpr auto end = parse_text(str, POS + 1); if constexpr (end - POS > 1) { return parse_tail(make_text(str, POS, end - POS), fmt); } else { return parse_tail(code_unit{str[POS]}, fmt); } } } template ::value)> constexpr auto compile(S fmt) { constexpr auto str = basic_string_view(fmt); if constexpr (str.size() == 0) { return detail::make_text(str, 0, 0); } else { constexpr auto result = detail::compile_format_string, 0, 0>(fmt); return result; } } #endif // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) } // namespace detail FMT_BEGIN_EXPORT #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) template ::value)> FMT_INLINE FMT_CONSTEXPR_STRING auto format(const CompiledFormat& cf, const T&... args) -> std::basic_string { auto s = std::basic_string(); cf.format(std::back_inserter(s), args...); return s; } template ::value)> constexpr FMT_INLINE auto format_to(OutputIt out, const CompiledFormat& cf, const T&... args) -> OutputIt { return cf.format(out, args...); } template ::value)> FMT_INLINE FMT_CONSTEXPR_STRING auto format(const S&, T&&... args) -> std::basic_string { if constexpr (std::is_same::value) { constexpr auto str = basic_string_view(S()); if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') { const auto& first = detail::first(args...); if constexpr (detail::is_named_arg< remove_cvref_t>::value) { return fmt::to_string(first.value); } else { return fmt::to_string(first); } } } constexpr auto compiled = detail::compile(S()); if constexpr (std::is_same, detail::unknown_format>()) { return fmt::format( static_cast>(S()), std::forward(args)...); } else { return fmt::format(compiled, std::forward(args)...); } } template ::value)> FMT_CONSTEXPR auto format_to(OutputIt out, const S&, T&&... args) -> OutputIt { constexpr auto compiled = detail::compile(S()); if constexpr (std::is_same, detail::unknown_format>()) { return fmt::format_to( out, static_cast>(S()), std::forward(args)...); } else { return fmt::format_to(out, compiled, std::forward(args)...); } } #endif template ::value)> auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); fmt::format_to(std::back_inserter(buf), fmt, std::forward(args)...); return {buf.out(), buf.count()}; } template ::value)> FMT_CONSTEXPR20 auto formatted_size(const S& fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); fmt::format_to(appender(buf), fmt, std::forward(args)...); return buf.count(); } template ::value)> void print(std::FILE* f, const S& fmt, T&&... args) { auto buf = memory_buffer(); fmt::format_to(appender(buf), fmt, std::forward(args)...); detail::print(f, {buf.data(), buf.size()}); } template ::value)> void print(const S& fmt, T&&... args) { print(stdout, fmt, std::forward(args)...); } template class static_format_result { private: char data[N]; public: template ::value)> explicit FMT_CONSTEXPR static_format_result(const S& fmt, T&&... args) { *fmt::format_to(data, fmt, std::forward(args)...) = '\0'; } auto str() const -> fmt::string_view { return {data, N - 1}; } auto c_str() const -> const char* { return data; } }; /** * Formats arguments according to the format string `fmt_str` and produces * a string of the exact required size at compile time. Both the format string * and the arguments must be compile-time expressions. * * The resulting string can be accessed as a C string via `c_str()` or as * a `fmt::string_view` via `str()`. * * **Example**: * * // Produces the static string "42" at compile time. * static constexpr auto result = FMT_STATIC_FORMAT("{}", 42); * const char* s = result.c_str(); */ #define FMT_STATIC_FORMAT(fmt_str, ...) \ fmt::static_format_result< \ fmt::formatted_size(FMT_COMPILE(fmt_str), __VA_ARGS__) + 1>( \ FMT_COMPILE(fmt_str), __VA_ARGS__) FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_COMPILE_H_ aristocratos-btop-d43a485/include/fmt/core.h000066400000000000000000000002731517514752700210610ustar00rootroot00000000000000// This file is only provided for compatibility and may be removed in future // versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h // otherwise. #include "format.h" aristocratos-btop-d43a485/include/fmt/format-inl.h000066400000000000000000002364661517514752700222200ustar00rootroot00000000000000// Formatting library for C++ - implementation // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_FORMAT_INL_H_ #define FMT_FORMAT_INL_H_ #ifndef FMT_MODULE # include # include // errno # include # include # include #endif #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) # include // _isatty #endif #include "format.h" #if FMT_USE_LOCALE && !defined(FMT_MODULE) # include #endif #ifndef FMT_FUNC # define FMT_FUNC #endif FMT_BEGIN_NAMESPACE #ifndef FMT_CUSTOM_ASSERT_FAIL FMT_FUNC void assert_fail(const char* file, int line, const char* message) { // Use unchecked std::fprintf to avoid triggering another assertion when // writing to stderr fails. fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message); abort(); } #endif #if FMT_USE_LOCALE namespace detail { using std::locale; using std::numpunct; using std::use_facet; } // namespace detail template > locale_ref::locale_ref(const Locale& loc) : locale_(&loc) { static_assert(std::is_same::value, ""); } #else namespace detail { struct locale {}; template struct numpunct { auto grouping() const -> std::string { return "\03"; } auto thousands_sep() const -> Char { return ','; } auto decimal_point() const -> Char { return '.'; } }; template Facet use_facet(locale) { return {}; } } // namespace detail #endif // FMT_USE_LOCALE template auto locale_ref::get() const -> Locale { using namespace detail; static_assert(std::is_same::value, ""); #if FMT_USE_LOCALE if (locale_) return *static_cast(locale_); #endif return locale(); } namespace detail { FMT_FUNC void format_error_code(detail::buffer& out, int error_code, string_view message) noexcept { // Report error code making sure that the output fits into // inline_buffer_size to avoid dynamic memory allocation and potential // bad_alloc. out.try_resize(0); static const char SEP[] = ": "; static const char ERROR_STR[] = "error "; // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; auto abs_value = static_cast>(error_code); if (detail::is_negative(error_code)) { abs_value = 0 - abs_value; ++error_code_size; } error_code_size += detail::to_unsigned(detail::count_digits(abs_value)); auto it = appender(out); if (message.size() <= inline_buffer_size - error_code_size) fmt::format_to(it, FMT_STRING("{}{}"), message, SEP); fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code); FMT_ASSERT(out.size() <= inline_buffer_size, ""); } FMT_FUNC void do_report_error(format_func func, int error_code, const char* message) noexcept { memory_buffer full_message; func(full_message, error_code, message); // Don't use fwrite_all because the latter may throw. if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0) std::fputc('\n', stderr); } // A wrapper around fwrite that throws on error. inline void fwrite_all(const void* ptr, size_t count, FILE* stream) { size_t written = std::fwrite(ptr, 1, count, stream); if (written < count) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } template FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result { auto&& facet = use_facet>(loc.get()); auto grouping = facet.grouping(); auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep(); return {std::move(grouping), thousands_sep}; } template FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char { return use_facet>(loc.get()).decimal_point(); } #if FMT_USE_LOCALE FMT_FUNC auto write_loc(appender out, loc_value value, const format_specs& specs, locale_ref loc) -> bool { auto locale = loc.get(); // We cannot use the num_put facet because it may produce output in // a wrong encoding. using facet = format_facet; if (std::has_facet(locale)) return use_facet(locale).put(out, value, specs); return facet(locale).put(out, value, specs); } #endif } // namespace detail FMT_FUNC void report_error(const char* message) { #if FMT_MSC_VERSION || defined(__NVCC__) // Silence unreachable code warnings in MSVC and NVCC because these // are nearly impossible to fix in a generic code. volatile bool b = true; if (!b) return; #endif FMT_THROW(format_error(message)); } template typename Locale::id format_facet::id; template format_facet::format_facet(Locale& loc) { auto& np = detail::use_facet>(loc); grouping_ = np.grouping(); if (!grouping_.empty()) separator_ = std::string(1, np.thousands_sep()); } #if FMT_USE_LOCALE template <> FMT_API FMT_FUNC auto format_facet::do_put( appender out, loc_value val, const format_specs& specs) const -> bool { return val.visit( detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_}); } #endif FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args) -> std::system_error { auto ec = std::error_code(error_code, std::generic_category()); return std::system_error(ec, vformat(fmt, args)); } namespace detail { template inline auto operator==(basic_fp x, basic_fp y) -> bool { return x.f == y.f && x.e == y.e; } // Compilers should be able to optimize this into the ror instruction. FMT_INLINE auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t { r &= 31; return (n >> r) | (n << (32 - r)); } FMT_INLINE auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t { r &= 63; return (n >> r) | (n << (64 - r)); } // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox. namespace dragonbox { // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t { return umul128_upper64(static_cast(x) << 32, y); } // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback { uint64_t high = x * y.high(); uint128_fallback high_low = umul128(x, y.low()); return {high + high_low.high(), high_low.low()}; } // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a // 64-bit unsigned integer. inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t { return x * y; } // Various fast log computations. inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int { FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent"); return (e * 631305 - 261663) >> 21; } FMT_INLINE_VARIABLE constexpr struct div_small_pow10_infos_struct { uint32_t divisor; int shift_amount; } div_small_pow10_infos[] = {{10, 16}, {100, 16}}; // Replaces n by floor(n / pow(10, N)) returning true if and only if n is // divisible by pow(10, N). // Precondition: n <= pow(10, N + 1). template auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool { // The numbers below are chosen such that: // 1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100, // 2. nm mod 2^k < m if and only if n is divisible by d, // where m is magic_number, k is shift_amount // and d is divisor. // // Item 1 is a common technique of replacing division by a constant with // multiplication, see e.g. "Division by Invariant Integers Using // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set // to ceil(2^k/d) for large enough k. // The idea for item 2 originates from Schubfach. constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; n *= magic_number; const uint32_t comparison_mask = (1u << info.shift_amount) - 1; bool result = (n & comparison_mask) < magic_number; n >>= info.shift_amount; return result; } // Computes floor(n / pow(10, N)) for small n and N. // Precondition: n <= pow(10, N + 1). template auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t { constexpr auto info = div_small_pow10_infos[N - 1]; FMT_ASSERT(n <= info.divisor * 10, "n is too large"); constexpr uint32_t magic_number = (1u << info.shift_amount) / info.divisor + 1; return (n * magic_number) >> info.shift_amount; } // Computes floor(n / 10^(kappa + 1)) (float) inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t { // 1374389535 = ceil(2^37/100) return static_cast((static_cast(n) * 1374389535) >> 37); } // Computes floor(n / 10^(kappa + 1)) (double) inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t { // 2361183241434822607 = ceil(2^(64+7)/1000) return umul128_upper64(n, 2361183241434822607ull) >> 7; } // Various subroutines using pow10 cache template struct cache_accessor; template <> struct cache_accessor { using carrier_uint = float_info::carrier_uint; using cache_entry_type = uint64_t; static auto get_cached_power(int k) noexcept -> uint64_t { FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, "k is out of range"); static constexpr uint64_t pow10_significands[] = { 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff, 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; return pow10_significands[k - float_info::min_k]; } struct compute_mul_result { carrier_uint result; bool is_integer; }; struct compute_mul_parity_result { bool parity; bool is_integer; }; static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result { auto r = umul96_upper64(u, cache); return {static_cast(r >> 32), static_cast(r) == 0}; } static auto compute_delta(const cache_entry_type& cache, int beta) noexcept -> uint32_t { return static_cast(cache >> (64 - 1 - beta)); } static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul96_lower64(two_f, cache); return {((r >> (64 - beta)) & 1) != 0, static_cast(r >> (32 - beta)) == 0}; } static auto compute_left_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast( (cache - (cache >> (num_significand_bits() + 2))) >> (64 - num_significand_bits() - 1 - beta)); } static auto compute_right_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return static_cast( (cache + (cache >> (num_significand_bits() + 1))) >> (64 - num_significand_bits() - 1 - beta)); } static auto compute_round_up_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (static_cast( cache >> (64 - num_significand_bits() - 2 - beta)) + 1) / 2; } }; template <> struct cache_accessor { using carrier_uint = float_info::carrier_uint; using cache_entry_type = uint128_fallback; static auto get_cached_power(int k) noexcept -> uint128_fallback { FMT_ASSERT(k >= float_info::min_k && k <= float_info::max_k, "k is out of range"); static constexpr uint128_fallback pow10_significands[] = { #if FMT_USE_FULL_CACHE_DRAGONBOX {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0x9faacf3df73609b1, 0x77b191618c54e9ad}, {0xc795830d75038c1d, 0xd59df5b9ef6a2418}, {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e}, {0x9becce62836ac577, 0x4ee367f9430aec33}, {0xc2e801fb244576d5, 0x229c41f793cda740}, {0xf3a20279ed56d48a, 0x6b43527578c11110}, {0x9845418c345644d6, 0x830a13896b78aaaa}, {0xbe5691ef416bd60c, 0x23cc986bc656d554}, {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9}, {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa}, {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54}, {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69}, {0x91376c36d99995be, 0x23100809b9c21fa2}, {0xb58547448ffffb2d, 0xabd40a0c2832a78b}, {0xe2e69915b3fff9f9, 0x16c90c8f323f516d}, {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4}, {0xb1442798f49ffb4a, 0x99cd11cfdf41779d}, {0xdd95317f31c7fa1d, 0x40405643d711d584}, {0x8a7d3eef7f1cfc52, 0x482835ea666b2573}, {0xad1c8eab5ee43b66, 0xda3243650005eed0}, {0xd863b256369d4a40, 0x90bed43e40076a83}, {0x873e4f75e2224e68, 0x5a7744a6e804a292}, {0xa90de3535aaae202, 0x711515d0a205cb37}, {0xd3515c2831559a83, 0x0d5a5b44ca873e04}, {0x8412d9991ed58091, 0xe858790afe9486c3}, {0xa5178fff668ae0b6, 0x626e974dbe39a873}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a}, {0xa139029f6a239f72, 0x1c1fffc1ebc44e81}, {0xc987434744ac874e, 0xa327ffb266b56221}, {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9}, {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa}, {0xc4ce17b399107c22, 0xcb550fb4384d21d4}, {0xf6019da07f549b2b, 0x7e2a53a146606a49}, {0x99c102844f94e0fb, 0x2eda7444cbfc426e}, {0xc0314325637a1939, 0xfa911155fefb5309}, {0xf03d93eebc589f88, 0x793555ab7eba27cb}, {0x96267c7535b763b5, 0x4bc1558b2f3458df}, {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17}, {0xea9c227723ee8bcb, 0x465e15a979c1cadd}, {0x92a1958a7675175f, 0x0bfacd89ec191eca}, {0xb749faed14125d36, 0xcef980ec671f667c}, {0xe51c79a85916f484, 0x82b7e12780e7401b}, {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811}, {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16}, {0xdfbdcece67006ac9, 0x67a791e093e1d49b}, {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1}, {0xaecc49914078536d, 0x58fae9f773886e19}, {0xda7f5bf590966848, 0xaf39a475506a899f}, {0x888f99797a5e012d, 0x6d8406c952429604}, {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84}, {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65}, {0x855c3be0a17fcd26, 0x5cf2eea09a550680}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0xd0601d8efc57b08b, 0xf13b94daf124da27}, {0x823c12795db6ce57, 0x76c53d08d6b70859}, {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f}, {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a}, {0xfe5d54150b090b02, 0xd3f93b35435d7c4d}, {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0}, {0xc6b8e9b0709f109a, 0x359ab6419ca1091c}, {0xf867241c8cc6d4c0, 0xc30163d203c94b63}, {0x9b407691d7fc44f8, 0x79e0de63425dcf1e}, {0xc21094364dfb5636, 0x985915fc12f542e5}, {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e}, {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43}, {0xbd8430bd08277231, 0x50c6ff782a838354}, {0xece53cec4a314ebd, 0xa4f8bf5635246429}, {0x940f4613ae5ed136, 0x871b7795e136be9a}, {0xb913179899f68584, 0x28e2557b59846e40}, {0xe757dd7ec07426e5, 0x331aeada2fe589d0}, {0x9096ea6f3848984f, 0x3ff0d2c85def7622}, {0xb4bca50b065abe63, 0x0fed077a756b53aa}, {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895}, {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d}, {0xb080392cc4349dec, 0xbd8d794d96aacfb4}, {0xdca04777f541c567, 0xecf0d7a0fc5583a1}, {0x89e42caaf9491b60, 0xf41686c49db57245}, {0xac5d37d5b79b6239, 0x311c2875c522ced6}, {0xd77485cb25823ac7, 0x7d633293366b828c}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xa8530886b54dbdeb, 0xd9f57f830283fdfd}, {0xd267caa862a12d66, 0xd072df63c324fd7c}, {0x8380dea93da4bc60, 0x4247cb9e59f71e6e}, {0xa46116538d0deb78, 0x52d9be85f074e609}, {0xcd795be870516656, 0x67902e276c921f8c}, {0x806bd9714632dff6, 0x00ba1cd8a3db53b7}, {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5}, {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce}, {0xfad2a4b13d1b5d6c, 0x796b805720085f82}, {0x9cc3a6eec6311a63, 0xcbe3303674053bb1}, {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d}, {0xf4f1b4d515acb93b, 0xee92fb5515482d45}, {0x991711052d8bf3c5, 0x751bdd152d4d1c4b}, {0xbf5cd54678eef0b6, 0xd262d45a78a0635e}, {0xef340a98172aace4, 0x86fb897116c87c35}, {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1}, {0xbae0a846d2195712, 0x8974836059cca10a}, {0xe998d258869facd7, 0x2bd1a438703fc94c}, {0x91ff83775423cc06, 0x7b6306a34627ddd0}, {0xb67f6455292cbf08, 0x1a3bc84c17b1d543}, {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94}, {0x8e938662882af53e, 0x547eb47b7282ee9d}, {0xb23867fb2a35b28d, 0xe99e619a4f23aa44}, {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5}, {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05}, {0xae0b158b4738705e, 0x9624ab50b148d446}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7}, {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d}, {0xd47487cc8470652b, 0x7647c32000696720}, {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074}, {0xa5fb0a17c777cf09, 0xf468107100525891}, {0xcf79cc9db955c2cc, 0x7182148d4066eeb5}, {0x81ac1fe293d599bf, 0xc6f14cd848405531}, {0xa21727db38cb002f, 0xb8ada00e5a506a7d}, {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d}, {0xfd442e4688bd304a, 0x908f4a166d1da664}, {0x9e4a9cec15763e2e, 0x9a598e4e043287ff}, {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe}, {0xf7549530e188c128, 0xd12bee59e68ef47d}, {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf}, {0xc13a148e3032d6e7, 0xe36a52363c1faf02}, {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2}, {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba}, {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8}, {0xebdf661791d60f56, 0x111b495b3464ad22}, {0x936b9fcebb25c995, 0xcab10dd900beec35}, {0xb84687c269ef3bfb, 0x3d5d514f40eea743}, {0xe65829b3046b0afa, 0x0cb4a5a3112a5113}, {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac}, {0xb3f4e093db73a093, 0x59ed216765690f57}, {0xe0f218b8d25088b8, 0x306869c13ec3532d}, {0x8c974f7383725573, 0x1e414218c73a13fc}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0xdbac6c247d62a583, 0xdf45f746b74abf3a}, {0x894bc396ce5da772, 0x6b8bba8c328eb784}, {0xab9eb47c81f5114f, 0x066ea92f3f326565}, {0xd686619ba27255a2, 0xc80a537b0efefebe}, {0x8613fd0145877585, 0xbd06742ce95f5f37}, {0xa798fc4196e952e7, 0x2c48113823b73705}, {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6}, {0x82ef85133de648c4, 0x9a984d73dbe722fc}, {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb}, {0xcc963fee10b7d1b3, 0x318df905079926a9}, {0xffbbcfe994e5c61f, 0xfdf17746497f7053}, {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634}, {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1}, {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1}, {0x9c1661a651213e2d, 0x06bea10ca65c084f}, {0xc31bfa0fe5698db8, 0x486e494fcff30a63}, {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb}, {0x986ddb5c6b3a76b7, 0xf89629465a75e01d}, {0xbe89523386091465, 0xf6bbb397f1135824}, {0xee2ba6c0678b597f, 0x746aa07ded582e2d}, {0x94db483840b717ef, 0xa8c2a44eb4571cdd}, {0xba121a4650e4ddeb, 0x92f34d62616ce414}, {0xe896a0d7e51e1566, 0x77b020baf9c81d18}, {0x915e2486ef32cd60, 0x0ace1474dc1d122f}, {0xb5b5ada8aaff80b8, 0x0d819992132456bb}, {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3}, {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf}, {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c}, {0xad4ab7112eb3929d, 0x86c16c98d2c953c7}, {0xd89d64d57a607744, 0xe871c7bf077ba8b8}, {0x87625f056c7c4a8b, 0x11471cd764ad4973}, {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0}, {0xd389b47879823479, 0x4aff1d108d4ec2c4}, {0x843610cb4bf160cb, 0xcedf722a585139bb}, {0xa54394fe1eedb8fe, 0xc2974eb4ee658829}, {0xce947a3da6a9273e, 0x733d226229feea33}, {0x811ccc668829b887, 0x0806357d5a3f5260}, {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8}, {0xc9bcff6034c13052, 0xfc89b393dd02f0b6}, {0xfc2c3f3841f17c67, 0xbbac2078d443ace3}, {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e}, {0xc5029163f384a931, 0x0a9e795e65d4df12}, {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6}, {0x99ea0196163fa42e, 0x504bced1bf8e4e46}, {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7}, {0xf07da27a82c37088, 0x5d767327bb4e5a4d}, {0x964e858c91ba2655, 0x3a6a07f8d510f870}, {0xbbe226efb628afea, 0x890489f70a55368c}, {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f}, {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e}, {0xb77ada0617e3bbcb, 0x09ce6ebb40173745}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0x8f57fa54c2a9eab6, 0x9fa946824a12232e}, {0xb32df8e9f3546564, 0x47939822dc96abfa}, {0xdff9772470297ebd, 0x59787e2b93bc56f8}, {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b}, {0xaefae51477a06b03, 0xede622920b6b23f2}, {0xdab99e59958885c4, 0xe95fab368e45ecee}, {0x88b402f7fd75539b, 0x11dbcb0218ebb415}, {0xaae103b5fcd2a881, 0xd652bdc29f26a11a}, {0xd59944a37c0752a2, 0x4be76d3346f04960}, {0x857fcae62d8493a5, 0x6f70a4400c562ddc}, {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953}, {0xd097ad07a71f26b2, 0x7e2000a41346a7a8}, {0x825ecc24c873782f, 0x8ed400668c0c28c9}, {0xa2f67f2dfa90563b, 0x728900802f0f32fb}, {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba}, {0xfea126b7d78186bc, 0xe2f610c84987bfa9}, {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca}, {0xc6ede63fa05d3143, 0x91503d1c79720dbc}, {0xf8a95fcf88747d94, 0x75a44c6397ce912b}, {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb}, {0xc24452da229b021b, 0xfbe85badce996169}, {0xf2d56790ab41c2a2, 0xfae27299423fb9c4}, {0x97c560ba6b0919a5, 0xdccd879fc967d41b}, {0xbdb6b8e905cb600f, 0x5400e987bbc1c921}, {0xed246723473e3813, 0x290123e9aab23b69}, {0x9436c0760c86e30b, 0xf9a0b6720aaf6522}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0xe7958cb87392c2c2, 0xb60b1d1230b20e05}, {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3}, {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4}, {0xe2280b6c20dd5232, 0x25c6da63c38de1b1}, {0x8d590723948a535f, 0x579c487e5a38ad0f}, {0xb0af48ec79ace837, 0x2d835a9df0c6d852}, {0xdcdb1b2798182244, 0xf8e431456cf88e66}, {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900}, {0xac8b2d36eed2dac5, 0xe272467e3d222f40}, {0xd7adf884aa879177, 0x5b0ed81dcc6abb10}, {0x86ccbb52ea94baea, 0x98e947129fc2b4ea}, {0xa87fea27a539e9a5, 0x3f2398d747b36225}, {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae}, {0x83a3eeeef9153e89, 0x1953cf68300424ad}, {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8}, {0xcdb02555653131b6, 0x3792f412cb06794e}, {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1}, {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5}, {0xc8de047564d20a8b, 0xf245825a5a445276}, {0xfb158592be068d2e, 0xeed6e2f0f0d56713}, {0x9ced737bb6c4183d, 0x55464dd69685606c}, {0xc428d05aa4751e4c, 0xaa97e14c3c26b887}, {0xf53304714d9265df, 0xd53dd99f4b3066a9}, {0x993fe2c6d07b7fab, 0xe546a8038efe402a}, {0xbf8fdb78849a5f96, 0xde98520472bdd034}, {0xef73d256a5c0f77c, 0x963e66858f6d4441}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xbb127c53b17ec159, 0x5560c018580d5d53}, {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7}, {0x9226712162ab070d, 0xcab3961304ca70e9}, {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23}, {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b}, {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243}, {0xb267ed1940f1c61c, 0x55f038b237591ed4}, {0xdf01e85f912e37a3, 0x6b6c46dec52f6689}, {0x8b61313bbabce2c6, 0x2323ac4b3b3da016}, {0xae397d8aa96c1b77, 0xabec975e0a0d081b}, {0xd9c7dced53c72255, 0x96e7bd358c904a22}, {0x881cea14545c7575, 0x7e50d64177da2e55}, {0xaa242499697392d2, 0xdde50bd1d5d0b9ea}, {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865}, {0x84ec3c97da624ab4, 0xbd5af13bef0b113f}, {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f}, {0xcfb11ead453994ba, 0x67de18eda5814af3}, {0x81ceb32c4b43fcf4, 0x80eacf948770ced8}, {0xa2425ff75e14fc31, 0xa1258379a94d028e}, {0xcad2f7f5359a3b3e, 0x096ee45813a04331}, {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd}, {0x9e74d1b791e07e48, 0x775ea264cf55347e}, {0xc612062576589dda, 0x95364afe032a819e}, {0xf79687aed3eec551, 0x3a83ddbd83f52205}, {0x9abe14cd44753b52, 0xc4926a9672793543}, {0xc16d9a0095928a27, 0x75b7053c0f178294}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0x971da05074da7bee, 0xd3f6fc16ebca5e04}, {0xbce5086492111aea, 0x88f4bb1ca6bcf585}, {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6}, {0x9392ee8e921d5d07, 0x3aff322e62439fd0}, {0xb877aa3236a4b449, 0x09befeb9fad487c3}, {0xe69594bec44de15b, 0x4c2ebe687989a9b4}, {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11}, {0xb424dc35095cd80f, 0x538484c19ef38c95}, {0xe12e13424bb40e13, 0x2865a5f206b06fba}, {0x8cbccc096f5088cb, 0xf93f87b7442e45d4}, {0xafebff0bcb24aafe, 0xf78f69a51539d749}, {0xdbe6fecebdedd5be, 0xb573440e5a884d1c}, {0x89705f4136b4a597, 0x31680a88f8953031}, {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e}, {0xd6bf94d5e57a42bc, 0x3d32907604691b4d}, {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110}, {0xa7c5ac471b478423, 0x0fcf80dc33721d54}, {0xd1b71758e219652b, 0xd3c36113404ea4a9}, {0x83126e978d4fdf3b, 0x645a1cac083126ea}, {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4}, {0xcccccccccccccccc, 0xcccccccccccccccd}, {0x8000000000000000, 0x0000000000000000}, {0xa000000000000000, 0x0000000000000000}, {0xc800000000000000, 0x0000000000000000}, {0xfa00000000000000, 0x0000000000000000}, {0x9c40000000000000, 0x0000000000000000}, {0xc350000000000000, 0x0000000000000000}, {0xf424000000000000, 0x0000000000000000}, {0x9896800000000000, 0x0000000000000000}, {0xbebc200000000000, 0x0000000000000000}, {0xee6b280000000000, 0x0000000000000000}, {0x9502f90000000000, 0x0000000000000000}, {0xba43b74000000000, 0x0000000000000000}, {0xe8d4a51000000000, 0x0000000000000000}, {0x9184e72a00000000, 0x0000000000000000}, {0xb5e620f480000000, 0x0000000000000000}, {0xe35fa931a0000000, 0x0000000000000000}, {0x8e1bc9bf04000000, 0x0000000000000000}, {0xb1a2bc2ec5000000, 0x0000000000000000}, {0xde0b6b3a76400000, 0x0000000000000000}, {0x8ac7230489e80000, 0x0000000000000000}, {0xad78ebc5ac620000, 0x0000000000000000}, {0xd8d726b7177a8000, 0x0000000000000000}, {0x878678326eac9000, 0x0000000000000000}, {0xa968163f0a57b400, 0x0000000000000000}, {0xd3c21bcecceda100, 0x0000000000000000}, {0x84595161401484a0, 0x0000000000000000}, {0xa56fa5b99019a5c8, 0x0000000000000000}, {0xcecb8f27f4200f3a, 0x0000000000000000}, {0x813f3978f8940984, 0x4000000000000000}, {0xa18f07d736b90be5, 0x5000000000000000}, {0xc9f2c9cd04674ede, 0xa400000000000000}, {0xfc6f7c4045812296, 0x4d00000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xc5371912364ce305, 0x6c28000000000000}, {0xf684df56c3e01bc6, 0xc732000000000000}, {0x9a130b963a6c115c, 0x3c7f400000000000}, {0xc097ce7bc90715b3, 0x4b9f100000000000}, {0xf0bdc21abb48db20, 0x1e86d40000000000}, {0x96769950b50d88f4, 0x1314448000000000}, {0xbc143fa4e250eb31, 0x17d955a000000000}, {0xeb194f8e1ae525fd, 0x5dcfab0800000000}, {0x92efd1b8d0cf37be, 0x5aa1cae500000000}, {0xb7abc627050305ad, 0xf14a3d9e40000000}, {0xe596b7b0c643c719, 0x6d9ccd05d0000000}, {0x8f7e32ce7bea5c6f, 0xe4820023a2000000}, {0xb35dbf821ae4f38b, 0xdda2802c8a800000}, {0xe0352f62a19e306e, 0xd50b2037ad200000}, {0x8c213d9da502de45, 0x4526f422cc340000}, {0xaf298d050e4395d6, 0x9670b12b7f410000}, {0xdaf3f04651d47b4c, 0x3c0cdd765f114000}, {0x88d8762bf324cd0f, 0xa5880a69fb6ac800}, {0xab0e93b6efee0053, 0x8eea0d047a457a00}, {0xd5d238a4abe98068, 0x72a4904598d6d880}, {0x85a36366eb71f041, 0x47a6da2b7f864750}, {0xa70c3c40a64e6c51, 0x999090b65f67d924}, {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d}, {0x82818f1281ed449f, 0xbff8f10e7a8921a5}, {0xa321f2d7226895c7, 0xaff72d52192b6a0e}, {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0x9f4f2726179a2245, 0x01d762422c946591}, {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6}, {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3}, {0x9b934c3b330c8577, 0x63cc55f49f88eb30}, {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc}, {0xf316271c7fc3908a, 0x8bef464e3945ef7b}, {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad}, {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318}, {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde}, {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b}, {0xb975d6b6ee39e436, 0xb3e2fd538e122b45}, {0xe7d34c64a9c85d44, 0x60dbbca87196b617}, {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce}, {0xb51d13aea4a488dd, 0x6babab6398bdbe42}, {0xe264589a4dcdab14, 0xc696963c7eed2dd2}, {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3}, {0xb0de65388cc8ada8, 0x3b25a55f43294bcc}, {0xdd15fe86affad912, 0x49ef0eb713f39ebf}, {0x8a2dbf142dfcc7ab, 0x6e3569326c784338}, {0xacb92ed9397bf996, 0x49c2c37f07965405}, {0xd7e77a8f87daf7fb, 0xdc33745ec97be907}, {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4}, {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d}, {0xd2d80db02aabd62b, 0xf50a3fa490c30191}, {0x83c7088e1aab65db, 0x792667c6da79e0fb}, {0xa4b8cab1a1563f52, 0x577001b891185939}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0x80b05e5ac60b6178, 0x544f8158315b05b5}, {0xa0dc75f1778e39d6, 0x696361ae3db1c722}, {0xc913936dd571c84c, 0x03bc3a19cd1e38ea}, {0xfb5878494ace3a5f, 0x04ab48a04065c724}, {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77}, {0xc45d1df942711d9a, 0x3ba5d0bd324f8395}, {0xf5746577930d6500, 0xca8f44ec7ee3647a}, {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc}, {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f}, {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f}, {0x95d04aee3b80ece5, 0xbba1f1d158724a13}, {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98}, {0xea1575143cf97226, 0xf52d09d71a3293be}, {0x924d692ca61be758, 0x593c2626705f9c57}, {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d}, {0xe498f455c38b997a, 0x0b6dfb9c0f956448}, {0x8edf98b59a373fec, 0x4724bd4189bd5ead}, {0xb2977ee300c50fe7, 0x58edec91ec2cb658}, {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee}, {0x8b865b215899f46c, 0xbd79e0d20082ee75}, {0xae67f1e9aec07187, 0xecd8590680a3aa12}, {0xda01ee641a708de9, 0xe80e6f4820cc9496}, {0x884134fe908658b2, 0x3109058d147fdcde}, {0xaa51823e34a7eede, 0xbd4b46f0599fd416}, {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b}, {0x850fadc09923329e, 0x03e2cf6bc604ddb1}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0xcfe87f7cef46ff16, 0xe612641865679a64}, {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f}, {0xa26da3999aef7749, 0xe3be5e330f38f09e}, {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6}, {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7}, {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb}, {0xc646d63501a1511d, 0xb281e1fd541501b9}, {0xf7d88bc24209a565, 0x1f225a7ca91a4227}, {0x9ae757596946075f, 0x3375788de9b06959}, {0xc1a12d2fc3978937, 0x0052d6b1641c83af}, {0xf209787bb47d6b84, 0xc0678c5dbd23a49b}, {0x9745eb4d50ce6332, 0xf840b7ba963646e1}, {0xbd176620a501fbff, 0xb650e5a93bc3d899}, {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf}, {0x93ba47c980e98cdf, 0xc66f336c36b10138}, {0xb8a8d9bbe123f017, 0xb80b0047445d4185}, {0xe6d3102ad96cec1d, 0xa60dc059157491e6}, {0x9043ea1ac7e41392, 0x87c89837ad68db30}, {0xb454e4a179dd1877, 0x29babe4598c311fc}, {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b}, {0x8ce2529e2734bb1d, 0x1899e4a65f58660d}, {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90}, {0xdc21a1171d42645d, 0x76707543f4fa1f74}, {0x899504ae72497eba, 0x6a06494a791c53a9}, {0xabfa45da0edbde69, 0x0487db9d17636893}, {0xd6f8d7509292d603, 0x45a9d2845d3c42b7}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xa7f26836f282b732, 0x8e6cac7768d7141f}, {0xd1ef0244af2364ff, 0x3207d795430cd927}, {0x8335616aed761f1f, 0x7f44e6bd49e807b9}, {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7}, {0xcd036837130890a1, 0x36dba887c37a8c10}, {0x802221226be55a64, 0xc2494954da2c978a}, {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d}, {0xc83553c5c8965d3d, 0x6f92829494e5acc8}, {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa}, {0x9c69a97284b578d7, 0xff2a760414536efc}, {0xc38413cf25e2d70d, 0xfef5138519684abb}, {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a}, {0x98bf2f79d5993802, 0xef2f773ffbd97a62}, {0xbeeefb584aff8603, 0xaafb550ffacfd8fb}, {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39}, {0x952ab45cfa97a0b2, 0xdd945a747bf26184}, {0xba756174393d88df, 0x94f971119aeef9e5}, {0xe912b9d1478ceb17, 0x7a37cd5601aab85e}, {0x91abb422ccb812ee, 0xac62e055c10ab33b}, {0xb616a12b7fe617aa, 0x577b986b314d600a}, {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c}, {0x8e41ade9fbebc27d, 0x14588f13be847308}, {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9}, {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc}, {0x8aec23d680043bee, 0x25de7bb9480d5855}, {0xada72ccc20054ae9, 0xaf561aa79a10ae6b}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0x87aa9aff79042286, 0x90fb44d2f05d0843}, {0xa99541bf57452b28, 0x353a1607ac744a54}, {0xd3fa922f2d1675f2, 0x42889b8997915ce9}, {0x847c9b5d7c2e09b7, 0x69956135febada12}, {0xa59bc234db398c25, 0x43fab9837e699096}, {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc}, {0x8161afb94b44f57d, 0x1d1be0eebac278f6}, {0xa1ba1ba79e1632dc, 0x6462d92a69731733}, {0xca28a291859bbf93, 0x7d7b8f7503cfdcff}, {0xfcb2cb35e702af78, 0x5cda735244c3d43f}, {0x9defbf01b061adab, 0x3a0888136afa64a8}, {0xc56baec21c7a1916, 0x088aaa1845b8fdd1}, {0xf6c69a72a3989f5b, 0x8aad549e57273d46}, {0x9a3c2087a63f6399, 0x36ac54e2f678864c}, {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de}, {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6}, {0x969eb7c47859e743, 0x9f644ae5a4b1b326}, {0xbc4665b596706114, 0x873d5d9f0dde1fef}, {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb}, {0x9316ff75dd87cbd8, 0x09a7f12442d588f3}, {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30}, {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb}, {0x8fa475791a569d10, 0xf96e017d694487bd}, {0xb38d92d760ec4455, 0x37c981dcc395a9ad}, {0xe070f78d3927556a, 0x85bbe253f47b1418}, {0x8c469ab843b89562, 0x93956d7478ccec8f}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f}, {0x88fcf317f22241e2, 0x441fece3bdf81f04}, {0xab3c2fddeeaad25a, 0xd527e81cad7626c4}, {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075}, {0x85c7056562757456, 0xf6872d5667844e4a}, {0xa738c6bebb12d16c, 0xb428f8ac016561dc}, {0xd106f86e69d785c7, 0xe13336d701beba53}, {0x82a45b450226b39c, 0xecc0024661173474}, {0xa34d721642b06084, 0x27f002d7f95d0191}, {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5}, {0xff290242c83396ce, 0x7e67047175a15272}, {0x9f79a169bd203e41, 0x0f0062c6e984d387}, {0xc75809c42c684dd1, 0x52c07b78a3e60869}, {0xf92e0c3537826145, 0xa7709a56ccdf8a83}, {0x9bbcc7a142b17ccb, 0x88a66076400bb692}, {0xc2abf989935ddbfe, 0x6acff893d00ea436}, {0xf356f7ebf83552fe, 0x0583f6b8c4124d44}, {0x98165af37b2153de, 0xc3727a337a8b704b}, {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d}, {0xeda2ee1c7064130c, 0x1162def06f79df74}, {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9}, {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693}, {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438}, {0x910ab1d4db9914a0, 0x1d9c9892400a22a3}, {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c}, {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xb10d8e1456105dad, 0x7425a83e872c5f48}, {0xdd50f1996b947518, 0xd12f124e28f7771a}, {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70}, {0xace73cbfdc0bfb7b, 0x636cc64d1001550c}, {0xd8210befd30efa5a, 0x3c47f7e05401aa4f}, {0x8714a775e3e95c78, 0x65acfaec34810a72}, {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e}, {0xd31045a8341ca07c, 0x1ede48111209a051}, {0x83ea2b892091e44d, 0x934aed0aab460433}, {0xa4e4b66b68b65d60, 0xf81da84d56178540}, {0xce1de40642e3f4b9, 0x36251260ab9d668f}, {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a}, {0xa1075a24e4421730, 0xb24cf65b8612f820}, {0xc94930ae1d529cfc, 0xdee033f26797b628}, {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2}, {0x9d412e0806e88aa5, 0x8e1f289560ee864f}, {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3}, {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc}, {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a}, {0xbff610b0cc6edd3f, 0x17fd090a58d32af4}, {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1}, {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f}, {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2}, {0xea53df5fd18d5513, 0x84c86189216dc5ee}, {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5}, {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f}, {0xb2c71d5bca9023f8, 0x743e20e9ef511013}, {0xdf78e4b2bd342cf6, 0x914da9246b255417}, {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f}, {0xae9672aba3d0c320, 0xa184ac2473b529b2}, {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f}, {0x8865899617fb1871, 0x7e2fa67c7a658893}, {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8}, {0xd51ea6fa85785631, 0x552a74227f3ea566}, {0x8533285c936b35de, 0xd53a88958f872760}, {0xa67ff273b8460356, 0x8a892abaf368f138}, {0xd01fef10a657842c, 0x2d2b7569b0432d86}, {0x8213f56a67f6b29b, 0x9c3b29620e29fc74}, {0xa298f2c501f45f42, 0x8349f3ba91b47b90}, {0xcb3f2f7642717713, 0x241c70a936219a74}, {0xfe0efb53d30dd4d7, 0xed238cd383aa0111}, {0x9ec95d1463e8a506, 0xf4363804324a40ab}, {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6}, {0xf81aa16fdc1b81da, 0xdd94b7868e94050b}, {0x9b10a4e5e9913128, 0xca7cf2b4191c8327}, {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1}, {0xf24a01a73cf2dccf, 0xbc633b39673c8ced}, {0x976e41088617ca01, 0xd5be0503e085d814}, {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19}, {0xec9c459d51852ba2, 0xddf8e7d60ed1219f}, {0x93e1ab8252f33b45, 0xcabb90e5c942b504}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0xe7109bfba19c0c9d, 0x0cc512670a783ad5}, {0x906a617d450187e2, 0x27fb2b80668b24c6}, {0xb484f9dc9641e9da, 0xb1f9f660802dedf7}, {0xe1a63853bbd26451, 0x5e7873f8a0396974}, {0x8d07e33455637eb2, 0xdb0b487b6423e1e9}, {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63}, {0xdc5c5301c56b75f7, 0x7641a140cc7810fc}, {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e}, {0xac2820d9623bf429, 0x546345fa9fbdcd45}, {0xd732290fbacaf133, 0xa97c177947ad4096}, {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e}, {0xa81f301449ee8c70, 0x5c68f256bfff5a75}, {0xd226fc195c6a2f8c, 0x73832eec6fff3112}, {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac}, {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56}, {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec}, {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4}, {0xa0555e361951c366, 0xd7e105bcc3326220}, {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8}, {0xfa856334878fc150, 0xb14f98f6f0feb952}, {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4}, {0xc3b8358109e84f07, 0x0a862f80ec4700c9}, {0xf4a642e14c6262c8, 0xcd27bb612758c0fb}, {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d}, {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4}, {0xeeea5d5004981478, 0x1858ccfce06cac75}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xbaa718e68396cffd, 0xd30560258f54e6bb}, {0xe950df20247c83fd, 0x47c6b82ef32a206a}, {0x91d28b7416cdd27e, 0x4cdc331d57fa5442}, {0xb6472e511c81471d, 0xe0133fe4adf8e953}, {0xe3d8f9e563a198e5, 0x58180fddd97723a7}, {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649}, {0xb201833b35d63f73, 0x2cd2cc6551e513db}, {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2}, {0x8b112e86420f6191, 0xfb04afaf27faf783}, {0xadd57a27d29339f6, 0x79c5db9af1f9b564}, {0xd94ad8b1c7380874, 0x18375281ae7822bd}, {0x87cec76f1c830548, 0x8f2293910d0b15b6}, {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23}, {0xd433179d9c8cb841, 0x5fa60692a46151ec}, {0x849feec281d7f328, 0xdbc7c41ba6bcd334}, {0xa5c7ea73224deff3, 0x12b9b522906c0801}, {0xcf39e50feae16bef, 0xd768226b34870a01}, {0x81842f29f2cce375, 0xe6a1158300d46641}, {0xa1e53af46f801c53, 0x60495ae3c1097fd1}, {0xca5e89b18b602368, 0x385bb19cb14bdfc5}, {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6}, {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2}, {0xc5a05277621be293, 0xc7098b7305241886}, {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8}, {0x9a65406d44a5c903, 0x737f74f1dc043329}, {0xc0fe908895cf3b44, 0x505f522e53053ff3}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0}, {0x96c6e0eab509e64d, 0x5eca783430dc19f6}, {0xbc789925624c5fe0, 0xb67d16413d132073}, {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890}, {0x933e37a534cbaae7, 0x8e91b962f7b6f15a}, {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1}, {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d}, {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2}, {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e}, {0xe0accfa875af45a7, 0x93eb1b80a33b8606}, {0x8c6c01c9498d8b88, 0xbc72f130660533c4}, {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5}, {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2}, #else {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b}, {0xce5d73ff402d98e3, 0xfb0a3d212dc81290}, {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f}, {0x86a8d39ef77164bc, 0xae5dff9c02033198}, {0xd98ddaee19068c76, 0x3badd624dd9b0958}, {0xafbd2350644eeacf, 0xe5d1929ef90898fb}, {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2}, {0xe55990879ddcaabd, 0xcc420a6a101d0516}, {0xb94470938fa89bce, 0xf808e40e8d5b3e6a}, {0x95a8637627989aad, 0xdde7001379a44aa9}, {0xf1c90080baf72cb1, 0x5324c68b12dd6339}, {0xc350000000000000, 0x0000000000000000}, {0x9dc5ada82b70b59d, 0xf020000000000000}, {0xfee50b7025c36a08, 0x02f236d04753d5b5}, {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87}, {0xa6539930bf6bff45, 0x84db8346b786151d}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3}, {0xd910f7ff28069da4, 0x1b2ba1518094da05}, {0xaf58416654a6babb, 0x387ac8d1970027b3}, {0x8da471a9de737e24, 0x5ceaecfed289e5d3}, {0xe4d5e82392a40515, 0x0fabaf3feaa5334b}, {0xb8da1662e7b00a17, 0x3d6a751f3b936244}, {0x95527a5202df0ccb, 0x0f37801e0c43ebc9}, {0xf13e34aabb430a15, 0x647726b9e7c68ff0} #endif }; #if FMT_USE_FULL_CACHE_DRAGONBOX return pow10_significands[k - float_info::min_k]; #else static constexpr uint64_t powers_of_5_64[] = { 0x0000000000000001, 0x0000000000000005, 0x0000000000000019, 0x000000000000007d, 0x0000000000000271, 0x0000000000000c35, 0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1, 0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd, 0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9, 0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5, 0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631, 0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed, 0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9}; static const int compression_ratio = 27; // Compute base index. int cache_index = (k - float_info::min_k) / compression_ratio; int kb = cache_index * compression_ratio + float_info::min_k; int offset = k - kb; // Get base cache. uint128_fallback base_cache = pow10_significands[cache_index]; if (offset == 0) return base_cache; // Compute the required amount of bit-shift. int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset; FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected"); // Try to recover the real cache. uint64_t pow5 = powers_of_5_64[offset]; uint128_fallback recovered_cache = umul128(base_cache.high(), pow5); uint128_fallback middle_low = umul128(base_cache.low(), pow5); recovered_cache += middle_low.high(); uint64_t high_to_middle = recovered_cache.high() << (64 - alpha); uint64_t middle_to_low = recovered_cache.low() << (64 - alpha); recovered_cache = uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle, ((middle_low.low() >> alpha) | middle_to_low)}; FMT_ASSERT(recovered_cache.low() + 1 != 0, ""); return {recovered_cache.high(), recovered_cache.low() + 1}; #endif } struct compute_mul_result { carrier_uint result; bool is_integer; }; struct compute_mul_parity_result { bool parity; bool is_integer; }; static auto compute_mul(carrier_uint u, const cache_entry_type& cache) noexcept -> compute_mul_result { auto r = umul192_upper128(u, cache); return {r.high(), r.low() == 0}; } static auto compute_delta(const cache_entry_type& cache, int beta) noexcept -> uint32_t { return static_cast(cache.high() >> (64 - 1 - beta)); } static auto compute_mul_parity(carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept -> compute_mul_parity_result { FMT_ASSERT(beta >= 1, ""); FMT_ASSERT(beta < 64, ""); auto r = umul192_lower128(two_f, cache); return {((r.high() >> (64 - beta)) & 1) != 0, ((r.high() << beta) | (r.low() >> (64 - beta))) == 0}; } static auto compute_left_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() - (cache.high() >> (num_significand_bits() + 2))) >> (64 - num_significand_bits() - 1 - beta); } static auto compute_right_endpoint_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return (cache.high() + (cache.high() >> (num_significand_bits() + 1))) >> (64 - num_significand_bits() - 1 - beta); } static auto compute_round_up_for_shorter_interval_case( const cache_entry_type& cache, int beta) noexcept -> carrier_uint { return ((cache.high() >> (64 - num_significand_bits() - 2 - beta)) + 1) / 2; } }; FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback { return cache_accessor::get_cached_power(k); } // Various integer checks template auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool { const int case_shorter_interval_left_endpoint_lower_threshold = 2; const int case_shorter_interval_left_endpoint_upper_threshold = 3; return exponent >= case_shorter_interval_left_endpoint_lower_threshold && exponent <= case_shorter_interval_left_endpoint_upper_threshold; } // Remove trailing zeros from n and return the number of zeros removed (float). FMT_INLINE auto remove_trailing_zeros(uint32_t& n, int s = 0) noexcept -> int { FMT_ASSERT(n != 0, ""); // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1. constexpr uint32_t mod_inv_5 = 0xcccccccd; constexpr uint32_t mod_inv_25 = 0xc28f5c29; // = mod_inv_5 * mod_inv_5 while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value() / 100) break; n = q; s += 2; } auto q = rotr(n * mod_inv_5, 1); if (q <= max_value() / 10) { n = q; s |= 1; } return s; } // Removes trailing zeros and returns the number of zeros removed (double). FMT_INLINE auto remove_trailing_zeros(uint64_t& n) noexcept -> int { FMT_ASSERT(n != 0, ""); // Is n is divisible by 10^8? constexpr uint32_t ten_pow_8 = 100000000u; if ((n % ten_pow_8) == 0) { // If yes, work with the quotient... auto n32 = static_cast(n / ten_pow_8); // ... and use the 32 bit variant of the function int num_zeros = remove_trailing_zeros(n32, 8); n = n32; return num_zeros; } // If n is not divisible by 10^8, work with n itself. constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd; constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29; // mod_inv_5 * mod_inv_5 int s = 0; while (true) { auto q = rotr(n * mod_inv_25, 2); if (q > max_value() / 100) break; n = q; s += 2; } auto q = rotr(n * mod_inv_5, 1); if (q <= max_value() / 10) { n = q; s |= 1; } return s; } // The main algorithm for shorter interval case template FMT_INLINE auto shorter_interval_case(int exponent) noexcept -> decimal_fp { decimal_fp ret_value; // Compute k and beta const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent); const int beta = exponent + floor_log2_pow10(-minus_k); // Compute xi and zi using cache_entry_type = typename cache_accessor::cache_entry_type; const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); auto xi = cache_accessor::compute_left_endpoint_for_shorter_interval_case( cache, beta); auto zi = cache_accessor::compute_right_endpoint_for_shorter_interval_case( cache, beta); // If the left endpoint is not an integer, increase it if (!is_left_endpoint_integer_shorter_interval(exponent)) ++xi; // Try bigger divisor ret_value.significand = zi / 10; // If succeed, remove trailing zeros if necessary and return if (ret_value.significand * 10 >= xi) { ret_value.exponent = minus_k + 1; ret_value.exponent += remove_trailing_zeros(ret_value.significand); return ret_value; } // Otherwise, compute the round-up of y ret_value.significand = cache_accessor::compute_round_up_for_shorter_interval_case(cache, beta); ret_value.exponent = minus_k; // When tie occurs, choose one of them according to the rule if (exponent >= float_info::shorter_interval_tie_lower_threshold && exponent <= float_info::shorter_interval_tie_upper_threshold) { ret_value.significand = ret_value.significand % 2 == 0 ? ret_value.significand : ret_value.significand - 1; } else if (ret_value.significand < xi) { ++ret_value.significand; } return ret_value; } template auto to_decimal(T x) noexcept -> decimal_fp { // Step 1: integer promotion & Schubfach multiplier calculation. using carrier_uint = typename float_info::carrier_uint; using cache_entry_type = typename cache_accessor::cache_entry_type; auto br = bit_cast(x); // Extract significand bits and exponent bits. const carrier_uint significand_mask = (static_cast(1) << num_significand_bits()) - 1; carrier_uint significand = (br & significand_mask); int exponent = static_cast((br & exponent_mask()) >> num_significand_bits()); if (exponent != 0) { // Check if normal. exponent -= exponent_bias() + num_significand_bits(); // Shorter interval case; proceed like Schubfach. // In fact, when exponent == 1 and significand == 0, the interval is // regular. However, it can be shown that the end-results are anyway same. if (significand == 0) return shorter_interval_case(exponent); significand |= (static_cast(1) << num_significand_bits()); } else { // Subnormal case; the interval is always regular. if (significand == 0) return {0, 0}; exponent = std::numeric_limits::min_exponent - num_significand_bits() - 1; } const bool include_left_endpoint = (significand % 2 == 0); const bool include_right_endpoint = include_left_endpoint; // Compute k and beta. const int minus_k = floor_log10_pow2(exponent) - float_info::kappa; const cache_entry_type cache = cache_accessor::get_cached_power(-minus_k); const int beta = exponent + floor_log2_pow10(-minus_k); // Compute zi and deltai. // 10^kappa <= deltai < 10^(kappa + 1) const uint32_t deltai = cache_accessor::compute_delta(cache, beta); const carrier_uint two_fc = significand << 1; // For the case of binary32, the result of integer check is not correct for // 29711844 * 2^-82 // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18 // and 29711844 * 2^-81 // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17, // and they are the unique counterexamples. However, since 29711844 is even, // this does not cause any problem for the endpoints calculations; it can only // cause a problem when we need to perform integer check for the center. // Fortunately, with these inputs, that branch is never executed, so we are // fine. const typename cache_accessor::compute_mul_result z_mul = cache_accessor::compute_mul((two_fc | 1) << beta, cache); // Step 2: Try larger divisor; remove trailing zeros if necessary. // Using an upper bound on zi, we might be able to optimize the division // better than the compiler; we are computing zi / big_divisor here. decimal_fp ret_value; ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result); uint32_t r = static_cast(z_mul.result - float_info::big_divisor * ret_value.significand); if (r < deltai) { // Exclude the right endpoint if necessary. if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) { --ret_value.significand; r = float_info::big_divisor; goto small_divisor_case_label; } } else if (r > deltai) { goto small_divisor_case_label; } else { // r == deltai; compare fractional parts. const typename cache_accessor::compute_mul_parity_result x_mul = cache_accessor::compute_mul_parity(two_fc - 1, cache, beta); if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint))) goto small_divisor_case_label; } ret_value.exponent = minus_k + float_info::kappa + 1; // We may need to remove trailing zeros. ret_value.exponent += remove_trailing_zeros(ret_value.significand); return ret_value; // Step 3: Find the significand with the smaller divisor. small_divisor_case_label: ret_value.significand *= 10; ret_value.exponent = minus_k + float_info::kappa; uint32_t dist = r - (deltai / 2) + (float_info::small_divisor / 2); const bool approx_y_parity = ((dist ^ (float_info::small_divisor / 2)) & 1) != 0; // Is dist divisible by 10^kappa? const bool divisible_by_small_divisor = check_divisibility_and_divide_by_pow10::kappa>(dist); // Add dist / 10^kappa to the significand. ret_value.significand += dist; if (!divisible_by_small_divisor) return ret_value; // Check z^(f) >= epsilon^(f). // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1, // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f). // Since there are only 2 possibilities, we only need to care about the // parity. Also, zi and r should have the same parity since the divisor // is an even number. const auto y_mul = cache_accessor::compute_mul_parity(two_fc, cache, beta); // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f), // or equivalently, when y is an integer. if (y_mul.parity != approx_y_parity) --ret_value.significand; else if (y_mul.is_integer & (ret_value.significand % 2 != 0)) --ret_value.significand; return ret_value; } } // namespace dragonbox } // namespace detail template <> struct formatter { FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> format_parse_context::iterator { return ctx.begin(); } auto format(const detail::bigint& n, format_context& ctx) const -> format_context::iterator { auto out = ctx.out(); bool first = true; for (auto i = n.bigits_.size(); i > 0; --i) { auto value = n.bigits_[i - 1u]; if (first) { out = fmt::format_to(out, FMT_STRING("{:x}"), value); first = false; continue; } out = fmt::format_to(out, FMT_STRING("{:08x}"), value); } if (n.exp_ > 0) out = fmt::format_to(out, FMT_STRING("p{}"), n.exp_ * detail::bigint::bigit_bits); return out; } }; FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) { for_each_codepoint(s, [this](uint32_t cp, string_view) { if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8")); if (cp <= 0xFFFF) { buffer_.push_back(static_cast(cp)); } else { cp -= 0x10000; buffer_.push_back(static_cast(0xD800 + (cp >> 10))); buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF))); } return true; }); buffer_.push_back(0); } FMT_FUNC void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept { FMT_TRY { auto ec = std::error_code(error_code, std::generic_category()); detail::write(appender(out), std::system_error(ec, message).what()); return; } FMT_CATCH(...) {} format_error_code(out, error_code, message); } FMT_FUNC void report_system_error(int error_code, const char* message) noexcept { do_report_error(format_system_error, error_code, message); } FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string { // Don't optimize the "{}" case to keep the binary size small and because it // can be better optimized in fmt::format anyway. auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); return to_string(buffer); } namespace detail { FMT_FUNC void vformat_to(buffer& buf, string_view fmt, format_args args, locale_ref loc) { auto out = appender(buf); if (fmt.size() == 2 && equal2(fmt.data(), "{}")) return args.get(0).visit(default_arg_formatter{out}); parse_format_string(fmt, format_handler<>{parse_context<>(fmt), {out, args, loc}}); } template struct span { T* data; size_t size; }; template auto flockfile(F* f) -> decltype(_lock_file(f)) { _lock_file(f); } template auto funlockfile(F* f) -> decltype(_unlock_file(f)) { _unlock_file(f); } #ifndef getc_unlocked template auto getc_unlocked(F* f) -> decltype(_fgetc_nolock(f)) { return _fgetc_nolock(f); } #endif template struct has_flockfile : std::false_type {}; template struct has_flockfile()))>> : std::true_type {}; // A FILE wrapper. F is FILE defined as a template parameter to make system API // detection work. template class file_base { public: F* file_; public: file_base(F* file) : file_(file) {} operator F*() const { return file_; } // Reads a code unit from the stream. auto get() -> int { int result = getc_unlocked(file_); if (result == EOF && ferror(file_) != 0) FMT_THROW(system_error(errno, FMT_STRING("getc failed"))); return result; } // Puts the code unit back into the stream buffer. void unget(char c) { if (ungetc(c, file_) == EOF) FMT_THROW(system_error(errno, FMT_STRING("ungetc failed"))); } void flush() { fflush(this->file_); } }; // A FILE wrapper for glibc. template class glibc_file : public file_base { private: enum { line_buffered = 0x200, // _IO_LINE_BUF unbuffered = 2 // _IO_UNBUFFERED }; public: using file_base::file_base; auto is_buffered() const -> bool { return (this->file_->_flags & unbuffered) == 0; } void init_buffer() { if (this->file_->_IO_write_ptr < this->file_->_IO_write_end) return; // Force buffer initialization by placing and removing a char in a buffer. putc_unlocked(0, this->file_); --this->file_->_IO_write_ptr; } // Returns the file's read buffer. auto get_read_buffer() const -> span { auto ptr = this->file_->_IO_read_ptr; return {ptr, to_unsigned(this->file_->_IO_read_end - ptr)}; } // Returns the file's write buffer. auto get_write_buffer() const -> span { auto ptr = this->file_->_IO_write_ptr; return {ptr, to_unsigned(this->file_->_IO_buf_end - ptr)}; } void advance_write_buffer(size_t size) { this->file_->_IO_write_ptr += size; } auto needs_flush() const -> bool { if ((this->file_->_flags & line_buffered) == 0) return false; char* end = this->file_->_IO_write_end; auto size = max_of(this->file_->_IO_write_ptr - end, 0); return memchr(end, '\n', static_cast(size)); } void flush() { fflush_unlocked(this->file_); } }; // A FILE wrapper for Apple's libc. template class apple_file : public file_base { private: enum { line_buffered = 1, // __SNBF unbuffered = 2 // __SLBF }; public: using file_base::file_base; auto is_buffered() const -> bool { return (this->file_->_flags & unbuffered) == 0; } void init_buffer() { if (this->file_->_p) return; // Force buffer initialization by placing and removing a char in a buffer. if (!FMT_CLANG_ANALYZER) putc_unlocked(0, this->file_); --this->file_->_p; ++this->file_->_w; } auto get_read_buffer() const -> span { return {reinterpret_cast(this->file_->_p), to_unsigned(this->file_->_r)}; } auto get_write_buffer() const -> span { return {reinterpret_cast(this->file_->_p), to_unsigned(this->file_->_bf._base + this->file_->_bf._size - this->file_->_p)}; } void advance_write_buffer(size_t size) { this->file_->_p += size; this->file_->_w -= size; } auto needs_flush() const -> bool { if ((this->file_->_flags & line_buffered) == 0) return false; return memchr(this->file_->_p + this->file_->_w, '\n', to_unsigned(-this->file_->_w)); } }; // A fallback FILE wrapper. template class fallback_file : public file_base { private: char next_; // The next unconsumed character in the buffer. bool has_next_ = false; public: using file_base::file_base; auto is_buffered() const -> bool { return false; } auto needs_flush() const -> bool { return false; } void init_buffer() {} auto get_read_buffer() const -> span { return {&next_, has_next_ ? 1u : 0u}; } auto get_write_buffer() const -> span { return {nullptr, 0}; } void advance_write_buffer(size_t) {} auto get() -> int { has_next_ = false; return file_base::get(); } void unget(char c) { file_base::unget(c); next_ = c; has_next_ = true; } }; #ifndef FMT_USE_FALLBACK_FILE # define FMT_USE_FALLBACK_FILE 0 #endif template auto get_file(F* f, int) -> apple_file { return f; } template inline auto get_file(F* f, int) -> glibc_file { return f; } inline auto get_file(FILE* f, ...) -> fallback_file { return f; } using file_ref = decltype(get_file(static_cast(nullptr), 0)); template class file_print_buffer : public buffer { public: explicit file_print_buffer(F*) : buffer(nullptr, size_t()) {} }; template class file_print_buffer::value>> : public buffer { private: file_ref file_; static void grow(buffer& base, size_t) { auto& self = static_cast(base); self.file_.advance_write_buffer(self.size()); if (self.file_.get_write_buffer().size == 0) self.file_.flush(); auto buf = self.file_.get_write_buffer(); FMT_ASSERT(buf.size > 0, ""); self.set(buf.data, buf.size); self.clear(); } public: explicit file_print_buffer(F* f) : buffer(grow, size_t()), file_(f) { flockfile(f); file_.init_buffer(); auto buf = file_.get_write_buffer(); set(buf.data, buf.size); } ~file_print_buffer() { file_.advance_write_buffer(size()); bool flush = file_.needs_flush(); F* f = file_; // Make funlockfile depend on the template parameter F funlockfile(f); // for the system API detection to work. if (flush) fflush(file_); } }; #if !defined(_WIN32) || defined(FMT_USE_WRITE_CONSOLE) FMT_FUNC auto write_console(int, string_view) -> bool { return false; } #else using dword = conditional_t; extern "C" __declspec(dllimport) int __stdcall WriteConsoleW( // void*, const void*, dword, dword*, void*); FMT_FUNC bool write_console(int fd, string_view text) { auto u16 = utf8_to_utf16(text); return WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)), u16.c_str(), static_cast(u16.size()), nullptr, nullptr) != 0; } #endif #ifdef _WIN32 // Print assuming legacy (non-Unicode) encoding. FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args, bool newline) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); if (newline) buffer.push_back('\n'); fwrite_all(buffer.data(), buffer.size(), f); } #endif FMT_FUNC void print(std::FILE* f, string_view text) { #if defined(_WIN32) && !defined(FMT_USE_WRITE_CONSOLE) int fd = _fileno(f); if (_isatty(fd)) { std::fflush(f); if (write_console(fd, text)) return; } #endif fwrite_all(text.data(), text.size(), f); } } // namespace detail FMT_FUNC void vprint_buffered(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); detail::print(f, {buffer.data(), buffer.size()}); } FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) { if (!detail::file_ref(f).is_buffered() || !detail::has_flockfile<>()) return vprint_buffered(f, fmt, args); auto&& buffer = detail::file_print_buffer<>(f); return detail::vformat_to(buffer, fmt, args); } FMT_FUNC void vprintln(std::FILE* f, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); buffer.push_back('\n'); detail::print(f, {buffer.data(), buffer.size()}); } FMT_FUNC void vprint(string_view fmt, format_args args) { vprint(stdout, fmt, args); } namespace detail { struct singleton { unsigned char upper; unsigned char lower_count; }; inline auto is_printable(uint16_t x, const singleton* singletons, size_t singletons_size, const unsigned char* singleton_lowers, const unsigned char* normal, size_t normal_size) -> bool { auto upper = x >> 8; auto lower_start = 0; for (size_t i = 0; i < singletons_size; ++i) { auto s = singletons[i]; auto lower_end = lower_start + s.lower_count; if (upper < s.upper) break; if (upper == s.upper) { for (auto j = lower_start; j < lower_end; ++j) { if (singleton_lowers[j] == (x & 0xff)) return false; } } lower_start = lower_end; } auto xsigned = static_cast(x); auto current = true; for (size_t i = 0; i < normal_size; ++i) { auto v = static_cast(normal[i]); auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v; xsigned -= len; if (xsigned < 0) break; current = !current; } return current; } // This code is generated by support/printable.py. FMT_FUNC auto is_printable(uint32_t cp) -> bool { static constexpr singleton singletons0[] = { {0x00, 1}, {0x03, 5}, {0x05, 6}, {0x06, 3}, {0x07, 6}, {0x08, 8}, {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13}, {0x0f, 4}, {0x10, 3}, {0x12, 18}, {0x13, 9}, {0x16, 1}, {0x17, 5}, {0x18, 2}, {0x19, 3}, {0x1a, 7}, {0x1c, 2}, {0x1d, 1}, {0x1f, 22}, {0x20, 3}, {0x2b, 3}, {0x2c, 2}, {0x2d, 11}, {0x2e, 1}, {0x30, 3}, {0x31, 2}, {0x32, 1}, {0xa7, 2}, {0xa9, 2}, {0xaa, 4}, {0xab, 8}, {0xfa, 2}, {0xfb, 5}, {0xfd, 4}, {0xfe, 3}, {0xff, 9}, }; static constexpr unsigned char singletons0_lower[] = { 0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90, 0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f, 0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04, 0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d, 0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf, 0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d, 0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d, 0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d, 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7, 0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, 0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, 0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0, 0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff, }; static constexpr singleton singletons1[] = { {0x00, 6}, {0x01, 1}, {0x03, 1}, {0x04, 2}, {0x08, 8}, {0x09, 2}, {0x0a, 5}, {0x0b, 2}, {0x0e, 4}, {0x10, 1}, {0x11, 2}, {0x12, 5}, {0x13, 17}, {0x14, 1}, {0x15, 2}, {0x17, 2}, {0x19, 13}, {0x1c, 5}, {0x1d, 8}, {0x24, 1}, {0x6a, 3}, {0x6b, 2}, {0xbc, 2}, {0xd1, 2}, {0xd4, 12}, {0xd5, 9}, {0xd6, 2}, {0xd7, 2}, {0xda, 1}, {0xe0, 5}, {0xe1, 2}, {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2}, {0xf9, 2}, {0xfa, 2}, {0xfb, 1}, }; static constexpr unsigned char singletons1_lower[] = { 0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07, 0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36, 0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87, 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b, 0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9, 0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66, 0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27, 0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc, 0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7, 0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6, 0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, 0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0, 0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93, }; static constexpr unsigned char normal0[] = { 0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04, 0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0, 0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01, 0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03, 0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03, 0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a, 0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15, 0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f, 0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80, 0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07, 0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06, 0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04, 0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac, 0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c, 0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11, 0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c, 0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b, 0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6, 0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03, 0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80, 0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06, 0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c, 0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17, 0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80, 0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80, 0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d, }; static constexpr unsigned char normal1[] = { 0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f, 0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e, 0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04, 0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09, 0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16, 0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f, 0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36, 0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33, 0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08, 0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e, 0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41, 0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03, 0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22, 0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04, 0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45, 0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03, 0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81, 0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75, 0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1, 0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a, 0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11, 0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09, 0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89, 0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6, 0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09, 0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50, 0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05, 0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83, 0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05, 0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80, 0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80, 0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07, 0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e, 0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07, 0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06, }; auto lower = static_cast(cp); if (cp < 0x10000) { return is_printable(lower, singletons0, sizeof(singletons0) / sizeof(*singletons0), singletons0_lower, normal0, sizeof(normal0)); } if (cp < 0x20000) { return is_printable(lower, singletons1, sizeof(singletons1) / sizeof(*singletons1), singletons1_lower, normal1, sizeof(normal1)); } if (0x2a6de <= cp && cp < 0x2a700) return false; if (0x2b735 <= cp && cp < 0x2b740) return false; if (0x2b81e <= cp && cp < 0x2b820) return false; if (0x2cea2 <= cp && cp < 0x2ceb0) return false; if (0x2ebe1 <= cp && cp < 0x2f800) return false; if (0x2fa1e <= cp && cp < 0x30000) return false; if (0x3134b <= cp && cp < 0xe0100) return false; if (0xe01f0 <= cp && cp < 0x110000) return false; return cp < 0x110000; } } // namespace detail FMT_END_NAMESPACE #endif // FMT_FORMAT_INL_H_ aristocratos-btop-d43a485/include/fmt/format.h000066400000000000000000004751121517514752700214310ustar00rootroot00000000000000/* Formatting library for C++ Copyright (c) 2012 - present, Victor Zverovich 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. --- Optional exception to the license --- As an exception, if, as a result of your compiling your source code, portions of this Software are embedded into a machine-executable object form of such source code, you may redistribute such embedded portions in such object form without including the above copyright and permission notices. */ #ifndef FMT_FORMAT_H_ #define FMT_FORMAT_H_ #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES # define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES # define FMT_REMOVE_TRANSITIVE_INCLUDES #endif #include "base.h" #ifndef FMT_MODULE # include // std::signbit # include // std::byte # include // uint32_t # include // std::malloc, std::free # include // std::memcpy # include // std::numeric_limits # include // std::bad_alloc # if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI) // Workaround for pre gcc 5 libstdc++. # include // std::allocator_traits # endif # include // std::runtime_error # include // std::string # include // std::system_error // Check FMT_CPLUSPLUS to avoid a warning in MSVC. # if FMT_HAS_INCLUDE() && FMT_CPLUSPLUS > 201703L # include // std::bit_cast # endif // libc++ supports string_view in pre-c++17. # if FMT_HAS_INCLUDE() && \ (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION)) # include # define FMT_USE_STRING_VIEW # endif # if FMT_MSC_VERSION # include // _BitScanReverse[64], _umul128 # endif #endif // FMT_MODULE #if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS) // Use the provided definition. #elif defined(__NVCOMPILER) # define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 #elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 #elif defined(__cpp_nontype_template_args) && \ __cpp_nontype_template_args >= 201911L # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 #elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L # define FMT_USE_NONTYPE_TEMPLATE_ARGS 1 #else # define FMT_USE_NONTYPE_TEMPLATE_ARGS 0 #endif #if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L # define FMT_INLINE_VARIABLE inline #else # define FMT_INLINE_VARIABLE #endif // Check if RTTI is disabled. #ifdef FMT_USE_RTTI // Use the provided definition. #elif defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \ defined(__INTEL_RTTI__) || defined(__RTTI) // __RTTI is for EDG compilers. _CPPRTTI is for MSVC. # define FMT_USE_RTTI 1 #else # define FMT_USE_RTTI 0 #endif // Visibility when compiled as a shared library/object. #if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED) # define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value) #else # define FMT_SO_VISIBILITY(value) #endif #if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_NOINLINE __attribute__((noinline)) #else # define FMT_NOINLINE #endif #ifdef FMT_DEPRECATED // Use the provided definition. #elif FMT_HAS_CPP14_ATTRIBUTE(deprecated) # define FMT_DEPRECATED [[deprecated]] #else # define FMT_DEPRECATED /* deprecated */ #endif // Detect constexpr std::string. #if !FMT_USE_CONSTEVAL # define FMT_USE_CONSTEXPR_STRING 0 #elif defined(__cpp_lib_constexpr_string) && \ __cpp_lib_constexpr_string >= 201907L # if FMT_CLANG_VERSION && FMT_GLIBCXX_RELEASE // clang + libstdc++ are able to work only starting with gcc13.3 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113294 # if FMT_GLIBCXX_RELEASE < 13 # define FMT_USE_CONSTEXPR_STRING 0 # elif FMT_GLIBCXX_RELEASE == 13 && __GLIBCXX__ < 20240521 # define FMT_USE_CONSTEXPR_STRING 0 # else # define FMT_USE_CONSTEXPR_STRING 1 # endif # else # define FMT_USE_CONSTEXPR_STRING 1 # endif #else # define FMT_USE_CONSTEXPR_STRING 0 #endif #if FMT_USE_CONSTEXPR_STRING # define FMT_CONSTEXPR_STRING constexpr #else # define FMT_CONSTEXPR_STRING #endif // GCC 4.9 doesn't support qualified names in specializations. namespace std { template struct iterator_traits> { using iterator_category = output_iterator_tag; using value_type = T; using difference_type = decltype(static_cast(nullptr) - static_cast(nullptr)); using pointer = void; using reference = void; }; } // namespace std #ifdef FMT_THROW // Use the provided definition. #elif FMT_USE_EXCEPTIONS # define FMT_THROW(x) throw x #else # define FMT_THROW(x) ::fmt::assert_fail(__FILE__, __LINE__, (x).what()) #endif #ifdef __clang_analyzer__ # define FMT_CLANG_ANALYZER 1 #else # define FMT_CLANG_ANALYZER 0 #endif // Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of // integer formatter template instantiations to just one by only using the // largest integer type. This results in a reduction in binary size but will // cause a decrease in integer formatting performance. #if !defined(FMT_REDUCE_INT_INSTANTIATIONS) # define FMT_REDUCE_INT_INSTANTIATIONS 0 #endif FMT_BEGIN_NAMESPACE template struct is_contiguous> : std::true_type {}; namespace detail { // __builtin_clz is broken in clang with Microsoft codegen: // https://github.com/fmtlib/fmt/issues/519. #if !FMT_MSC_VERSION # if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION # define FMT_BUILTIN_CLZ(n) __builtin_clz(n) # endif # if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION # define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) # endif #endif // Some compilers masquerade as both MSVC and GCC but otherwise support // __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the // MSVC intrinsics if the clz and clzll builtins are not available. #if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. # ifndef __clang__ # pragma intrinsic(_BitScanReverse) # ifdef _WIN64 # pragma intrinsic(_BitScanReverse64) # endif # endif inline auto clz(uint32_t x) -> int { FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. unsigned long r = 0; _BitScanReverse(&r, x); return 31 ^ static_cast(r); } # define FMT_BUILTIN_CLZ(n) detail::clz(n) inline auto clzll(uint64_t x) -> int { FMT_ASSERT(x != 0, ""); FMT_MSC_WARNING(suppress : 6102) // Suppress a bogus static analysis warning. unsigned long r = 0; # ifdef _WIN64 _BitScanReverse64(&r, x); # else // Scan the high 32 bits. if (_BitScanReverse(&r, static_cast(x >> 32))) return 63 ^ static_cast(r + 32); // Scan the low 32 bits. _BitScanReverse(&r, static_cast(x)); # endif return 63 ^ static_cast(r); } # define FMT_BUILTIN_CLZLL(n) detail::clzll(n) #endif // FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) { ignore_unused(condition); #ifdef FMT_FUZZ if (condition) throw std::runtime_error("fuzzing limit reached"); #endif } #if defined(FMT_USE_STRING_VIEW) template using std_string_view = std::basic_string_view; #else template struct std_string_view { operator basic_string_view() const; }; #endif template struct string_literal { static constexpr Char value[sizeof...(C)] = {C...}; constexpr operator basic_string_view() const { return {value, sizeof...(C)}; } }; #if FMT_CPLUSPLUS < 201703L template constexpr Char string_literal::value[sizeof...(C)]; #endif // Implementation of std::bit_cast for pre-C++20. template FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To { #ifdef __cpp_lib_bit_cast if (is_constant_evaluated()) return std::bit_cast(from); #endif auto to = To(); // The cast suppresses a bogus -Wclass-memaccess on GCC. std::memcpy(static_cast(&to), &from, sizeof(to)); return to; } inline auto is_big_endian() -> bool { #ifdef _WIN32 return false; #elif defined(__BIG_ENDIAN__) return true; #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__; #else struct bytes { char data[sizeof(int)]; }; return bit_cast(1).data[0] == 0; #endif } class uint128_fallback { private: uint64_t lo_, hi_; public: constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {} constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {} constexpr auto high() const noexcept -> uint64_t { return hi_; } constexpr auto low() const noexcept -> uint64_t { return lo_; } template ::value)> constexpr explicit operator T() const { return static_cast(lo_); } friend constexpr auto operator==(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_; } friend constexpr auto operator!=(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return !(lhs == rhs); } friend constexpr auto operator>(const uint128_fallback& lhs, const uint128_fallback& rhs) -> bool { return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_; } friend constexpr auto operator|(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_}; } friend constexpr auto operator&(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_}; } friend constexpr auto operator~(const uint128_fallback& n) -> uint128_fallback { return {~n.hi_, ~n.lo_}; } friend FMT_CONSTEXPR auto operator+(const uint128_fallback& lhs, const uint128_fallback& rhs) -> uint128_fallback { auto result = uint128_fallback(lhs); result += rhs; return result; } friend FMT_CONSTEXPR auto operator*(const uint128_fallback& lhs, uint32_t rhs) -> uint128_fallback { FMT_ASSERT(lhs.hi_ == 0, ""); uint64_t hi = (lhs.lo_ >> 32) * rhs; uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs; uint64_t new_lo = (hi << 32) + lo; return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo}; } friend constexpr auto operator-(const uint128_fallback& lhs, uint64_t rhs) -> uint128_fallback { return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs}; } FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback { if (shift == 64) return {0, hi_}; if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64); return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)}; } FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback { if (shift == 64) return {lo_, 0}; if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64); return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)}; } FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& { return *this = *this >> shift; } FMT_CONSTEXPR void operator+=(uint128_fallback n) { uint64_t new_lo = lo_ + n.lo_; uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0); FMT_ASSERT(new_hi >= hi_, ""); lo_ = new_lo; hi_ = new_hi; } FMT_CONSTEXPR void operator&=(uint128_fallback n) { lo_ &= n.lo_; hi_ &= n.hi_; } FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& { if (is_constant_evaluated()) { lo_ += n; hi_ += (lo_ < n ? 1 : 0); return *this; } #if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__) unsigned long long carry; lo_ = __builtin_addcll(lo_, n, 0, &carry); hi_ += carry; #elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__) unsigned long long result; auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result); lo_ = result; hi_ += carry; #elif defined(_MSC_VER) && defined(_M_X64) auto carry = _addcarry_u64(0, lo_, n, &lo_); _addcarry_u64(carry, hi_, 0, &hi_); #else lo_ += n; hi_ += (lo_ < n ? 1 : 0); #endif return *this; } }; using uint128_t = conditional_t; #ifdef UINTPTR_MAX using uintptr_t = ::uintptr_t; #else using uintptr_t = uint128_t; #endif // Returns the largest possible value for type T. Same as // std::numeric_limits::max() but shorter and not affected by the max macro. template constexpr auto max_value() -> T { return (std::numeric_limits::max)(); } template constexpr auto num_bits() -> int { return std::numeric_limits::digits; } // std::numeric_limits::digits may return 0 for 128-bit ints. template <> constexpr auto num_bits() -> int { return 128; } template <> constexpr auto num_bits() -> int { return 128; } template <> constexpr auto num_bits() -> int { return 128; } // A heterogeneous bit_cast used for converting 96-bit long double to uint128_t // and 128-bit pointers to uint128_fallback. template sizeof(From))> inline auto bit_cast(const From& from) -> To { constexpr auto size = static_cast(sizeof(From) / sizeof(unsigned short)); struct data_t { unsigned short value[static_cast(size)]; } data = bit_cast(from); auto result = To(); if (const_check(is_big_endian())) { for (int i = 0; i < size; ++i) result = (result << num_bits()) | data.value[i]; } else { for (int i = size - 1; i >= 0; --i) result = (result << num_bits()) | data.value[i]; } return result; } template FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int { int lz = 0; constexpr UInt msb_mask = static_cast(1) << (num_bits() - 1); for (; (n & msb_mask) == 0; n <<= 1) lz++; return lz; } FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n); #endif return countl_zero_fallback(n); } FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n); #endif return countl_zero_fallback(n); } FMT_INLINE void assume(bool condition) { (void)condition; #if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION __builtin_assume(condition); #elif FMT_GCC_VERSION if (!condition) __builtin_unreachable(); #endif } // Attempts to reserve space for n extra characters in the output range. // Returns a pointer to the reserved range or a reference to it. template ::value&& is_contiguous::value)> #if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION __attribute__((no_sanitize("undefined"))) #endif FMT_CONSTEXPR20 inline auto reserve(OutputIt it, size_t n) -> typename OutputIt::value_type* { auto& c = get_container(it); size_t size = c.size(); c.resize(size + n); return &c[size]; } template FMT_CONSTEXPR20 inline auto reserve(basic_appender it, size_t n) -> basic_appender { buffer& buf = get_container(it); buf.try_reserve(buf.size() + n); return it; } template constexpr auto reserve(Iterator& it, size_t) -> Iterator& { return it; } template using reserve_iterator = remove_reference_t(), 0))>; template constexpr auto to_pointer(OutputIt, size_t) -> T* { return nullptr; } template FMT_CONSTEXPR auto to_pointer(T*& ptr, size_t n) -> T* { T* begin = ptr; ptr += n; return begin; } template FMT_CONSTEXPR20 auto to_pointer(basic_appender it, size_t n) -> T* { buffer& buf = get_container(it); buf.try_reserve(buf.size() + n); auto size = buf.size(); if (buf.capacity() < size + n) return nullptr; buf.try_resize(size + n); return buf.data() + size; } template ::value&& is_contiguous::value)> inline auto base_iterator(OutputIt it, typename OutputIt::container_type::value_type*) -> OutputIt { return it; } template constexpr auto base_iterator(Iterator, Iterator it) -> Iterator { return it; } // is spectacularly slow to compile in C++20 so use a simple fill_n // instead (#1998). template FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value) -> OutputIt { for (Size i = 0; i < count; ++i) *out++ = value; return out; } template FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* { if (is_constant_evaluated()) return fill_n(out, count, value); static_assert(sizeof(T) == 1, "sizeof(T) must be 1 to use char for initialization"); std::memset(out, value, to_unsigned(count)); return out + count; } template FMT_CONSTEXPR FMT_NOINLINE auto copy_noinline(InputIt begin, InputIt end, OutputIt out) -> OutputIt { return copy(begin, end, out); } // A public domain branchless UTF-8 decoder by Christopher Wellons: // https://github.com/skeeto/branchless-utf8 /* Decode the next character, c, from s, reporting errors in e. * * Since this is a branchless decoder, four bytes will be read from the * buffer regardless of the actual length of the next character. This * means the buffer _must_ have at least three bytes of zero padding * following the end of the data stream. * * Errors are reported in e, which will be non-zero if the parsed * character was somehow invalid: invalid byte sequence, non-canonical * encoding, or a surrogate half. * * The function returns a pointer to the next character. When an error * occurs, this pointer will be a guess that depends on the particular * error, but it will always advance at least one byte. */ FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e) -> const char* { constexpr int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07}; constexpr uint32_t mins[] = {4194304, 0, 128, 2048, 65536}; constexpr int shiftc[] = {0, 18, 12, 6, 0}; constexpr int shifte[] = {0, 6, 4, 2, 0}; int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4" [static_cast(*s) >> 3]; // Compute the pointer to the next character early so that the next // iteration can start working on the next character. Neither Clang // nor GCC figure out this reordering on their own. const char* next = s + len + !len; using uchar = unsigned char; // Assume a four-byte character and load four bytes. Unused bits are // shifted out. *c = uint32_t(uchar(s[0]) & masks[len]) << 18; *c |= uint32_t(uchar(s[1]) & 0x3f) << 12; *c |= uint32_t(uchar(s[2]) & 0x3f) << 6; *c |= uint32_t(uchar(s[3]) & 0x3f) << 0; *c >>= shiftc[len]; // Accumulate the various error conditions. *e = (*c < mins[len]) << 6; // non-canonical encoding *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half? *e |= (*c > 0x10FFFF) << 8; // out of range? *e |= (uchar(s[1]) & 0xc0) >> 2; *e |= (uchar(s[2]) & 0xc0) >> 4; *e |= uchar(s[3]) >> 6; *e ^= 0x2a; // top two bits of each tail byte correct? *e >>= shifte[len]; return next; } constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t(); // Invokes f(cp, sv) for every code point cp in s with sv being the string view // corresponding to the code point. cp is invalid_code_point on error. template FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) { auto decode = [f](const char* buf_ptr, const char* ptr) { auto cp = uint32_t(); auto error = 0; auto end = utf8_decode(buf_ptr, &cp, &error); bool result = f(error ? invalid_code_point : cp, string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr))); return result ? (error ? buf_ptr + 1 : end) : nullptr; }; auto p = s.data(); const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars. if (s.size() >= block_size) { for (auto end = p + s.size() - block_size + 1; p < end;) { p = decode(p, p); if (!p) return; } } auto num_chars_left = to_unsigned(s.data() + s.size() - p); if (num_chars_left == 0) return; // Suppress bogus -Wstringop-overflow. if (FMT_GCC_VERSION) num_chars_left &= 3; char buf[2 * block_size - 1] = {}; copy(p, p + num_chars_left, buf); const char* buf_ptr = buf; do { auto end = decode(buf_ptr, p); if (!end) return; p += end - buf_ptr; buf_ptr = end; } while (buf_ptr < buf + num_chars_left); } FMT_CONSTEXPR inline auto display_width_of(uint32_t cp) noexcept -> size_t { return to_unsigned( 1 + (cp >= 0x1100 && (cp <= 0x115f || // Hangul Jamo init. consonants cp == 0x2329 || // LEFT-POINTING ANGLE BRACKET cp == 0x232a || // RIGHT-POINTING ANGLE BRACKET // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE: (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) || (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul Syllables (cp >= 0xf900 && cp <= 0xfaff) || // CJK Compatibility Ideographs (cp >= 0xfe10 && cp <= 0xfe19) || // Vertical Forms (cp >= 0xfe30 && cp <= 0xfe6f) || // CJK Compatibility Forms (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth Forms (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth Forms (cp >= 0x20000 && cp <= 0x2fffd) || // CJK (cp >= 0x30000 && cp <= 0x3fffd) || // Miscellaneous Symbols and Pictographs + Emoticons: (cp >= 0x1f300 && cp <= 0x1f64f) || // Supplemental Symbols and Pictographs: (cp >= 0x1f900 && cp <= 0x1f9ff)))); } template struct is_integral : std::is_integral {}; template <> struct is_integral : std::true_type {}; template <> struct is_integral : std::true_type {}; template using is_signed = std::integral_constant::is_signed || std::is_same::value>; template using is_integer = bool_constant::value && !std::is_same::value && !std::is_same::value && !std::is_same::value>; #if defined(FMT_USE_FLOAT128) // Use the provided definition. #elif FMT_CLANG_VERSION >= 309 && FMT_HAS_INCLUDE() # define FMT_USE_FLOAT128 1 #elif FMT_GCC_VERSION && defined(_GLIBCXX_USE_FLOAT128) && \ !defined(__STRICT_ANSI__) # define FMT_USE_FLOAT128 1 #else # define FMT_USE_FLOAT128 0 #endif #if FMT_USE_FLOAT128 using float128 = __float128; #else struct float128 {}; #endif template using is_float128 = std::is_same; template struct is_floating_point : std::is_floating_point {}; template <> struct is_floating_point : std::true_type {}; template ::value> struct is_fast_float : bool_constant::is_iec559 && sizeof(T) <= sizeof(double)> {}; template struct is_fast_float : std::false_type {}; template using fast_float_t = conditional_t; template using is_double_double = bool_constant::digits == 106>; #ifndef FMT_USE_FULL_CACHE_DRAGONBOX # define FMT_USE_FULL_CACHE_DRAGONBOX 0 #endif // An allocator that uses malloc/free to allow removing dependency on the C++ // standard libary runtime. std::decay is used for back_inserter to be found by // ADL when applied to memory_buffer. template struct allocator : private std::decay { using value_type = T; auto allocate(size_t n) -> T* { FMT_ASSERT(n <= max_value() / sizeof(T), ""); T* p = static_cast(std::malloc(n * sizeof(T))); if (!p) FMT_THROW(std::bad_alloc()); return p; } void deallocate(T* p, size_t) { std::free(p); } constexpr friend auto operator==(allocator, allocator) noexcept -> bool { return true; // All instances of this allocator are equivalent. } constexpr friend auto operator!=(allocator, allocator) noexcept -> bool { return false; } }; } // namespace detail FMT_BEGIN_EXPORT // The number of characters to store in the basic_memory_buffer object itself // to avoid dynamic memory allocation. enum { inline_buffer_size = 500 }; /** * A dynamically growing memory buffer for trivially copyable/constructible * types with the first `SIZE` elements stored in the object itself. Most * commonly used via the `memory_buffer` alias for `char`. * * **Example**: * * auto out = fmt::memory_buffer(); * fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); * * This will append "The answer is 42." to `out`. The buffer content can be * converted to `std::string` with `to_string(out)`. */ template > class basic_memory_buffer : public detail::buffer { private: T store_[SIZE]; // Don't inherit from Allocator to avoid generating type_info for it. FMT_NO_UNIQUE_ADDRESS Allocator alloc_; // Deallocate memory allocated by the buffer. FMT_CONSTEXPR20 void deallocate() { T* data = this->data(); if (data != store_) alloc_.deallocate(data, this->capacity()); } static FMT_CONSTEXPR20 void grow(detail::buffer& buf, size_t size) { detail::abort_fuzzing_if(size > 5000); auto& self = static_cast(buf); const size_t max_size = std::allocator_traits::max_size(self.alloc_); size_t old_capacity = buf.capacity(); size_t new_capacity = old_capacity + old_capacity / 2; if (size > new_capacity) new_capacity = size; else if (new_capacity > max_size) new_capacity = max_of(size, max_size); T* old_data = buf.data(); T* new_data = self.alloc_.allocate(new_capacity); // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481). detail::assume(buf.size() <= new_capacity); // The following code doesn't throw, so the raw pointer above doesn't leak. memcpy(new_data, old_data, buf.size() * sizeof(T)); self.set(new_data, new_capacity); // deallocate must not throw according to the standard, but even if it does, // the buffer already uses the new storage and will deallocate it in // destructor. if (old_data != self.store_) self.alloc_.deallocate(old_data, old_capacity); } public: using value_type = T; using const_reference = const T&; FMT_CONSTEXPR explicit basic_memory_buffer( const Allocator& alloc = Allocator()) : detail::buffer(grow), alloc_(alloc) { this->set(store_, SIZE); if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T()); } FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); } private: template :: propagate_on_container_move_assignment::value)> FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool { alloc_ = std::move(other.alloc_); return true; } // If the allocator does not propagate then copy the data from other. template :: propagate_on_container_move_assignment::value)> FMT_CONSTEXPR20 auto move_alloc(basic_memory_buffer& other) -> bool { T* data = other.data(); if (alloc_ == other.alloc_ || data == other.store_) return true; size_t size = other.size(); // Perform copy operation, allocators are different. this->resize(size); detail::copy(data, data + size, this->data()); return false; } // Move data from other to this buffer. FMT_CONSTEXPR20 void move(basic_memory_buffer& other) { T* data = other.data(); size_t size = other.size(), capacity = other.capacity(); if (!move_alloc(other)) return; if (data == other.store_) { this->set(store_, capacity); detail::copy(other.store_, other.store_ + size, store_); } else { this->set(data, capacity); // Set pointer to the inline array so that delete is not called // when deallocating. other.set(other.store_, 0); other.clear(); } this->resize(size); } public: /// Constructs a `basic_memory_buffer` object moving the content of the other /// object to it. FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept : detail::buffer(grow) { move(other); } /// Moves the content of the other `basic_memory_buffer` object to this one. auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& { FMT_ASSERT(this != &other, ""); deallocate(); move(other); return *this; } // Returns a copy of the allocator associated with this buffer. auto get_allocator() const -> Allocator { return alloc_; } /// Resizes the buffer to contain `count` elements. If T is a POD type new /// elements may not be initialized. FMT_CONSTEXPR void resize(size_t count) { this->try_resize(count); } /// Increases the buffer capacity to `new_capacity`. void reserve(size_t new_capacity) { this->try_reserve(new_capacity); } using detail::buffer::append; template FMT_CONSTEXPR20 void append(const ContiguousRange& range) { append(range.data(), range.data() + range.size()); } }; using memory_buffer = basic_memory_buffer; template FMT_NODISCARD auto to_string(const basic_memory_buffer& buf) -> std::string { auto size = buf.size(); detail::assume(size < std::string().max_size()); return {buf.data(), size}; } // A writer to a buffered stream. It doesn't own the underlying stream. class writer { private: detail::buffer* buf_; // We cannot create a file buffer in advance because any write to a FILE may // invalidate it. FILE* file_; public: inline writer(FILE* f) : buf_(nullptr), file_(f) {} inline writer(detail::buffer& buf) : buf_(&buf) {} /// Formats `args` according to specifications in `fmt` and writes the /// output to the file. template void print(format_string fmt, T&&... args) { if (buf_) fmt::format_to(appender(*buf_), fmt, std::forward(args)...); else fmt::print(file_, fmt, std::forward(args)...); } }; class string_buffer { private: std::string str_; detail::container_buffer buf_; public: inline string_buffer() : buf_(str_) {} inline operator writer() { return buf_; } inline auto str() -> std::string& { return str_; } }; template struct is_contiguous> : std::true_type { }; // Suppress a misleading warning in older versions of clang. FMT_PRAGMA_CLANG(diagnostic ignored "-Wweak-vtables") /// An error reported from a formatting function. class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error { public: using std::runtime_error::runtime_error; }; class loc_value; FMT_END_EXPORT namespace detail { FMT_API auto write_console(int fd, string_view text) -> bool; FMT_API void print(FILE*, string_view); } // namespace detail namespace detail { template struct fixed_string { FMT_CONSTEXPR20 fixed_string(const Char (&s)[N]) { detail::copy(static_cast(s), s + N, data); } Char data[N] = {}; }; // Converts a compile-time string to basic_string_view. FMT_EXPORT template constexpr auto compile_string_to_view(const Char (&s)[N]) -> basic_string_view { // Remove trailing NUL character if needed. Won't be present if this is used // with a raw character array (i.e. not defined as a string). return {s, N - (std::char_traits::to_int_type(s[N - 1]) == 0 ? 1 : 0)}; } FMT_EXPORT template constexpr auto compile_string_to_view(basic_string_view s) -> basic_string_view { return s; } // Returns true if value is negative, false otherwise. // Same as `value < 0` but doesn't produce warnings if T is an unsigned type. template ::value)> constexpr auto is_negative(T value) -> bool { return value < 0; } template ::value)> constexpr auto is_negative(T) -> bool { return false; } // Smallest of uint32_t, uint64_t, uint128_t that is large enough to // represent all values of an integral type T. template using uint32_or_64_or_128_t = conditional_t() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS, uint32_t, conditional_t() <= 64, uint64_t, uint128_t>>; template using uint64_or_128_t = conditional_t() <= 64, uint64_t, uint128_t>; #define FMT_POWERS_OF_10(factor) \ factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \ (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \ (factor) * 100000000, (factor) * 1000000000 // Converts value in the range [0, 100) to a string. // GCC generates slightly better code when value is pointer-size. inline auto digits2(size_t value) -> const char* { // Align data since unaligned access may be slower when crossing a // hardware-specific boundary. alignas(2) static const char data[] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"; return &data[value * 2]; } template constexpr auto getsign(sign s) -> Char { return static_cast(((' ' << 24) | ('+' << 16) | ('-' << 8)) >> (static_cast(s) * 8)); } template FMT_CONSTEXPR auto count_digits_fallback(T n) -> int { int count = 1; for (;;) { // Integer division is slow so do it for a group of four digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. if (n < 10) return count; if (n < 100) return count + 1; if (n < 1000) return count + 2; if (n < 10000) return count + 3; n /= 10000u; count += 4; } } #if FMT_USE_INT128 FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int { return count_digits_fallback(n); } #endif #ifdef FMT_BUILTIN_CLZLL // It is a separate function rather than a part of count_digits to workaround // the lack of static constexpr in constexpr functions. inline auto do_count_digits(uint64_t n) -> int { // This has comparable performance to the version by Kendall Willets // (https://github.com/fmtlib/format-benchmark/blob/master/digits10) // but uses smaller tables. // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)). static constexpr uint8_t bsr2log10[] = { 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20}; auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63]; static constexpr uint64_t zero_or_powers_of_10[] = { 0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL), 10000000000000000000ULL}; return t - (n < zero_or_powers_of_10[t]); } #endif // Returns the number of decimal digits in n. Leading zeros are not counted // except for n == 0 in which case count_digits returns 1. FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int { #ifdef FMT_BUILTIN_CLZLL if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n); #endif return count_digits_fallback(n); } // Counts the number of digits in n. BITS = log2(radix). template FMT_CONSTEXPR auto count_digits(UInt n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated() && num_bits() == 32) return (FMT_BUILTIN_CLZ(static_cast(n) | 1) ^ 31) / BITS + 1; #endif // Lambda avoids unreachable code warnings from NVHPC. return [](UInt m) { int num_digits = 0; do { ++num_digits; } while ((m >>= BITS) != 0); return num_digits; }(n); } #ifdef FMT_BUILTIN_CLZ // It is a separate function rather than a part of count_digits to workaround // the lack of static constexpr in constexpr functions. FMT_INLINE auto do_count_digits(uint32_t n) -> int { // An optimization by Kendall Willets from https://bit.ly/3uOIQrB. // This increments the upper 32 bits (log10(T) - 1) when >= T is added. # define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T) static constexpr uint64_t table[] = { FMT_INC(0), FMT_INC(0), FMT_INC(0), // 8 FMT_INC(10), FMT_INC(10), FMT_INC(10), // 64 FMT_INC(100), FMT_INC(100), FMT_INC(100), // 512 FMT_INC(1000), FMT_INC(1000), FMT_INC(1000), // 4096 FMT_INC(10000), FMT_INC(10000), FMT_INC(10000), // 32k FMT_INC(100000), FMT_INC(100000), FMT_INC(100000), // 256k FMT_INC(1000000), FMT_INC(1000000), FMT_INC(1000000), // 2048k FMT_INC(10000000), FMT_INC(10000000), FMT_INC(10000000), // 16M FMT_INC(100000000), FMT_INC(100000000), FMT_INC(100000000), // 128M FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000), // 1024M FMT_INC(1000000000), FMT_INC(1000000000) // 4B }; auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31]; return static_cast((n + inc) >> 32); } #endif // Optional version of count_digits for better performance on 32-bit platforms. FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated() && !FMT_OPTIMIZE_SIZE) return do_count_digits(n); #endif return count_digits_fallback(n); } template constexpr auto digits10() noexcept -> int { return std::numeric_limits::digits10; } template <> constexpr auto digits10() noexcept -> int { return 38; } template <> constexpr auto digits10() noexcept -> int { return 38; } template struct thousands_sep_result { std::string grouping; Char thousands_sep; }; template FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result; template inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { auto result = thousands_sep_impl(loc); return {result.grouping, Char(result.thousands_sep)}; } template <> inline auto thousands_sep(locale_ref loc) -> thousands_sep_result { return thousands_sep_impl(loc); } template FMT_API auto decimal_point_impl(locale_ref loc) -> Char; template inline auto decimal_point(locale_ref loc) -> Char { return Char(decimal_point_impl(loc)); } template <> inline auto decimal_point(locale_ref loc) -> wchar_t { return decimal_point_impl(loc); } #ifndef FMT_HEADER_ONLY FMT_BEGIN_EXPORT extern template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; extern template FMT_API auto thousands_sep_impl(locale_ref) -> thousands_sep_result; extern template FMT_API auto decimal_point_impl(locale_ref) -> char; extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t; FMT_END_EXPORT #endif // FMT_HEADER_ONLY // Compares two characters for equality. template auto equal2(const Char* lhs, const char* rhs) -> bool { return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]); } inline auto equal2(const char* lhs, const char* rhs) -> bool { return memcmp(lhs, rhs, 2) == 0; } // Writes a two-digit value to out. template FMT_CONSTEXPR20 FMT_INLINE void write2digits(Char* out, size_t value) { if (!is_constant_evaluated() && std::is_same::value && !FMT_OPTIMIZE_SIZE) { memcpy(out, digits2(value), 2); return; } *out++ = static_cast('0' + value / 10); *out = static_cast('0' + value % 10); } // Formats a decimal unsigned integer value writing to out pointing to a buffer // of specified size. The caller must ensure that the buffer is large enough. template FMT_CONSTEXPR20 auto do_format_decimal(Char* out, UInt value, int size) -> Char* { FMT_ASSERT(size >= count_digits(value), "invalid digit count"); unsigned n = to_unsigned(size); while (value >= 100) { // Integer division is slow so do it for a group of two digits instead // of for every digit. The idea comes from the talk by Alexandrescu // "Three Optimization Tips for C++". See speed-test for a comparison. n -= 2; write2digits(out + n, static_cast(value % 100)); value /= 100; } if (value >= 10) { n -= 2; write2digits(out + n, static_cast(value)); } else { out[--n] = static_cast('0' + value); } return out + n; } template FMT_CONSTEXPR FMT_INLINE auto format_decimal(Char* out, UInt value, int num_digits) -> Char* { do_format_decimal(out, value, num_digits); return out + num_digits; } template >::value)> FMT_CONSTEXPR auto format_decimal(OutputIt out, UInt value, int num_digits) -> OutputIt { if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { do_format_decimal(ptr, value, num_digits); return out; } // Buffer is large enough to hold all digits (digits10 + 1). char buffer[digits10() + 1]; if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0'); do_format_decimal(buffer, value, num_digits); return copy_noinline(buffer, buffer + num_digits, out); } template FMT_CONSTEXPR auto do_format_base2e(int base_bits, Char* out, UInt value, int size, bool upper = false) -> Char* { out += size; do { const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; unsigned digit = static_cast(value & ((1u << base_bits) - 1)); *--out = static_cast(base_bits < 4 ? static_cast('0' + digit) : digits[digit]); } while ((value >>= base_bits) != 0); return out; } // Formats an unsigned integer in the power of two base (binary, octal, hex). template FMT_CONSTEXPR auto format_base2e(int base_bits, Char* out, UInt value, int num_digits, bool upper = false) -> Char* { do_format_base2e(base_bits, out, value, num_digits, upper); return out + num_digits; } template ::value)> FMT_CONSTEXPR inline auto format_base2e(int base_bits, OutputIt out, UInt value, int num_digits, bool upper = false) -> OutputIt { if (auto ptr = to_pointer(out, to_unsigned(num_digits))) { format_base2e(base_bits, ptr, value, num_digits, upper); return out; } // Make buffer large enough for any base. char buffer[num_bits()]; if (is_constant_evaluated()) fill_n(buffer, sizeof(buffer), '\0'); format_base2e(base_bits, buffer, value, num_digits, upper); return detail::copy_noinline(buffer, buffer + num_digits, out); } // A converter from UTF-8 to UTF-16. class utf8_to_utf16 { private: basic_memory_buffer buffer_; public: FMT_API explicit utf8_to_utf16(string_view s); inline operator basic_string_view() const { return {&buffer_[0], size()}; } inline auto size() const -> size_t { return buffer_.size() - 1; } inline auto c_str() const -> const wchar_t* { return &buffer_[0]; } inline auto str() const -> std::wstring { return {&buffer_[0], size()}; } }; enum class to_utf8_error_policy { abort, replace }; // A converter from UTF-16/UTF-32 (host endian) to UTF-8. template class to_utf8 { private: Buffer buffer_; public: to_utf8() {} explicit to_utf8(basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) { static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4, "expected utf16 or utf32"); if (!convert(s, policy)) { FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" : "invalid utf32")); } } operator string_view() const { return string_view(&buffer_[0], size()); } auto size() const -> size_t { return buffer_.size() - 1; } auto c_str() const -> const char* { return &buffer_[0]; } auto str() const -> std::string { return std::string(&buffer_[0], size()); } // Performs conversion returning a bool instead of throwing exception on // conversion error. This method may still throw in case of memory allocation // error. auto convert(basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool { if (!convert(buffer_, s, policy)) return false; buffer_.push_back(0); return true; } static auto convert(Buffer& buf, basic_string_view s, to_utf8_error_policy policy = to_utf8_error_policy::abort) -> bool { for (auto p = s.begin(); p != s.end(); ++p) { uint32_t c = static_cast(*p); if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) { // Handle a surrogate pair. ++p; if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) { if (policy == to_utf8_error_policy::abort) return false; buf.append(string_view("\xEF\xBF\xBD")); --p; continue; } c = (c << 10) + static_cast(*p) - 0x35fdc00; } if (c < 0x80) { buf.push_back(static_cast(c)); } else if (c < 0x800) { buf.push_back(static_cast(0xc0 | (c >> 6))); buf.push_back(static_cast(0x80 | (c & 0x3f))); } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) { buf.push_back(static_cast(0xe0 | (c >> 12))); buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); buf.push_back(static_cast(0x80 | (c & 0x3f))); } else if (c >= 0x10000 && c <= 0x10ffff) { buf.push_back(static_cast(0xf0 | (c >> 18))); buf.push_back(static_cast(0x80 | ((c & 0x3ffff) >> 12))); buf.push_back(static_cast(0x80 | ((c & 0xfff) >> 6))); buf.push_back(static_cast(0x80 | (c & 0x3f))); } else { return false; } } return true; } }; // Computes 128-bit result of multiplication of two 64-bit unsigned integers. FMT_INLINE auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback { #if FMT_USE_INT128 auto p = static_cast(x) * static_cast(y); return {static_cast(p >> 64), static_cast(p)}; #elif defined(_MSC_VER) && defined(_M_X64) auto hi = uint64_t(); auto lo = _umul128(x, y, &hi); return {hi, lo}; #else const uint64_t mask = static_cast(max_value()); uint64_t a = x >> 32; uint64_t b = x & mask; uint64_t c = y >> 32; uint64_t d = y & mask; uint64_t ac = a * c; uint64_t bc = b * c; uint64_t ad = a * d; uint64_t bd = b * d; uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask); return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32), (intermediate << 32) + (bd & mask)}; #endif } namespace dragonbox { // Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from // https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1. inline auto floor_log10_pow2(int e) noexcept -> int { FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent"); static_assert((-1 >> 1) == -1, "right shift is not arithmetic"); return (e * 315653) >> 20; } inline auto floor_log2_pow10(int e) noexcept -> int { FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent"); return (e * 1741647) >> 19; } // Computes upper 64 bits of multiplication of two 64-bit unsigned integers. inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t { #if FMT_USE_INT128 auto p = static_cast(x) * static_cast(y); return static_cast(p >> 64); #elif defined(_MSC_VER) && defined(_M_X64) return __umulh(x, y); #else return umul128(x, y).high(); #endif } // Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a // 128-bit unsigned integer. inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept -> uint128_fallback { uint128_fallback r = umul128(x, y.high()); r += umul128_upper64(x, y.low()); return r; } FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback; // Type-specific information that Dragonbox uses. template struct float_info; template <> struct float_info { using carrier_uint = uint32_t; static const int exponent_bits = 8; static const int kappa = 1; static const int big_divisor = 100; static const int small_divisor = 10; static const int min_k = -31; static const int max_k = 46; static const int shorter_interval_tie_lower_threshold = -35; static const int shorter_interval_tie_upper_threshold = -35; }; template <> struct float_info { using carrier_uint = uint64_t; static const int exponent_bits = 11; static const int kappa = 2; static const int big_divisor = 1000; static const int small_divisor = 100; static const int min_k = -292; static const int max_k = 341; static const int shorter_interval_tie_lower_threshold = -77; static const int shorter_interval_tie_upper_threshold = -77; }; // An 80- or 128-bit floating point number. template struct float_info::digits == 64 || std::numeric_limits::digits == 113 || is_float128::value>> { using carrier_uint = detail::uint128_t; static const int exponent_bits = 15; }; // A double-double floating point number. template struct float_info::value>> { using carrier_uint = detail::uint128_t; }; template struct decimal_fp { using significand_type = typename float_info::carrier_uint; significand_type significand; int exponent; }; template FMT_API auto to_decimal(T x) noexcept -> decimal_fp; } // namespace dragonbox // Returns true iff Float has the implicit bit which is not stored. template constexpr auto has_implicit_bit() -> bool { // An 80-bit FP number has a 64-bit significand an no implicit bit. return std::numeric_limits::digits != 64; } // Returns the number of significand bits stored in Float. The implicit bit is // not counted since it is not stored. template constexpr auto num_significand_bits() -> int { // std::numeric_limits may not support __float128. return is_float128() ? 112 : (std::numeric_limits::digits - (has_implicit_bit() ? 1 : 0)); } template constexpr auto exponent_mask() -> typename dragonbox::float_info::carrier_uint { using float_uint = typename dragonbox::float_info::carrier_uint; return ((float_uint(1) << dragonbox::float_info::exponent_bits) - 1) << num_significand_bits(); } template constexpr auto exponent_bias() -> int { // std::numeric_limits may not support __float128. return is_float128() ? 16383 : std::numeric_limits::max_exponent - 1; } FMT_CONSTEXPR inline auto compute_exp_size(int exp) -> int { auto prefix_size = 2; // sign + 'e' auto abs_exp = exp >= 0 ? exp : -exp; if (abs_exp < 100) return prefix_size + 2; return prefix_size + (abs_exp >= 1000 ? 4 : 3); } // Writes the exponent exp in the form "[+-]d{2,3}" to buffer. template FMT_CONSTEXPR auto write_exponent(int exp, OutputIt out) -> OutputIt { FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range"); if (exp < 0) { *out++ = static_cast('-'); exp = -exp; } else { *out++ = static_cast('+'); } auto uexp = static_cast(exp); if (is_constant_evaluated()) { if (uexp < 10) *out++ = '0'; return format_decimal(out, uexp, count_digits(uexp)); } if (uexp >= 100u) { const char* top = digits2(uexp / 100); if (uexp >= 1000u) *out++ = static_cast(top[0]); *out++ = static_cast(top[1]); uexp %= 100; } const char* d = digits2(uexp); *out++ = static_cast(d[0]); *out++ = static_cast(d[1]); return out; } // A floating-point number f * pow(2, e) where F is an unsigned type. template struct basic_fp { F f; int e; static constexpr int num_significand_bits = static_cast(sizeof(F) * num_bits()); constexpr basic_fp() : f(0), e(0) {} constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {} // Constructs fp from an IEEE754 floating-point number. template FMT_CONSTEXPR basic_fp(Float n) { assign(n); } // Assigns n to this and return true iff predecessor is closer than successor. template ::value)> FMT_CONSTEXPR auto assign(Float n) -> bool { static_assert(std::numeric_limits::digits <= 113, "unsupported FP"); // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename dragonbox::float_info::carrier_uint; const auto num_float_significand_bits = detail::num_significand_bits(); const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; const auto significand_mask = implicit_bit - 1; auto u = bit_cast(n); f = static_cast(u & significand_mask); auto biased_e = static_cast((u & exponent_mask()) >> num_float_significand_bits); // The predecessor is closer if n is a normalized power of 2 (f == 0) // other than the smallest normalized number (biased_e > 1). auto is_predecessor_closer = f == 0 && biased_e > 1; if (biased_e == 0) biased_e = 1; // Subnormals use biased exponent 1 (min exponent). else if (has_implicit_bit()) f += static_cast(implicit_bit); e = biased_e - exponent_bias() - num_float_significand_bits; if (!has_implicit_bit()) ++e; return is_predecessor_closer; } template ::value)> FMT_CONSTEXPR auto assign(Float n) -> bool { static_assert(std::numeric_limits::is_iec559, "unsupported FP"); return assign(static_cast(n)); } }; using fp = basic_fp; // Normalizes the value converted from double and multiplied by (1 << SHIFT). template FMT_CONSTEXPR auto normalize(basic_fp value) -> basic_fp { // Handle subnormals. const auto implicit_bit = F(1) << num_significand_bits(); const auto shifted_implicit_bit = implicit_bit << SHIFT; while ((value.f & shifted_implicit_bit) == 0) { value.f <<= 1; --value.e; } // Subtract 1 to account for hidden bit. const auto offset = basic_fp::num_significand_bits - num_significand_bits() - SHIFT - 1; value.f <<= offset; value.e -= offset; return value; } // Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking. FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t { #if FMT_USE_INT128 auto product = static_cast<__uint128_t>(lhs) * rhs; auto f = static_cast(product >> 64); return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f; #else // Multiply 32-bit parts of significands. uint64_t mask = (1ULL << 32) - 1; uint64_t a = lhs >> 32, b = lhs & mask; uint64_t c = rhs >> 32, d = rhs & mask; uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; // Compute mid 64-bit of result and round. uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); return ac + (ad >> 32) + (bc >> 32) + (mid >> 32); #endif } FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp { return {multiply(x.f, y.f), x.e + y.e + 64}; } template () == num_bits()> using convert_float_result = conditional_t::value || doublish, double, T>; template constexpr auto convert_float(T value) -> convert_float_result { return static_cast>(value); } template auto select(T true_value, F) -> T { return true_value; } template auto select(T, F false_value) -> F { return false_value; } template FMT_CONSTEXPR FMT_NOINLINE auto fill(OutputIt it, size_t n, const basic_specs& specs) -> OutputIt { auto fill_size = specs.fill_size(); if (fill_size == 1) return detail::fill_n(it, n, specs.fill_unit()); if (const Char* data = specs.fill()) { for (size_t i = 0; i < n; ++i) it = copy(data, data + fill_size, it); } return it; } // Writes the output of f, padded according to format specifications in specs. // size: output size in code units. // width: output display width in (terminal) column positions. template FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(default_align == align::left || default_align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = default_align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[static_cast(specs.align())]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill_size()); if (left_padding != 0) it = fill(it, left_padding, specs); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs); return base_iterator(out, it); } template constexpr auto write_padded(OutputIt out, const format_specs& specs, size_t size, F&& f) -> OutputIt { return write_padded(out, specs, size, size, f); } template FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes, const format_specs& specs = {}) -> OutputIt { return write_padded( out, specs, bytes.size(), [bytes](reserve_iterator it) { const char* data = bytes.data(); return copy(data, data + bytes.size(), it); }); } template auto write_ptr(OutputIt out, UIntPtr value, const format_specs* specs) -> OutputIt { int num_digits = count_digits<4>(value); auto size = to_unsigned(num_digits) + size_t(2); auto write = [=](reserve_iterator it) { *it++ = static_cast('0'); *it++ = static_cast('x'); return format_base2e(4, it, value, num_digits); }; return specs ? write_padded(out, *specs, size, write) : base_iterator(out, write(reserve(out, size))); } // Returns true iff the code point cp is printable. FMT_API auto is_printable(uint32_t cp) -> bool; inline auto needs_escape(uint32_t cp) -> bool { if (cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\') return true; if (const_check(FMT_OPTIMIZE_SIZE > 1)) return false; return !is_printable(cp); } template struct find_escape_result { const Char* begin; const Char* end; uint32_t cp; }; template auto find_escape(const Char* begin, const Char* end) -> find_escape_result { for (; begin != end; ++begin) { uint32_t cp = static_cast>(*begin); if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue; if (needs_escape(cp)) return {begin, begin + 1, cp}; } return {begin, nullptr, 0}; } inline auto find_escape(const char* begin, const char* end) -> find_escape_result { if (const_check(!use_utf8)) return find_escape(begin, end); auto result = find_escape_result{end, nullptr, 0}; for_each_codepoint(string_view(begin, to_unsigned(end - begin)), [&](uint32_t cp, string_view sv) { if (needs_escape(cp)) { result = {sv.begin(), sv.end(), cp}; return false; } return true; }); return result; } template auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt { *out++ = static_cast('\\'); *out++ = static_cast(prefix); Char buf[width]; fill_n(buf, width, static_cast('0')); format_base2e(4, buf, cp, width); return copy(buf, buf + width, out); } template auto write_escaped_cp(OutputIt out, const find_escape_result& escape) -> OutputIt { auto c = static_cast(escape.cp); switch (escape.cp) { case '\n': *out++ = static_cast('\\'); c = static_cast('n'); break; case '\r': *out++ = static_cast('\\'); c = static_cast('r'); break; case '\t': *out++ = static_cast('\\'); c = static_cast('t'); break; case '"': FMT_FALLTHROUGH; case '\'': FMT_FALLTHROUGH; case '\\': *out++ = static_cast('\\'); break; default: if (escape.cp < 0x100) return write_codepoint<2, Char>(out, 'x', escape.cp); if (escape.cp < 0x10000) return write_codepoint<4, Char>(out, 'u', escape.cp); if (escape.cp < 0x110000) return write_codepoint<8, Char>(out, 'U', escape.cp); for (Char escape_char : basic_string_view( escape.begin, to_unsigned(escape.end - escape.begin))) { out = write_codepoint<2, Char>(out, 'x', static_cast(escape_char) & 0xFF); } return out; } *out++ = c; return out; } template auto write_escaped_string(OutputIt out, basic_string_view str) -> OutputIt { *out++ = static_cast('"'); auto begin = str.begin(), end = str.end(); do { auto escape = find_escape(begin, end); out = copy(begin, escape.begin, out); begin = escape.end; if (!begin) break; out = write_escaped_cp(out, escape); } while (begin != end); *out++ = static_cast('"'); return out; } template auto write_escaped_char(OutputIt out, Char v) -> OutputIt { Char v_array[1] = {v}; *out++ = static_cast('\''); if ((needs_escape(static_cast(v)) && v != static_cast('"')) || v == static_cast('\'')) { out = write_escaped_cp(out, find_escape_result{v_array, v_array + 1, static_cast(v)}); } else { *out++ = v; } *out++ = static_cast('\''); return out; } template FMT_CONSTEXPR auto write_char(OutputIt out, Char value, const format_specs& specs) -> OutputIt { bool is_debug = specs.type() == presentation_type::debug; return write_padded(out, specs, 1, [=](reserve_iterator it) { if (is_debug) return write_escaped_char(it, value); *it++ = value; return it; }); } template class digit_grouping { private: std::string grouping_; std::basic_string thousands_sep_; struct next_state { std::string::const_iterator group; int pos; }; auto initial_state() const -> next_state { return {grouping_.begin(), 0}; } // Returns the next digit group separator position. auto next(next_state& state) const -> int { if (thousands_sep_.empty()) return max_value(); if (state.group == grouping_.end()) return state.pos += grouping_.back(); if (*state.group <= 0 || *state.group == max_value()) return max_value(); state.pos += *state.group++; return state.pos; } public: explicit digit_grouping(locale_ref loc, bool localized = true) { if (!localized) return; auto sep = thousands_sep(loc); grouping_ = sep.grouping; if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep); } digit_grouping(std::string grouping, std::basic_string sep) : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {} auto has_separator() const -> bool { return !thousands_sep_.empty(); } auto count_separators(int num_digits) const -> int { int count = 0; auto state = initial_state(); while (num_digits > next(state)) ++count; return count; } // Applies grouping to digits and writes the output to out. template auto apply(Out out, basic_string_view digits) const -> Out { auto num_digits = static_cast(digits.size()); auto separators = basic_memory_buffer(); separators.push_back(0); auto state = initial_state(); while (int i = next(state)) { if (i >= num_digits) break; separators.push_back(i); } for (int i = 0, sep_index = static_cast(separators.size() - 1); i < num_digits; ++i) { if (num_digits - i == separators[sep_index]) { out = copy(thousands_sep_.data(), thousands_sep_.data() + thousands_sep_.size(), out); --sep_index; } *out++ = static_cast(digits[to_unsigned(i)]); } return out; } }; FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) { prefix |= prefix != 0 ? value << 8 : value; prefix += (1u + (value > 0xff ? 1 : 0)) << 24; } // Writes a decimal integer with digit grouping. template auto write_int(OutputIt out, UInt value, unsigned prefix, const format_specs& specs, const digit_grouping& grouping) -> OutputIt { static_assert(std::is_same, UInt>::value, ""); int num_digits = 0; auto buffer = memory_buffer(); switch (specs.type()) { default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH; case presentation_type::none: case presentation_type::dec: num_digits = count_digits(value); format_decimal(appender(buffer), value, num_digits); break; case presentation_type::hex: if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0'); num_digits = count_digits<4>(value); format_base2e(4, appender(buffer), value, num_digits, specs.upper()); break; case presentation_type::oct: num_digits = count_digits<3>(value); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. if (specs.alt() && specs.precision <= num_digits && value != 0) prefix_append(prefix, '0'); format_base2e(3, appender(buffer), value, num_digits); break; case presentation_type::bin: if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0'); num_digits = count_digits<1>(value); format_base2e(1, appender(buffer), value, num_digits); break; case presentation_type::chr: return write_char(out, static_cast(value), specs); } unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) + to_unsigned(grouping.count_separators(num_digits)); return write_padded( out, specs, size, size, [&](reserve_iterator it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); return grouping.apply(it, string_view(buffer.data(), buffer.size())); }); } #if FMT_USE_LOCALE // Writes a localized value. FMT_API auto write_loc(appender out, loc_value value, const format_specs& specs, locale_ref loc) -> bool; auto write_loc(basic_appender out, loc_value value, const format_specs& specs, locale_ref loc) -> bool; #endif template inline auto write_loc(OutputIt, const loc_value&, const format_specs&, locale_ref) -> bool { return false; } template struct write_int_arg { UInt abs_value; unsigned prefix; }; template FMT_CONSTEXPR auto make_write_int_arg(T value, sign s) -> write_int_arg> { auto prefix = 0u; auto abs_value = static_cast>(value); if (is_negative(value)) { prefix = 0x01000000 | '-'; abs_value = 0 - abs_value; } else { constexpr unsigned prefixes[4] = {0, 0, 0x1000000u | '+', 0x1000000u | ' '}; prefix = prefixes[static_cast(s)]; } return {abs_value, prefix}; } template struct loc_writer { basic_appender out; const format_specs& specs; std::basic_string sep; std::string grouping; std::basic_string decimal_point; template ::value)> auto operator()(T value) -> bool { auto arg = make_write_int_arg(value, specs.sign()); write_int(out, static_cast>(arg.abs_value), arg.prefix, specs, digit_grouping(grouping, sep)); return true; } template ::value)> auto operator()(T) -> bool { return false; } }; // Size and padding computation separate from write_int to avoid template bloat. struct size_padding { unsigned size; unsigned padding; FMT_CONSTEXPR size_padding(int num_digits, unsigned prefix, const format_specs& specs) : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) { if (specs.align() == align::numeric) { auto width = to_unsigned(specs.width); if (width > size) { padding = width - size; size = width; } } else if (specs.precision > num_digits) { size = (prefix >> 24) + to_unsigned(specs.precision); padding = to_unsigned(specs.precision - num_digits); } } }; template FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg arg, const format_specs& specs) -> OutputIt { static_assert(std::is_same>::value, ""); constexpr size_t buffer_size = num_bits(); char buffer[buffer_size]; if (is_constant_evaluated()) fill_n(buffer, buffer_size, '\0'); const char* begin = nullptr; const char* end = buffer + buffer_size; auto abs_value = arg.abs_value; auto prefix = arg.prefix; switch (specs.type()) { default: FMT_ASSERT(false, ""); FMT_FALLTHROUGH; case presentation_type::none: case presentation_type::dec: begin = do_format_decimal(buffer, abs_value, buffer_size); break; case presentation_type::hex: begin = do_format_base2e(4, buffer, abs_value, buffer_size, specs.upper()); if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'X' : 'x') << 8 | '0'); break; case presentation_type::oct: { begin = do_format_base2e(3, buffer, abs_value, buffer_size); // Octal prefix '0' is counted as a digit, so only add it if precision // is not greater than the number of digits. auto num_digits = end - begin; if (specs.alt() && specs.precision <= num_digits && abs_value != 0) prefix_append(prefix, '0'); break; } case presentation_type::bin: begin = do_format_base2e(1, buffer, abs_value, buffer_size); if (specs.alt()) prefix_append(prefix, unsigned(specs.upper() ? 'B' : 'b') << 8 | '0'); break; case presentation_type::chr: return write_char(out, static_cast(abs_value), specs); } // Write an integer in the format // // prefix contains chars in three lower bytes and the size in the fourth byte. int num_digits = static_cast(end - begin); // Slightly faster check for specs.width == 0 && specs.precision == -1. if ((specs.width | (specs.precision + 1)) == 0) { auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24)); for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); return base_iterator(out, copy(begin, end, it)); } auto sp = size_padding(num_digits, prefix, specs); unsigned padding = sp.padding; return write_padded( out, specs, sp.size, [=](reserve_iterator it) { for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8) *it++ = static_cast(p & 0xff); it = detail::fill_n(it, padding, static_cast('0')); return copy(begin, end, it); }); } template FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(OutputIt out, write_int_arg arg, const format_specs& specs) -> OutputIt { return write_int(out, arg, specs); } template ::value && !std::is_same::value && !std::is_same::value)> FMT_CONSTEXPR FMT_INLINE auto write(basic_appender out, T value, const format_specs& specs, locale_ref loc) -> basic_appender { if (specs.localized() && write_loc(out, value, specs, loc)) return out; return write_int_noinline(out, make_write_int_arg(value, specs.sign()), specs); } // An inlined version of write used in format string compilation. template ::value && !std::is_same::value && !std::is_same::value && !std::is_same>::value)> FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value, const format_specs& specs, locale_ref loc) -> OutputIt { if (specs.localized() && write_loc(out, value, specs, loc)) return out; return write_int(out, make_write_int_arg(value, specs.sign()), specs); } template FMT_CONSTEXPR auto write(OutputIt out, Char value, const format_specs& specs, locale_ref loc = {}) -> OutputIt { // char is formatted as unsigned char for consistency across platforms. using unsigned_type = conditional_t::value, unsigned char, unsigned>; return check_char_specs(specs) ? write_char(out, value, specs) : write(out, static_cast(value), specs, loc); } template ::value)> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, const format_specs& specs) -> OutputIt { bool is_debug = specs.type() == presentation_type::debug; if (specs.precision < 0 && specs.width == 0) { auto&& it = reserve(out, s.size()); return is_debug ? write_escaped_string(it, s) : copy(s, it); } size_t display_width_limit = specs.precision < 0 ? SIZE_MAX : to_unsigned(specs.precision); size_t display_width = !is_debug || specs.precision == 0 ? 0 : 1; // Account for opening '"'. size_t size = !is_debug || specs.precision == 0 ? 0 : 1; for_each_codepoint(s, [&](uint32_t cp, string_view sv) { if (is_debug && needs_escape(cp)) { counting_buffer buf; write_escaped_cp(basic_appender(buf), find_escape_result{sv.begin(), sv.end(), cp}); // We're reinterpreting bytes as display width. That's okay // because write_escaped_cp() only writes ASCII characters. size_t cp_width = buf.count(); if (display_width + cp_width <= display_width_limit) { display_width += cp_width; size += cp_width; // If this is the end of the string, account for closing '"'. if (display_width < display_width_limit && sv.end() == s.end()) { ++display_width; ++size; } return true; } size += display_width_limit - display_width; display_width = display_width_limit; return false; } size_t cp_width = display_width_of(cp); if (cp_width + display_width <= display_width_limit) { display_width += cp_width; size += sv.size(); // If this is the end of the string, account for closing '"'. if (is_debug && display_width < display_width_limit && sv.end() == s.end()) { ++display_width; ++size; } return true; } return false; }); struct bounded_output_iterator { reserve_iterator underlying_iterator; size_t bound; FMT_CONSTEXPR auto operator*() -> bounded_output_iterator& { return *this; } FMT_CONSTEXPR auto operator++() -> bounded_output_iterator& { return *this; } FMT_CONSTEXPR auto operator++(int) -> bounded_output_iterator& { return *this; } FMT_CONSTEXPR auto operator=(char c) -> bounded_output_iterator& { if (bound > 0) { *underlying_iterator++ = c; --bound; } return *this; } }; return write_padded( out, specs, size, display_width, [=](reserve_iterator it) { return is_debug ? write_escaped_string(bounded_output_iterator{it, size}, s) .underlying_iterator : copy(s.data(), s.data() + size, it); }); } template ::value)> FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, const format_specs& specs) -> OutputIt { auto data = s.data(); auto size = s.size(); if (specs.precision >= 0 && to_unsigned(specs.precision) < size) size = to_unsigned(specs.precision); bool is_debug = specs.type() == presentation_type::debug; if (is_debug) { auto buf = counting_buffer(); write_escaped_string(basic_appender(buf), s); size = buf.count(); } return write_padded( out, specs, size, [=](reserve_iterator it) { return is_debug ? write_escaped_string(it, s) : copy(data, data + size, it); }); } template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view s, const format_specs& specs, locale_ref) -> OutputIt { return write(out, s, specs); } template FMT_CONSTEXPR auto write(OutputIt out, const Char* s, const format_specs& specs, locale_ref) -> OutputIt { if (specs.type() == presentation_type::pointer) return write_ptr(out, bit_cast(s), &specs); if (!s) report_error("string pointer is null"); return write(out, basic_string_view(s), specs, {}); } template ::value && !std::is_same::value && !std::is_same::value)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { auto abs_value = static_cast>(value); bool negative = is_negative(value); // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer. if (negative) abs_value = ~abs_value + 1; int num_digits = count_digits(abs_value); auto size = (negative ? 1 : 0) + static_cast(num_digits); if (auto ptr = to_pointer(out, size)) { if (negative) *ptr++ = static_cast('-'); format_decimal(ptr, abs_value, num_digits); return out; } if (negative) *out++ = static_cast('-'); return format_decimal(out, abs_value, num_digits); } template FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end, format_specs& specs) -> const Char* { FMT_ASSERT(begin != end, ""); auto alignment = align::none; auto p = begin + code_point_length(begin); if (end - p <= 0) p = begin; for (;;) { switch (to_ascii(*p)) { case '<': alignment = align::left; break; case '>': alignment = align::right; break; case '^': alignment = align::center; break; } if (alignment != align::none) { if (p != begin) { auto c = *begin; if (c == '}') return begin; if (c == '{') { report_error("invalid fill character '{'"); return begin; } specs.set_fill(basic_string_view(begin, to_unsigned(p - begin))); begin = p + 1; } else { ++begin; } break; } else if (p == begin) { break; } p = begin; } specs.set_align(alignment); return begin; } template FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan, format_specs specs, sign s) -> OutputIt { auto str = isnan ? (specs.upper() ? "NAN" : "nan") : (specs.upper() ? "INF" : "inf"); constexpr size_t str_size = 3; auto size = str_size + (s != sign::none ? 1 : 0); // Replace '0'-padding with space for non-finite values. const bool is_zero_fill = specs.fill_size() == 1 && specs.fill_unit() == '0'; if (is_zero_fill) specs.set_fill(' '); return write_padded(out, specs, size, [=](reserve_iterator it) { if (s != sign::none) *it++ = detail::getsign(s); return copy(str, str + str_size, it); }); } // A decimal floating-point number significand * pow(10, exp). struct big_decimal_fp { const char* significand; int significand_size; int exponent; }; constexpr auto get_significand_size(const big_decimal_fp& f) -> int { return f.significand_size; } template inline auto get_significand_size(const dragonbox::decimal_fp& f) -> int { return count_digits(f.significand); } template constexpr auto write_significand(OutputIt out, const char* significand, int significand_size) -> OutputIt { return copy(significand, significand + significand_size, out); } template inline auto write_significand(OutputIt out, UInt significand, int significand_size) -> OutputIt { return format_decimal(out, significand, significand_size); } template FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt { if (!grouping.has_separator()) { out = write_significand(out, significand, significand_size); return detail::fill_n(out, exponent, static_cast('0')); } auto buffer = memory_buffer(); write_significand(appender(buffer), significand, significand_size); detail::fill_n(appender(buffer), exponent, '0'); return grouping.apply(out, string_view(buffer.data(), buffer.size())); } template ::value)> inline auto write_significand(Char* out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> Char* { if (!decimal_point) return format_decimal(out, significand, significand_size); out += significand_size + 1; Char* end = out; int floating_size = significand_size - integral_size; for (int i = floating_size / 2; i > 0; --i) { out -= 2; write2digits(out, static_cast(significand % 100)); significand /= 100; } if (floating_size % 2 != 0) { *--out = static_cast('0' + significand % 10); significand /= 10; } *--out = decimal_point; format_decimal(out - integral_size, significand, integral_size); return end; } template >::value)> inline auto write_significand(OutputIt out, UInt significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { // Buffer is large enough to hold digits (digits10 + 1) and a decimal point. Char buffer[digits10() + 2]; auto end = write_significand(buffer, significand, significand_size, integral_size, decimal_point); return detail::copy_noinline(buffer, end, out); } template FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand, int significand_size, int integral_size, Char decimal_point) -> OutputIt { out = detail::copy_noinline(significand, significand + integral_size, out); if (!decimal_point) return out; *out++ = decimal_point; return detail::copy_noinline(significand + integral_size, significand + significand_size, out); } template FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping& grouping) -> OutputIt { if (!grouping.has_separator()) { return write_significand(out, significand, significand_size, integral_size, decimal_point); } auto buffer = basic_memory_buffer(); write_significand(basic_appender(buffer), significand, significand_size, integral_size, decimal_point); grouping.apply( out, basic_string_view(buffer.data(), to_unsigned(integral_size))); return detail::copy_noinline(buffer.data() + integral_size, buffer.end(), out); } // Numbers with exponents greater or equal to the returned value will use // the exponential notation. template FMT_CONSTEVAL auto exp_upper() -> int { return std::numeric_limits::digits10 != 0 ? min_of(16, std::numeric_limits::digits10 + 1) : 16; } // Use the fixed notation if the exponent is in [-4, exp_upper), // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation. constexpr auto use_fixed(int exp, int exp_upper) -> bool { return exp >= -4 && exp < exp_upper; } template class fallback_digit_grouping { public: constexpr fallback_digit_grouping(locale_ref, bool) {} constexpr auto has_separator() const -> bool { return false; } constexpr auto count_separators(int) const -> int { return 0; } template constexpr auto apply(Out out, basic_string_view) const -> Out { return out; } }; template FMT_CONSTEXPR20 auto write_fixed(OutputIt out, const DecimalFP& f, int significand_size, Char decimal_point, const format_specs& specs, sign s, locale_ref loc = {}) -> OutputIt { using iterator = reserve_iterator; int exp = f.exponent + significand_size; long long size = significand_size + (s != sign::none ? 1 : 0); if (f.exponent >= 0) { // 1234e5 -> 123400000[.0+] size += f.exponent; int num_zeros = specs.precision - exp; abort_fuzzing_if(num_zeros > 5000); if (specs.alt()) { ++size; if (num_zeros <= 0 && specs.type() != presentation_type::fixed) num_zeros = 0; if (num_zeros > 0) size += num_zeros; } auto grouping = Grouping(loc, specs.localized()); size += grouping.count_separators(exp); return write_padded( out, specs, to_unsigned(size), [&](iterator it) { if (s != sign::none) *it++ = detail::getsign(s); it = write_significand(it, f.significand, significand_size, f.exponent, grouping); if (!specs.alt()) return it; *it++ = decimal_point; return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it; }); } if (exp > 0) { // 1234e-2 -> 12.34[0+] int num_zeros = specs.alt() ? specs.precision - significand_size : 0; size += 1 + max_of(num_zeros, 0); auto grouping = Grouping(loc, specs.localized()); size += grouping.count_separators(exp); return write_padded( out, specs, to_unsigned(size), [&](iterator it) { if (s != sign::none) *it++ = detail::getsign(s); it = write_significand(it, f.significand, significand_size, exp, decimal_point, grouping); return num_zeros > 0 ? detail::fill_n(it, num_zeros, Char('0')) : it; }); } // 1234e-6 -> 0.001234 int num_zeros = -exp; if (significand_size == 0 && specs.precision >= 0 && specs.precision < num_zeros) { num_zeros = specs.precision; } bool pointy = num_zeros != 0 || significand_size != 0 || specs.alt(); size += 1 + (pointy ? 1 : 0) + num_zeros; return write_padded( out, specs, to_unsigned(size), [&](iterator it) { if (s != sign::none) *it++ = detail::getsign(s); *it++ = Char('0'); if (!pointy) return it; *it++ = decimal_point; it = detail::fill_n(it, num_zeros, Char('0')); return write_significand(it, f.significand, significand_size); }); } template FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, sign s, int exp_upper, locale_ref loc) -> OutputIt { Char point = specs.localized() ? detail::decimal_point(loc) : Char('.'); int significand_size = get_significand_size(f); int exp = f.exponent + significand_size - 1; if (specs.type() == presentation_type::fixed || (specs.type() != presentation_type::exp && use_fixed(exp, specs.precision > 0 ? specs.precision : exp_upper))) { return write_fixed(out, f, significand_size, point, specs, s, loc); } // Write value in the exponential format. int num_zeros = 0; long long size = significand_size + (s != sign::none ? 1 : 0); if (specs.alt()) { num_zeros = max_of(specs.precision - significand_size, 0); size += num_zeros; } else if (significand_size == 1) { point = Char(); } size += (point ? 1 : 0) + compute_exp_size(exp); char exp_char = specs.upper() ? 'E' : 'e'; auto write = [=](reserve_iterator it) { if (s != sign::none) *it++ = detail::getsign(s); // Insert a decimal point after the first digit and add an exponent. it = write_significand(it, f.significand, significand_size, 1, point); if (num_zeros > 0) it = detail::fill_n(it, num_zeros, Char('0')); *it++ = Char(exp_char); return write_exponent(exp, it); }; auto usize = to_unsigned(size); return specs.width > 0 ? write_padded(out, specs, usize, write) : base_iterator(out, write(reserve(out, usize))); } template FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f, const format_specs& specs, sign s, int exp_upper, locale_ref loc) -> OutputIt { if (is_constant_evaluated()) { return do_write_float>(out, f, specs, s, exp_upper, loc); } else { return do_write_float>(out, f, specs, s, exp_upper, loc); } } template constexpr auto isnan(T value) -> bool { return value != value; // std::isnan doesn't support __float128. } template struct has_isfinite : std::false_type {}; template struct has_isfinite> : std::true_type {}; template ::value&& has_isfinite::value)> FMT_CONSTEXPR20 auto isfinite(T value) -> bool { constexpr T inf = T(std::numeric_limits::infinity()); if (is_constant_evaluated()) return !detail::isnan(value) && value < inf && value > -inf; return std::isfinite(value); } template ::value)> FMT_CONSTEXPR auto isfinite(T value) -> bool { T inf = T(std::numeric_limits::infinity()); // std::isfinite doesn't support __float128. return !detail::isnan(value) && value < inf && value > -inf; } template ::value)> FMT_INLINE FMT_CONSTEXPR auto signbit(T value) -> bool { if (is_constant_evaluated()) { #ifdef __cpp_if_constexpr if constexpr (std::numeric_limits::is_iec559) { auto bits = detail::bit_cast(static_cast(value)); return (bits >> (num_bits() - 1)) != 0; } #endif } return std::signbit(static_cast(value)); } inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) { // Adjust fixed precision by exponent because it is relative to decimal // point. if (exp10 > 0 && precision > max_value() - exp10) FMT_THROW(format_error("number is too big")); precision += exp10; } class bigint { private: // A bigint is a number in the form bigit_[N - 1] ... bigit_[0] * 32^exp_. using bigit = uint32_t; // A big digit. using double_bigit = uint64_t; enum { bigit_bits = num_bits() }; enum { bigits_capacity = 32 }; basic_memory_buffer bigits_; int exp_; friend struct formatter; FMT_CONSTEXPR auto get_bigit(int i) const -> bigit { return i >= exp_ && i < num_bigits() ? bigits_[i - exp_] : 0; } FMT_CONSTEXPR void subtract_bigits(int index, bigit other, bigit& borrow) { auto result = double_bigit(bigits_[index]) - other - borrow; bigits_[index] = static_cast(result); borrow = static_cast(result >> (bigit_bits * 2 - 1)); } FMT_CONSTEXPR void remove_leading_zeros() { int num_bigits = static_cast(bigits_.size()) - 1; while (num_bigits > 0 && bigits_[num_bigits] == 0) --num_bigits; bigits_.resize(to_unsigned(num_bigits + 1)); } // Computes *this -= other assuming aligned bigints and *this >= other. FMT_CONSTEXPR void subtract_aligned(const bigint& other) { FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints"); FMT_ASSERT(compare(*this, other) >= 0, ""); bigit borrow = 0; int i = other.exp_ - exp_; for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) subtract_bigits(i, other.bigits_[j], borrow); if (borrow != 0) subtract_bigits(i, 0, borrow); FMT_ASSERT(borrow == 0, ""); remove_leading_zeros(); } FMT_CONSTEXPR void multiply(uint32_t value) { bigit carry = 0; const double_bigit wide_value = value; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { double_bigit result = bigits_[i] * wide_value + carry; bigits_[i] = static_cast(result); carry = static_cast(result >> bigit_bits); } if (carry != 0) bigits_.push_back(carry); } template ::value || std::is_same::value)> FMT_CONSTEXPR void multiply(UInt value) { using half_uint = conditional_t::value, uint64_t, uint32_t>; const int shift = num_bits() - bigit_bits; const UInt lower = static_cast(value); const UInt upper = value >> num_bits(); UInt carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { UInt result = lower * bigits_[i] + static_cast(carry); carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) + (carry >> bigit_bits); bigits_[i] = static_cast(result); } while (carry != 0) { bigits_.push_back(static_cast(carry)); carry >>= bigit_bits; } } template ::value || std::is_same::value)> FMT_CONSTEXPR void assign(UInt n) { size_t num_bigits = 0; do { bigits_[num_bigits++] = static_cast(n); n >>= bigit_bits; } while (n != 0); bigits_.resize(num_bigits); exp_ = 0; } public: FMT_CONSTEXPR bigint() : exp_(0) {} explicit bigint(uint64_t n) { assign(n); } bigint(const bigint&) = delete; void operator=(const bigint&) = delete; FMT_CONSTEXPR void assign(const bigint& other) { auto size = other.bigits_.size(); bigits_.resize(size); auto data = other.bigits_.data(); copy(data, data + size, bigits_.data()); exp_ = other.exp_; } template FMT_CONSTEXPR void operator=(Int n) { FMT_ASSERT(n > 0, ""); assign(uint64_or_128_t(n)); } FMT_CONSTEXPR auto num_bigits() const -> int { return static_cast(bigits_.size()) + exp_; } FMT_CONSTEXPR auto operator<<=(int shift) -> bigint& { FMT_ASSERT(shift >= 0, ""); exp_ += shift / bigit_bits; shift %= bigit_bits; if (shift == 0) return *this; bigit carry = 0; for (size_t i = 0, n = bigits_.size(); i < n; ++i) { bigit c = bigits_[i] >> (bigit_bits - shift); bigits_[i] = (bigits_[i] << shift) + carry; carry = c; } if (carry != 0) bigits_.push_back(carry); return *this; } template FMT_CONSTEXPR auto operator*=(Int value) -> bigint& { FMT_ASSERT(value > 0, ""); multiply(uint32_or_64_or_128_t(value)); return *this; } friend FMT_CONSTEXPR auto compare(const bigint& b1, const bigint& b2) -> int { int num_bigits1 = b1.num_bigits(), num_bigits2 = b2.num_bigits(); if (num_bigits1 != num_bigits2) return num_bigits1 > num_bigits2 ? 1 : -1; int i = static_cast(b1.bigits_.size()) - 1; int j = static_cast(b2.bigits_.size()) - 1; int end = i - j; if (end < 0) end = 0; for (; i >= end; --i, --j) { bigit b1_bigit = b1.bigits_[i], b2_bigit = b2.bigits_[j]; if (b1_bigit != b2_bigit) return b1_bigit > b2_bigit ? 1 : -1; } if (i != j) return i > j ? 1 : -1; return 0; } // Returns compare(lhs1 + lhs2, rhs). friend FMT_CONSTEXPR auto add_compare(const bigint& lhs1, const bigint& lhs2, const bigint& rhs) -> int { int max_lhs_bigits = max_of(lhs1.num_bigits(), lhs2.num_bigits()); int num_rhs_bigits = rhs.num_bigits(); if (max_lhs_bigits + 1 < num_rhs_bigits) return -1; if (max_lhs_bigits > num_rhs_bigits) return 1; double_bigit borrow = 0; int min_exp = min_of(min_of(lhs1.exp_, lhs2.exp_), rhs.exp_); for (int i = num_rhs_bigits - 1; i >= min_exp; --i) { double_bigit sum = double_bigit(lhs1.get_bigit(i)) + lhs2.get_bigit(i); bigit rhs_bigit = rhs.get_bigit(i); if (sum > rhs_bigit + borrow) return 1; borrow = rhs_bigit + borrow - sum; if (borrow > 1) return -1; borrow <<= bigit_bits; } return borrow != 0 ? -1 : 0; } // Assigns pow(10, exp) to this bigint. FMT_CONSTEXPR20 void assign_pow10(int exp) { FMT_ASSERT(exp >= 0, ""); if (exp == 0) return *this = 1; int bitmask = 1 << (num_bits() - countl_zero(static_cast(exp)) - 1); // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by // repeated squaring and multiplication. *this = 5; bitmask >>= 1; while (bitmask != 0) { square(); if ((exp & bitmask) != 0) *this *= 5; bitmask >>= 1; } *this <<= exp; // Multiply by pow(2, exp) by shifting. } FMT_CONSTEXPR20 void square() { int num_bigits = static_cast(bigits_.size()); int num_result_bigits = 2 * num_bigits; basic_memory_buffer n(std::move(bigits_)); bigits_.resize(to_unsigned(num_result_bigits)); auto sum = uint128_t(); for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) { // Compute bigit at position bigit_index of the result by adding // cross-product terms n[i] * n[j] such that i + j == bigit_index. for (int i = 0, j = bigit_index; j >= 0; ++i, --j) { // Most terms are multiplied twice which can be optimized in the future. sum += double_bigit(n[i]) * n[j]; } bigits_[bigit_index] = static_cast(sum); sum >>= num_bits(); // Compute the carry. } // Do the same for the top half. for (int bigit_index = num_bigits; bigit_index < num_result_bigits; ++bigit_index) { for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;) sum += double_bigit(n[i++]) * n[j--]; bigits_[bigit_index] = static_cast(sum); sum >>= num_bits(); } remove_leading_zeros(); exp_ *= 2; } // If this bigint has a bigger exponent than other, adds trailing zero to make // exponents equal. This simplifies some operations such as subtraction. FMT_CONSTEXPR void align(const bigint& other) { int exp_difference = exp_ - other.exp_; if (exp_difference <= 0) return; int num_bigits = static_cast(bigits_.size()); bigits_.resize(to_unsigned(num_bigits + exp_difference)); for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j) bigits_[j] = bigits_[i]; fill_n(bigits_.data(), to_unsigned(exp_difference), 0U); exp_ -= exp_difference; } // Divides this bignum by divisor, assigning the remainder to this and // returning the quotient. FMT_CONSTEXPR auto divmod_assign(const bigint& divisor) -> int { FMT_ASSERT(this != &divisor, ""); if (compare(*this, divisor) < 0) return 0; FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, ""); align(divisor); int quotient = 0; do { subtract_aligned(divisor); ++quotient; } while (compare(*this, divisor) >= 0); return quotient; } }; // format_dragon flags. enum dragon { predecessor_closer = 1, fixup = 2, // Run fixup to correct exp10 which can be off by one. fixed = 4, }; // Formats a floating-point number using a variation of the Fixed-Precision // Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White: // https://fmt.dev/papers/p372-steele.pdf. FMT_CONSTEXPR20 inline void format_dragon(basic_fp value, unsigned flags, int num_digits, buffer& buf, int& exp10) { bigint numerator; // 2 * R in (FPP)^2. bigint denominator; // 2 * S in (FPP)^2. // lower and upper are differences between value and corresponding boundaries. bigint lower; // (M^- in (FPP)^2). bigint upper_store; // upper's value if different from lower. bigint* upper = nullptr; // (M^+ in (FPP)^2). // Shift numerator and denominator by an extra bit or two (if lower boundary // is closer) to make lower and upper integers. This eliminates multiplication // by 2 during later computations. bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0; int shift = is_predecessor_closer ? 2 : 1; if (value.e >= 0) { numerator = value.f; numerator <<= value.e + shift; lower = 1; lower <<= value.e; if (is_predecessor_closer) { upper_store = 1; upper_store <<= value.e + 1; upper = &upper_store; } denominator.assign_pow10(exp10); denominator <<= shift; } else if (exp10 < 0) { numerator.assign_pow10(-exp10); lower.assign(numerator); if (is_predecessor_closer) { upper_store.assign(numerator); upper_store <<= 1; upper = &upper_store; } numerator *= value.f; numerator <<= shift; denominator = 1; denominator <<= shift - value.e; } else { numerator = value.f; numerator <<= shift; denominator.assign_pow10(exp10); denominator <<= shift - value.e; lower = 1; if (is_predecessor_closer) { upper_store = 1ULL << 1; upper = &upper_store; } } int even = static_cast((value.f & 1) == 0); if (!upper) upper = &lower; bool shortest = num_digits < 0; if ((flags & dragon::fixup) != 0) { if (add_compare(numerator, *upper, denominator) + even <= 0) { --exp10; numerator *= 10; if (num_digits < 0) { lower *= 10; if (upper != &lower) *upper *= 10; } } if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1); } // Invariant: value == (numerator / denominator) * pow(10, exp10). if (shortest) { // Generate the shortest representation. num_digits = 0; char* data = buf.data(); for (;;) { int digit = numerator.divmod_assign(denominator); bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower. // numerator + upper >[=] pow10: bool high = add_compare(numerator, *upper, denominator) + even > 0; data[num_digits++] = static_cast('0' + digit); if (low || high) { if (!low) { ++data[num_digits - 1]; } else if (high) { int result = add_compare(numerator, numerator, denominator); // Round half to even. if (result > 0 || (result == 0 && (digit % 2) != 0)) ++data[num_digits - 1]; } buf.try_resize(to_unsigned(num_digits)); exp10 -= num_digits - 1; return; } numerator *= 10; lower *= 10; if (upper != &lower) *upper *= 10; } } // Generate the given number of digits. exp10 -= num_digits - 1; if (num_digits <= 0) { auto digit = '0'; if (num_digits == 0) { denominator *= 10; digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0'; } buf.push_back(digit); return; } buf.try_resize(to_unsigned(num_digits)); for (int i = 0; i < num_digits - 1; ++i) { int digit = numerator.divmod_assign(denominator); buf[i] = static_cast('0' + digit); numerator *= 10; } int digit = numerator.divmod_assign(denominator); auto result = add_compare(numerator, numerator, denominator); if (result > 0 || (result == 0 && (digit % 2) != 0)) { if (digit == 9) { const auto overflow = '0' + 10; buf[num_digits - 1] = overflow; // Propagate the carry. for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) { buf[i] = '0'; ++buf[i - 1]; } if (buf[0] == overflow) { buf[0] = '1'; if ((flags & dragon::fixed) != 0) buf.push_back('0'); else ++exp10; } return; } ++digit; } buf[num_digits - 1] = static_cast('0' + digit); } // Formats a floating-point number using the hexfloat format. template ::value)> FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, buffer& buf) { // float is passed as double to reduce the number of instantiations and to // simplify implementation. static_assert(!std::is_same::value, ""); using info = dragonbox::float_info; // Assume Float is in the format [sign][exponent][significand]. using carrier_uint = typename info::carrier_uint; const auto num_float_significand_bits = detail::num_significand_bits(); basic_fp f(value); f.e += num_float_significand_bits; if (!has_implicit_bit()) --f.e; const auto num_fraction_bits = num_float_significand_bits + (has_implicit_bit() ? 1 : 0); const auto num_xdigits = (num_fraction_bits + 3) / 4; const auto leading_shift = ((num_xdigits - 1) * 4); const auto leading_mask = carrier_uint(0xF) << leading_shift; const auto leading_xdigit = static_cast((f.f & leading_mask) >> leading_shift); if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1); int print_xdigits = num_xdigits - 1; if (specs.precision >= 0 && print_xdigits > specs.precision) { const int shift = ((print_xdigits - specs.precision - 1) * 4); const auto mask = carrier_uint(0xF) << shift; const auto v = static_cast((f.f & mask) >> shift); if (v >= 8) { const auto inc = carrier_uint(1) << (shift + 4); f.f += inc; f.f &= ~(inc - 1); } // Check long double overflow if (!has_implicit_bit()) { const auto implicit_bit = carrier_uint(1) << num_float_significand_bits; if ((f.f & implicit_bit) == implicit_bit) { f.f >>= 4; f.e += 4; } } print_xdigits = specs.precision; } char xdigits[num_bits() / 4]; detail::fill_n(xdigits, sizeof(xdigits), '0'); format_base2e(4, xdigits, f.f, num_xdigits, specs.upper()); // Remove zero tail while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits; buf.push_back('0'); buf.push_back(specs.upper() ? 'X' : 'x'); buf.push_back(xdigits[0]); if (specs.alt() || print_xdigits > 0 || print_xdigits < specs.precision) buf.push_back('.'); buf.append(xdigits + 1, xdigits + 1 + print_xdigits); for (; print_xdigits < specs.precision; ++print_xdigits) buf.push_back('0'); buf.push_back(specs.upper() ? 'P' : 'p'); uint32_t abs_e; if (f.e < 0) { buf.push_back('-'); abs_e = static_cast(-f.e); } else { buf.push_back('+'); abs_e = static_cast(f.e); } format_decimal(appender(buf), abs_e, detail::count_digits(abs_e)); } template ::value)> FMT_CONSTEXPR20 void format_hexfloat(Float value, format_specs specs, buffer& buf) { format_hexfloat(static_cast(value), specs, buf); } constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t { // For checking rounding thresholds. // The kth entry is chosen to be the smallest integer such that the // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k. // It is equal to ceil(2^31 + 2^32/10^(k + 1)). // These are stored in a string literal because we cannot have static arrays // in constexpr functions and non-static ones are poorly optimized. return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7" U"\x800001ae\x8000002b"[index]; } template FMT_CONSTEXPR20 auto format_float(Float value, int precision, const format_specs& specs, bool binary32, buffer& buf) -> int { // float is passed as double to reduce the number of instantiations. static_assert(!std::is_same::value, ""); auto converted_value = convert_float(value); const bool fixed = specs.type() == presentation_type::fixed; if (value == 0) { if (precision <= 0 || !fixed) { buf.push_back('0'); return 0; } buf.try_resize(to_unsigned(precision)); fill_n(buf.data(), precision, '0'); return -precision; } int exp = 0; bool use_dragon = true; unsigned dragon_flags = 0; if (!is_fast_float() || is_constant_evaluated()) { const auto inv_log2_10 = 0.3010299956639812; // 1 / log2(10) using info = dragonbox::float_info; const auto f = basic_fp(converted_value); // Compute exp, an approximate power of 10, such that // 10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1). // This is based on log10(value) == log2(value) / log2(10) and approximation // of log2(value) by e + num_fraction_bits idea from double-conversion. auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10; exp = static_cast(e); if (e > exp) ++exp; // Compute ceil. dragon_flags = dragon::fixup; } else { // Extract significand bits and exponent bits. using info = dragonbox::float_info; auto br = bit_cast(static_cast(value)); const uint64_t significand_mask = (static_cast(1) << num_significand_bits()) - 1; uint64_t significand = (br & significand_mask); int exponent = static_cast((br & exponent_mask()) >> num_significand_bits()); if (exponent != 0) { // Check if normal. exponent -= exponent_bias() + num_significand_bits(); significand |= (static_cast(1) << num_significand_bits()); significand <<= 1; } else { // Normalize subnormal inputs. FMT_ASSERT(significand != 0, "zeros should not appear here"); int shift = countl_zero(significand); FMT_ASSERT(shift >= num_bits() - num_significand_bits(), ""); shift -= (num_bits() - num_significand_bits() - 2); exponent = (std::numeric_limits::min_exponent - num_significand_bits()) - shift; significand <<= shift; } // Compute the first several nonzero decimal significand digits. // We call the number we get the first segment. const int k = info::kappa - dragonbox::floor_log10_pow2(exponent); exp = -k; const int beta = exponent + dragonbox::floor_log2_pow10(k); uint64_t first_segment; bool has_more_segments; int digits_in_the_first_segment; { const auto r = dragonbox::umul192_upper128( significand << beta, dragonbox::get_cached_power(k)); first_segment = r.high(); has_more_segments = r.low() != 0; // The first segment can have 18 ~ 19 digits. if (first_segment >= 1000000000000000000ULL) { digits_in_the_first_segment = 19; } else { // When it is of 18-digits, we align it to 19-digits by adding a bogus // zero at the end. digits_in_the_first_segment = 18; first_segment *= 10; } } // Compute the actual number of decimal digits to print. if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment); // Use Dragon4 only when there might be not enough digits in the first // segment. if (digits_in_the_first_segment > precision) { use_dragon = false; if (precision <= 0) { exp += digits_in_the_first_segment; if (precision < 0) { // Nothing to do, since all we have are just leading zeros. buf.try_resize(0); } else { // We may need to round-up. buf.try_resize(1); if ((first_segment | static_cast(has_more_segments)) > 5000000000000000000ULL) { buf[0] = '1'; } else { buf[0] = '0'; } } } // precision <= 0 else { exp += digits_in_the_first_segment - precision; // When precision > 0, we divide the first segment into three // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits // in 32-bits which usually allows faster calculation than in // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize // division-by-constant for large 64-bit divisors, we do it here // manually. The magic number 7922816251426433760 below is equal to // ceil(2^(64+32) / 10^10). const uint32_t first_subsegment = static_cast( dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >> 32); const uint64_t second_third_subsegments = first_segment - first_subsegment * 10000000000ULL; uint64_t prod; uint32_t digits; bool should_round_up; int number_of_digits_to_print = min_of(precision, 9); // Print a 9-digits subsegment, either the first or the second. auto print_subsegment = [&](uint32_t subsegment, char* buffer) { int number_of_digits_printed = 0; // If we want to print an odd number of digits from the subsegment, if ((number_of_digits_to_print & 1) != 0) { // Convert to 64-bit fixed-point fractional form with 1-digit // integer part. The magic number 720575941 is a good enough // approximation of 2^(32 + 24) / 10^8; see // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case // for details. prod = ((subsegment * static_cast(720575941)) >> 24) + 1; digits = static_cast(prod >> 32); *buffer = static_cast('0' + digits); number_of_digits_printed++; } // If we want to print an even number of digits from the // first_subsegment, else { // Convert to 64-bit fixed-point fractional form with 2-digits // integer part. The magic number 450359963 is a good enough // approximation of 2^(32 + 20) / 10^7; see // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case // for details. prod = ((subsegment * static_cast(450359963)) >> 20) + 1; digits = static_cast(prod >> 32); write2digits(buffer, digits); number_of_digits_printed += 2; } // Print all digit pairs. while (number_of_digits_printed < number_of_digits_to_print) { prod = static_cast(prod) * static_cast(100); digits = static_cast(prod >> 32); write2digits(buffer + number_of_digits_printed, digits); number_of_digits_printed += 2; } }; // Print first subsegment. print_subsegment(first_subsegment, buf.data()); // Perform rounding if the first subsegment is the last subsegment to // print. if (precision <= 9) { // Rounding inside the subsegment. // We round-up if: // - either the fractional part is strictly larger than 1/2, or // - the fractional part is exactly 1/2 and the last digit is odd. // We rely on the following observations: // - If fractional_part >= threshold, then the fractional part is // strictly larger than 1/2. // - If the MSB of fractional_part is set, then the fractional part // must be at least 1/2. // - When the MSB of fractional_part is set, either // second_third_subsegments being nonzero or has_more_segments // being true means there are further digits not printed, so the // fractional part is strictly larger than 1/2. if (precision < 9) { uint32_t fractional_part = static_cast(prod); should_round_up = fractional_part >= fractional_part_rounding_thresholds( 8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (second_third_subsegments != 0) | has_more_segments)) != 0; } // Rounding at the subsegment boundary. // In this case, the fractional part is at least 1/2 if and only if // second_third_subsegments >= 5000000000ULL, and is strictly larger // than 1/2 if we further have either second_third_subsegments > // 5000000000ULL or has_more_segments == true. else { should_round_up = second_third_subsegments > 5000000000ULL || (second_third_subsegments == 5000000000ULL && ((digits & 1) != 0 || has_more_segments)); } } // Otherwise, print the second subsegment. else { // Compilers are not aware of how to leverage the maximum value of // second_third_subsegments to find out a better magic number which // allows us to eliminate an additional shift. 1844674407370955162 = // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))). const uint32_t second_subsegment = static_cast(dragonbox::umul128_upper64( second_third_subsegments, 1844674407370955162ULL)); const uint32_t third_subsegment = static_cast(second_third_subsegments) - second_subsegment * 10; number_of_digits_to_print = precision - 9; print_subsegment(second_subsegment, buf.data() + 9); // Rounding inside the subsegment. if (precision < 18) { // The condition third_subsegment != 0 implies that the segment was // of 19 digits, so in this case the third segment should be // consisting of a genuine digit from the input. uint32_t fractional_part = static_cast(prod); should_round_up = fractional_part >= fractional_part_rounding_thresholds( 8 - number_of_digits_to_print) || ((fractional_part >> 31) & ((digits & 1) | (third_subsegment != 0) | has_more_segments)) != 0; } // Rounding at the subsegment boundary. else { // In this case, the segment must be of 19 digits, thus // the third subsegment should be consisting of a genuine digit from // the input. should_round_up = third_subsegment > 5 || (third_subsegment == 5 && ((digits & 1) != 0 || has_more_segments)); } } // Round-up if necessary. if (should_round_up) { ++buf[precision - 1]; for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) { buf[i] = '0'; ++buf[i - 1]; } if (buf[0] > '9') { buf[0] = '1'; if (fixed) buf[precision++] = '0'; else ++exp; } } buf.try_resize(to_unsigned(precision)); } } // if (digits_in_the_first_segment > precision) else { // Adjust the exponent for its use in Dragon4. exp += digits_in_the_first_segment - 1; } } if (use_dragon) { auto f = basic_fp(); bool is_predecessor_closer = binary32 ? f.assign(static_cast(value)) : f.assign(converted_value); if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer; if (fixed) dragon_flags |= dragon::fixed; // Limit precision to the maximum possible number of significant digits in // an IEEE754 double because we don't need to generate zeros. const int max_double_digits = 767; if (precision > max_double_digits) precision = max_double_digits; format_dragon(f, dragon_flags, precision, buf, exp); } if (!fixed && !specs.alt()) { // Remove trailing zeros. auto num_digits = buf.size(); while (num_digits > 0 && buf[num_digits - 1] == '0') { --num_digits; ++exp; } buf.try_resize(num_digits); } return exp; } template ::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs specs, locale_ref loc = {}) -> OutputIt { if (specs.localized() && write_loc(out, value, specs, loc)) return out; // Use signbit because value < 0 is false for NaN. sign s = detail::signbit(value) ? sign::minus : specs.sign(); if (!detail::isfinite(value)) return write_nonfinite(out, detail::isnan(value), specs, s); if (specs.align() == align::numeric && s != sign::none) { *out++ = detail::getsign(s); s = sign::none; if (specs.width != 0) --specs.width; } const int exp_upper = detail::exp_upper(); int precision = specs.precision; if (precision < 0) { if (specs.type() != presentation_type::none) { precision = 6; } else if (is_fast_float::value && !is_constant_evaluated()) { // Use Dragonbox for the shortest format. auto dec = dragonbox::to_decimal(static_cast>(value)); return write_float(out, dec, specs, s, exp_upper, loc); } } memory_buffer buffer; if (specs.type() == presentation_type::hexfloat) { if (s != sign::none) buffer.push_back(detail::getsign(s)); format_hexfloat(convert_float(value), specs, buffer); return write_bytes(out, {buffer.data(), buffer.size()}, specs); } if (specs.type() == presentation_type::exp) { if (precision == max_value()) report_error("number is too big"); else ++precision; if (specs.precision != 0) specs.set_alt(); } else if (specs.type() == presentation_type::fixed) { if (specs.precision != 0) specs.set_alt(); } else if (precision == 0) { precision = 1; } int exp = format_float(convert_float(value), precision, specs, std::is_same(), buffer); specs.precision = precision; auto f = big_decimal_fp{buffer.data(), static_cast(buffer.size()), exp}; return write_float(out, f, specs, s, exp_upper, loc); } template ::value)> FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt { if (is_constant_evaluated()) return write(out, value, format_specs()); auto s = detail::signbit(value) ? sign::minus : sign::none; auto mask = exponent_mask>(); if ((bit_cast(value) & mask) == mask) return write_nonfinite(out, std::isnan(value), {}, s); auto dec = dragonbox::to_decimal(static_cast>(value)); auto significand = dec.significand; int significand_size = count_digits(significand); int exponent = dec.exponent + significand_size - 1; if (use_fixed(exponent, detail::exp_upper())) { return write_fixed>( out, dec, significand_size, Char('.'), {}, s); } // Write value in the exponential format. const char* prefix = "e+"; int abs_exponent = exponent; if (exponent < 0) { abs_exponent = -exponent; prefix = "e-"; } auto has_decimal_point = significand_size != 1; size_t size = std::is_pointer::value ? 0u : to_unsigned((s != sign::none ? 1 : 0) + significand_size + (has_decimal_point ? 1 : 0) + (abs_exponent >= 100 ? 5 : 4)); if (auto ptr = to_pointer(out, size)) { if (s != sign::none) *ptr++ = Char('-'); if (has_decimal_point) { auto begin = ptr; ptr = format_decimal(ptr, significand, significand_size + 1); *begin = begin[1]; begin[1] = '.'; } else { *ptr++ = static_cast('0' + significand); } if (std::is_same::value) { memcpy(ptr, prefix, 2); ptr += 2; } else { *ptr++ = prefix[0]; *ptr++ = prefix[1]; } if (abs_exponent >= 100) { *ptr++ = static_cast('0' + abs_exponent / 100); abs_exponent %= 100; } write2digits(ptr, static_cast(abs_exponent)); return select::value>(ptr + 2, out); } auto it = reserve(out, size); if (s != sign::none) *it++ = Char('-'); // Insert a decimal point after the first digit and add an exponent. it = write_significand(it, significand, significand_size, 1, has_decimal_point ? Char('.') : Char()); *it++ = Char('e'); it = write_exponent(exponent, it); return base_iterator(out, it); } template ::value && !is_fast_float::value)> inline auto write(OutputIt out, T value) -> OutputIt { return write(out, value, {}); } template auto write(OutputIt out, monostate, format_specs = {}, locale_ref = {}) -> OutputIt { FMT_ASSERT(false, ""); return out; } template FMT_CONSTEXPR auto write(OutputIt out, basic_string_view value) -> OutputIt { return copy_noinline(value.begin(), value.end(), out); } template ::value)> constexpr auto write(OutputIt out, const T& value) -> OutputIt { return write(out, to_string_view(value)); } // FMT_ENABLE_IF() condition separated to workaround an MSVC bug. template < typename Char, typename OutputIt, typename T, bool check = std::is_enum::value && !std::is_same::value && mapped_type_constant::value != type::custom_type, FMT_ENABLE_IF(check)> FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt { return write(out, static_cast>(value)); } template ::value)> FMT_CONSTEXPR auto write(OutputIt out, T value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return specs.type() != presentation_type::none && specs.type() != presentation_type::string ? write(out, value ? 1 : 0, specs, {}) : write_bytes(out, value ? "true" : "false", specs); } template FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt { auto it = reserve(out, 1); *it++ = value; return base_iterator(out, it); } template FMT_CONSTEXPR20 auto write(OutputIt out, const Char* value) -> OutputIt { if (value) return write(out, basic_string_view(value)); report_error("string pointer is null"); return out; } template ::value)> auto write(OutputIt out, const T* value, const format_specs& specs = {}, locale_ref = {}) -> OutputIt { return write_ptr(out, bit_cast(value), &specs); } template ::value == type::custom_type && !std::is_fundamental::value)> FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> OutputIt { auto f = formatter(); auto parse_ctx = parse_context({}); f.parse(parse_ctx); auto ctx = basic_format_context(out, {}, {}); return f.format(value, ctx); } template using is_builtin = bool_constant::value || FMT_BUILTIN_TYPES>; // An argument visitor that formats the argument and writes it via the output // iterator. It's a class and not a generic lambda for compatibility with C++11. template struct default_arg_formatter { using context = buffered_context; basic_appender out; void operator()(monostate) { report_error("argument not found"); } template ::value)> void operator()(T value) { write(out, value); } template ::value)> void operator()(T) { FMT_ASSERT(false, ""); } void operator()(typename basic_format_arg::handle h) { // Use a null locale since the default format must be unlocalized. auto parse_ctx = parse_context({}); auto format_ctx = context(out, {}, {}); h.format(parse_ctx, format_ctx); } }; template struct arg_formatter { basic_appender out; const format_specs& specs; FMT_NO_UNIQUE_ADDRESS locale_ref locale; template ::value)> FMT_CONSTEXPR FMT_INLINE void operator()(T value) { detail::write(out, value, specs, locale); } template ::value)> void operator()(T) { FMT_ASSERT(false, ""); } void operator()(typename basic_format_arg>::handle) { // User-defined types are handled separately because they require access // to the parse context. } }; struct dynamic_spec_getter { template ::value)> FMT_CONSTEXPR auto operator()(T value) -> unsigned long long { return is_negative(value) ? ~0ull : static_cast(value); } template ::value)> FMT_CONSTEXPR auto operator()(T) -> unsigned long long { report_error("width/precision is not integer"); return 0; } }; template FMT_CONSTEXPR void handle_dynamic_spec( arg_id_kind kind, int& value, const arg_ref& ref, Context& ctx) { if (kind == arg_id_kind::none) return; auto arg = kind == arg_id_kind::index ? ctx.arg(ref.index) : ctx.arg(ref.name); if (!arg) report_error("argument not found"); unsigned long long result = arg.visit(dynamic_spec_getter()); if (result > to_unsigned(max_value())) report_error("width/precision is out of range"); value = static_cast(result); } #if FMT_USE_NONTYPE_TEMPLATE_ARGS template Str> struct static_named_arg : view { static constexpr auto name = Str.data; const T& value; static_named_arg(const T& v) : value(v) {} }; template Str> struct is_named_arg> : std::true_type {}; template Str> struct is_static_named_arg> : std::true_type { }; template Str> struct udl_arg { template auto operator=(T&& value) const { return static_named_arg(std::forward(value)); } }; #else template struct udl_arg { const Char* str; template auto operator=(T&& value) const -> named_arg { return {str, std::forward(value)}; } }; #endif // FMT_USE_NONTYPE_TEMPLATE_ARGS template struct format_handler { parse_context parse_ctx; buffered_context ctx; void on_text(const Char* begin, const Char* end) { copy_noinline(begin, end, ctx.out()); } FMT_CONSTEXPR auto on_arg_id() -> int { return parse_ctx.next_arg_id(); } FMT_CONSTEXPR auto on_arg_id(int id) -> int { parse_ctx.check_arg_id(id); return id; } FMT_CONSTEXPR auto on_arg_id(basic_string_view id) -> int { parse_ctx.check_arg_id(id); int arg_id = ctx.arg_id(id); if (arg_id < 0) report_error("argument not found"); return arg_id; } FMT_INLINE void on_replacement_field(int id, const Char*) { ctx.arg(id).visit(default_arg_formatter{ctx.out()}); } auto on_format_specs(int id, const Char* begin, const Char* end) -> const Char* { auto arg = ctx.arg(id); if (!arg) report_error("argument not found"); // Not using a visitor for custom types gives better codegen. if (arg.format_custom(begin, parse_ctx, ctx)) return parse_ctx.begin(); auto specs = dynamic_format_specs(); begin = parse_format_specs(begin, end, specs, parse_ctx, arg.type()); if (specs.dynamic()) { handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); } arg.visit(arg_formatter{ctx.out(), specs, ctx.locale()}); return begin; } FMT_NORETURN void on_error(const char* message) { report_error(message); } }; // It is used in format-inl.h and os.cc. using format_func = void (*)(detail::buffer&, int, const char*); FMT_API void do_report_error(format_func func, int error_code, const char* message) noexcept; FMT_API void format_error_code(buffer& out, int error_code, string_view message) noexcept; template template FMT_CONSTEXPR auto native_formatter::format( const T& val, FormatContext& ctx) const -> decltype(ctx.out()) { if (!specs_.dynamic()) return write(ctx.out(), val, specs_, ctx.locale()); auto specs = format_specs(specs_); handle_dynamic_spec(specs.dynamic_width(), specs.width, specs_.width_ref, ctx); handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs_.precision_ref, ctx); return write(ctx.out(), val, specs, ctx.locale()); } } // namespace detail FMT_BEGIN_EXPORT // A generic formatting context with custom output iterator and character // (code unit) support. Char is the format string code unit type which can be // different from OutputIt::value_type. template class generic_context { private: OutputIt out_; basic_format_args args_; locale_ref loc_; public: using char_type = Char; using iterator = OutputIt; enum { builtin_types = FMT_BUILTIN_TYPES }; constexpr generic_context(OutputIt out, basic_format_args args, locale_ref loc = {}) : out_(out), args_(args), loc_(loc) {} generic_context(generic_context&&) = default; generic_context(const generic_context&) = delete; void operator=(const generic_context&) = delete; constexpr auto arg(int id) const -> basic_format_arg { return args_.get(id); } auto arg(basic_string_view name) const -> basic_format_arg { return args_.get(name); } constexpr auto arg_id(basic_string_view name) const -> int { return args_.get_id(name); } constexpr auto out() const -> iterator { return out_; } void advance_to(iterator it) { if (!detail::is_back_insert_iterator()) out_ = it; } constexpr auto locale() const -> locale_ref { return loc_; } }; class loc_value { private: basic_format_arg value_; public: template ::value)> loc_value(T value) : value_(value) {} template ::value)> loc_value(T) {} template auto visit(Visitor&& vis) -> decltype(vis(0)) { return value_.visit(vis); } }; // A locale facet that formats values in UTF-8. // It is parameterized on the locale to avoid the heavy include. template class format_facet : public Locale::facet { private: std::string separator_; std::string grouping_; std::string decimal_point_; protected: virtual auto do_put(appender out, loc_value val, const format_specs& specs) const -> bool; public: static FMT_API typename Locale::id id; explicit format_facet(Locale& loc); explicit format_facet(string_view sep = "", std::string grouping = "\3", std::string decimal_point = ".") : separator_(sep.data(), sep.size()), grouping_(grouping), decimal_point_(decimal_point) {} auto put(appender out, loc_value val, const format_specs& specs) const -> bool { return do_put(out, val, specs); } }; #define FMT_FORMAT_AS(Type, Base) \ template \ struct formatter : formatter { \ template \ FMT_CONSTEXPR auto format(Type value, FormatContext& ctx) const \ -> decltype(ctx.out()) { \ return formatter::format(value, ctx); \ } \ } FMT_FORMAT_AS(signed char, int); FMT_FORMAT_AS(unsigned char, unsigned); FMT_FORMAT_AS(short, int); FMT_FORMAT_AS(unsigned short, unsigned); FMT_FORMAT_AS(long, detail::long_type); FMT_FORMAT_AS(unsigned long, detail::ulong_type); FMT_FORMAT_AS(Char*, const Char*); FMT_FORMAT_AS(detail::std_string_view, basic_string_view); FMT_FORMAT_AS(std::nullptr_t, const void*); FMT_FORMAT_AS(void*, const void*); template struct formatter : formatter, Char> {}; template class formatter, Char> : public formatter, Char> {}; template struct formatter, Char> : formatter {}; template struct formatter, Char> : formatter {}; template struct formatter : detail::native_formatter {}; template struct formatter>> : formatter, Char> { template FMT_CONSTEXPR auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto&& val = format_as(value); // Make an lvalue reference for format. return formatter, Char>::format(val, ctx); } }; /** * Converts `p` to `const void*` for pointer formatting. * * **Example**: * * auto s = fmt::format("{}", fmt::ptr(p)); */ template auto ptr(T p) -> const void* { static_assert(std::is_pointer::value, "fmt::ptr used with non-pointer"); return detail::bit_cast(p); } /** * Converts `e` to the underlying type. * * **Example**: * * enum class color { red, green, blue }; * auto s = fmt::format("{}", fmt::underlying(color::red)); // s == "0" */ template constexpr auto underlying(Enum e) noexcept -> underlying_t { return static_cast>(e); } namespace enums { template ::value)> constexpr auto format_as(Enum e) noexcept -> underlying_t { return static_cast>(e); } } // namespace enums #ifdef __cpp_lib_byte template struct formatter : formatter { static auto format_as(std::byte b) -> unsigned char { return static_cast(b); } template auto format(std::byte b, Context& ctx) const -> decltype(ctx.out()) { return formatter::format(format_as(b), ctx); } }; #endif struct bytes { string_view data; inline explicit bytes(string_view s) : data(s) {} }; template <> struct formatter { private: detail::dynamic_format_specs<> specs_; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::string_type); } template auto format(bytes b, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); return detail::write_bytes(ctx.out(), b.data, specs); } }; // group_digits_view is not derived from view because it copies the argument. template struct group_digits_view { T value; }; /** * Returns a view that formats an integer value using ',' as a * locale-independent thousands separator. * * **Example**: * * fmt::print("{}", fmt::group_digits(12345)); * // Output: "12,345" */ template auto group_digits(T value) -> group_digits_view { return {value}; } template struct formatter> : formatter { private: detail::dynamic_format_specs<> specs_; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::int_type); } template auto format(group_digits_view view, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); auto arg = detail::make_write_int_arg(view.value, specs.sign()); return detail::write_int( ctx.out(), static_cast>(arg.abs_value), arg.prefix, specs, detail::digit_grouping("\3", ",")); } }; template struct nested_view { const formatter* fmt; const T* value; }; template struct formatter, Char> { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return ctx.begin(); } template auto format(nested_view view, FormatContext& ctx) const -> decltype(ctx.out()) { return view.fmt->format(*view.value, ctx); } }; template struct nested_formatter { private: basic_specs specs_; int width_; formatter formatter_; public: constexpr nested_formatter() : width_(0) {} FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; auto specs = format_specs(); it = detail::parse_align(it, end, specs); specs_ = specs; Char c = *it; auto width_ref = detail::arg_ref(); if ((c >= '0' && c <= '9') || c == '{') { it = detail::parse_width(it, end, specs, width_ref, ctx); width_ = specs.width; } ctx.advance_to(it); return formatter_.parse(ctx); } template auto write_padded(FormatContext& ctx, F write) const -> decltype(ctx.out()) { if (width_ == 0) return write(ctx.out()); auto buf = basic_memory_buffer(); write(basic_appender(buf)); auto specs = format_specs(); specs.width = width_; specs.copy_fill_from(specs_); specs.set_align(specs_.align()); return detail::write( ctx.out(), basic_string_view(buf.data(), buf.size()), specs); } auto nested(const T& value) const -> nested_view { return nested_view{&formatter_, &value}; } }; inline namespace literals { #if FMT_USE_NONTYPE_TEMPLATE_ARGS template constexpr auto operator""_a() { using char_t = remove_cvref_t; return detail::udl_arg(); } #else /** * User-defined literal equivalent of `fmt::arg`. * * **Example**: * * using namespace fmt::literals; * fmt::print("The answer is {answer}.", "answer"_a=42); */ constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg { return {s}; } #endif // FMT_USE_NONTYPE_TEMPLATE_ARGS } // namespace literals /// A fast integer formatter. class format_int { private: // Buffer should be large enough to hold all digits (digits10 + 1), // a sign and a null character. enum { buffer_size = std::numeric_limits::digits10 + 3 }; mutable char buffer_[buffer_size]; char* str_; template FMT_CONSTEXPR20 auto format_unsigned(UInt value) -> char* { auto n = static_cast>(value); return detail::do_format_decimal(buffer_, n, buffer_size - 1); } template FMT_CONSTEXPR20 auto format_signed(Int value) -> char* { auto abs_value = static_cast>(value); bool negative = value < 0; if (negative) abs_value = 0 - abs_value; auto begin = format_unsigned(abs_value); if (negative) *--begin = '-'; return begin; } public: FMT_CONSTEXPR20 explicit format_int(int value) : str_(format_signed(value)) {} FMT_CONSTEXPR20 explicit format_int(long value) : str_(format_signed(value)) {} FMT_CONSTEXPR20 explicit format_int(long long value) : str_(format_signed(value)) {} FMT_CONSTEXPR20 explicit format_int(unsigned value) : str_(format_unsigned(value)) {} FMT_CONSTEXPR20 explicit format_int(unsigned long value) : str_(format_unsigned(value)) {} FMT_CONSTEXPR20 explicit format_int(unsigned long long value) : str_(format_unsigned(value)) {} /// Returns the number of characters written to the output buffer. FMT_CONSTEXPR20 auto size() const -> size_t { return detail::to_unsigned(buffer_ - str_ + buffer_size - 1); } /// Returns a pointer to the output buffer content. No terminating null /// character is appended. FMT_CONSTEXPR20 auto data() const -> const char* { return str_; } /// Returns a pointer to the output buffer content with terminating null /// character appended. FMT_CONSTEXPR20 auto c_str() const -> const char* { buffer_[buffer_size - 1] = '\0'; return str_; } /// Returns the content of the output buffer as an `std::string`. inline auto str() const -> std::string { return {str_, size()}; } }; #if FMT_CLANG_ANALYZER # define FMT_STRING_IMPL(s, base) s #else # define FMT_STRING_IMPL(s, base) \ [] { \ /* Use the hidden visibility as a workaround for a GCC bug (#1973). */ \ /* Use a macro-like name to avoid shadowing warnings. */ \ struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base { \ using char_type = fmt::remove_cvref_t; \ constexpr explicit operator fmt::basic_string_view() \ const { \ return fmt::detail::compile_string_to_view(s); \ } \ }; \ using FMT_STRING_VIEW = \ fmt::basic_string_view; \ fmt::detail::ignore_unused(FMT_STRING_VIEW(FMT_COMPILE_STRING())); \ return FMT_COMPILE_STRING(); \ }() #endif // FMT_CLANG_ANALYZER /** * Constructs a legacy compile-time format string from a string literal `s`. * * **Example**: * * // A compile-time error because 'd' is an invalid specifier for strings. * std::string s = fmt::format(FMT_STRING("{:d}"), "foo"); */ #define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string) FMT_API auto vsystem_error(int error_code, string_view fmt, format_args args) -> std::system_error; /** * Constructs `std::system_error` with a message formatted with * `fmt::format(fmt, args...)`. * `error_code` is a system error code as given by `errno`. * * **Example**: * * // This throws std::system_error with the description * // cannot open file 'madeup': No such file or directory * // or similar (system message may vary). * const char* filename = "madeup"; * FILE* file = fopen(filename, "r"); * if (!file) * throw fmt::system_error(errno, "cannot open file '{}'", filename); */ template auto system_error(int error_code, format_string fmt, T&&... args) -> std::system_error { return vsystem_error(error_code, fmt.str, vargs{{args...}}); } /** * Formats an error message for an error returned by an operating system or a * language runtime, for example a file opening error, and writes it to `out`. * The format is the same as the one used by `std::system_error(ec, message)` * where `ec` is `std::error_code(error_code, std::generic_category())`. * It is implementation-defined but normally looks like: * * : * * where `` is the passed message and `` is the system * message corresponding to the error code. * `error_code` is a system error code as given by `errno`. */ FMT_API void format_system_error(detail::buffer& out, int error_code, const char* message) noexcept; // Reports a system error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_system_error(int error_code, const char* message) noexcept; inline auto vformat(locale_ref loc, string_view fmt, format_args args) -> std::string { auto buf = memory_buffer(); detail::vformat_to(buf, fmt, args, loc); return {buf.data(), buf.size()}; } template FMT_INLINE auto format(locale_ref loc, format_string fmt, T&&... args) -> std::string { return vformat(loc, fmt.str, vargs{{args...}}); } template ::value)> auto vformat_to(OutputIt out, locale_ref loc, string_view fmt, format_args args) -> OutputIt { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, fmt, args, loc); return detail::get_iterator(buf, out); } template ::value)> FMT_INLINE auto format_to(OutputIt out, locale_ref loc, format_string fmt, T&&... args) -> OutputIt { return fmt::vformat_to(out, loc, fmt.str, vargs{{args...}}); } template FMT_NODISCARD FMT_INLINE auto formatted_size(locale_ref loc, format_string fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer<>(); detail::vformat_to(buf, fmt.str, vargs{{args...}}, loc); return buf.count(); } FMT_API auto vformat(string_view fmt, format_args args) -> std::string; /** * Formats `args` according to specifications in `fmt` and returns the result * as a string. * * **Example**: * * #include * std::string message = fmt::format("The answer is {}.", 42); */ template FMT_NODISCARD FMT_INLINE auto format(format_string fmt, T&&... args) -> std::string { return vformat(fmt.str, vargs{{args...}}); } /** * Converts `value` to `std::string` using the default format for type `T`. * * **Example**: * * std::string answer = fmt::to_string(42); */ template ::value)> FMT_NODISCARD FMT_CONSTEXPR_STRING auto to_string(T value) -> std::string { // The buffer should be large enough to store the number including the sign // or "false" for bool. char buffer[max_of(detail::digits10() + 2, 5)]; return {buffer, detail::write(buffer, value)}; } template ::value)> FMT_NODISCARD FMT_CONSTEXPR_STRING auto to_string(const T& value) -> std::string { return to_string(format_as(value)); } template ::value && !detail::use_format_as::value)> FMT_NODISCARD FMT_CONSTEXPR_STRING auto to_string(const T& value) -> std::string { auto buffer = memory_buffer(); detail::write(appender(buffer), value); return {buffer.data(), buffer.size()}; } FMT_END_EXPORT FMT_END_NAMESPACE #ifdef FMT_HEADER_ONLY # define FMT_FUNC inline # include "format-inl.h" #endif // Restore _LIBCPP_REMOVE_TRANSITIVE_INCLUDES. #ifdef FMT_REMOVE_TRANSITIVE_INCLUDES # undef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES #endif #endif // FMT_FORMAT_H_ aristocratos-btop-d43a485/include/fmt/os.h000066400000000000000000000310231517514752700205470ustar00rootroot00000000000000// Formatting library for C++ - optional OS-specific functionality // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OS_H_ #define FMT_OS_H_ #include "format.h" #ifndef FMT_MODULE # include # include # include # include // std::system_error # if FMT_HAS_INCLUDE() # include // LC_NUMERIC_MASK on macOS # endif #endif // FMT_MODULE #ifndef FMT_USE_FCNTL // UWP doesn't provide _pipe. # if FMT_HAS_INCLUDE("winapifamily.h") # include # endif # if (FMT_HAS_INCLUDE() || defined(__APPLE__) || \ defined(__linux__)) && \ (!defined(WINAPI_FAMILY) || \ (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)) && \ !defined(__wasm__) # include // for O_RDONLY # define FMT_USE_FCNTL 1 # else # define FMT_USE_FCNTL 0 # endif #endif #ifndef FMT_POSIX # if defined(_WIN32) && !defined(__MINGW32__) // Fix warnings about deprecated symbols. # define FMT_POSIX(call) _##call # else # define FMT_POSIX(call) call # endif #endif // Calls to system functions are wrapped in FMT_SYSTEM for testability. #ifdef FMT_SYSTEM # define FMT_HAS_SYSTEM # define FMT_POSIX_CALL(call) FMT_SYSTEM(call) #else # define FMT_SYSTEM(call) ::call # ifdef _WIN32 // Fix warnings about deprecated symbols. # define FMT_POSIX_CALL(call) ::_##call # else # define FMT_POSIX_CALL(call) ::call # endif #endif // Retries the expression while it evaluates to error_result and errno // equals to EINTR. #ifndef _WIN32 # define FMT_RETRY_VAL(result, expression, error_result) \ do { \ (result) = (expression); \ } while ((result) == (error_result) && errno == EINTR) #else # define FMT_RETRY_VAL(result, expression, error_result) result = (expression) #endif #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT /** * A reference to a null-terminated string. It can be constructed from a C * string or `std::string`. * * You can use one of the following type aliases for common character types: * * +---------------+-----------------------------+ * | Type | Definition | * +===============+=============================+ * | cstring_view | basic_cstring_view | * +---------------+-----------------------------+ * | wcstring_view | basic_cstring_view | * +---------------+-----------------------------+ * * This class is most useful as a parameter type for functions that wrap C APIs. */ template class basic_cstring_view { private: const Char* data_; public: /// Constructs a string reference object from a C string. basic_cstring_view(const Char* s) : data_(s) {} /// Constructs a string reference from an `std::string` object. basic_cstring_view(const std::basic_string& s) : data_(s.c_str()) {} /// Returns the pointer to a C string. auto c_str() const -> const Char* { return data_; } }; using cstring_view = basic_cstring_view; using wcstring_view = basic_cstring_view; #ifdef _WIN32 FMT_API const std::error_category& system_category() noexcept; namespace detail { FMT_API void format_windows_error(buffer& out, int error_code, const char* message) noexcept; } FMT_API std::system_error vwindows_error(int error_code, string_view fmt, format_args args); /** * Constructs a `std::system_error` object with the description of the form * * : * * where `` is the formatted message and `` is the * system message corresponding to the error code. * `error_code` is a Windows error code as given by `GetLastError`. * If `error_code` is not a valid error code such as -1, the system message * will look like "error -1". * * **Example**: * * // This throws a system_error with the description * // cannot open file 'madeup': The system cannot find the file * specified. * // or similar (system message may vary). * const char *filename = "madeup"; * LPOFSTRUCT of = LPOFSTRUCT(); * HFILE file = OpenFile(filename, &of, OF_READ); * if (file == HFILE_ERROR) { * throw fmt::windows_error(GetLastError(), * "cannot open file '{}'", filename); * } */ template auto windows_error(int error_code, string_view message, const T&... args) -> std::system_error { return vwindows_error(error_code, message, vargs{{args...}}); } // Reports a Windows error without throwing an exception. // Can be used to report errors from destructors. FMT_API void report_windows_error(int error_code, const char* message) noexcept; #else inline auto system_category() noexcept -> const std::error_category& { return std::system_category(); } #endif // _WIN32 // std::system is not available on some platforms such as iOS (#2248). #ifdef __OSX__ template > void say(const S& fmt, Args&&... args) { std::system(format("say \"{}\"", format(fmt, args...)).c_str()); } #endif // A buffered file. class buffered_file { private: FILE* file_; friend class file; inline explicit buffered_file(FILE* f) : file_(f) {} public: buffered_file(const buffered_file&) = delete; void operator=(const buffered_file&) = delete; // Constructs a buffered_file object which doesn't represent any file. inline buffered_file() noexcept : file_(nullptr) {} // Destroys the object closing the file it represents if any. FMT_API ~buffered_file() noexcept; public: inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) { other.file_ = nullptr; } inline auto operator=(buffered_file&& other) -> buffered_file& { close(); file_ = other.file_; other.file_ = nullptr; return *this; } // Opens a file. FMT_API buffered_file(cstring_view filename, cstring_view mode); // Closes the file. FMT_API void close(); // Returns the pointer to a FILE object representing this file. inline auto get() const noexcept -> FILE* { return file_; } FMT_API auto descriptor() const -> int; template inline void print(string_view fmt, const T&... args) { fmt::vargs vargs = {{args...}}; detail::is_locking() ? fmt::vprint_buffered(file_, fmt, vargs) : fmt::vprint(file_, fmt, vargs); } }; #if FMT_USE_FCNTL // A file. Closed file is represented by a file object with descriptor -1. // Methods that are not declared with noexcept may throw // fmt::system_error in case of failure. Note that some errors such as // closing the file multiple times will cause a crash on Windows rather // than an exception. You can get standard behavior by overriding the // invalid parameter handler with _set_invalid_parameter_handler. class FMT_API file { private: int fd_; // File descriptor. // Constructs a file object with a given descriptor. explicit file(int fd) : fd_(fd) {} friend struct pipe; public: // Possible values for the oflag argument to the constructor. enum { RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. RDWR = FMT_POSIX(O_RDWR), // Open for reading and writing. CREATE = FMT_POSIX(O_CREAT), // Create if the file doesn't exist. APPEND = FMT_POSIX(O_APPEND), // Open in append mode. TRUNC = FMT_POSIX(O_TRUNC) // Truncate the content of the file. }; // Constructs a file object which doesn't represent any file. inline file() noexcept : fd_(-1) {} // Opens a file and constructs a file object representing this file. file(cstring_view path, int oflag); public: file(const file&) = delete; void operator=(const file&) = delete; inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; } // Move assignment is not noexcept because close may throw. inline auto operator=(file&& other) -> file& { close(); fd_ = other.fd_; other.fd_ = -1; return *this; } // Destroys the object closing the file it represents if any. ~file() noexcept; // Returns the file descriptor. inline auto descriptor() const noexcept -> int { return fd_; } // Closes the file. void close(); // Returns the file size. The size has signed type for consistency with // stat::st_size. auto size() const -> long long; // Attempts to read count bytes from the file into the specified buffer. auto read(void* buffer, size_t count) -> size_t; // Attempts to write count bytes from the specified buffer to the file. auto write(const void* buffer, size_t count) -> size_t; // Duplicates a file descriptor with the dup function and returns // the duplicate as a file object. static auto dup(int fd) -> file; // Makes fd be the copy of this file descriptor, closing fd first if // necessary. void dup2(int fd); // Makes fd be the copy of this file descriptor, closing fd first if // necessary. void dup2(int fd, std::error_code& ec) noexcept; // Creates a buffered_file object associated with this file and detaches // this file object from the file. auto fdopen(const char* mode) -> buffered_file; # if defined(_WIN32) && !defined(__MINGW32__) // Opens a file and constructs a file object representing this file by // wcstring_view filename. Windows only. static file open_windows_file(wcstring_view path, int oflag); # endif }; struct FMT_API pipe { file read_end; file write_end; // Creates a pipe setting up read_end and write_end file objects for reading // and writing respectively. pipe(); }; // Returns the memory page size. auto getpagesize() -> long; namespace detail { struct buffer_size { constexpr buffer_size() = default; size_t value = 0; FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size { auto bs = buffer_size(); bs.value = val; return bs; } }; struct ostream_params { int oflag = file::WRONLY | file::CREATE | file::TRUNC; size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768; constexpr ostream_params() {} template ostream_params(T... params, int new_oflag) : ostream_params(params...) { oflag = new_oflag; } template ostream_params(T... params, detail::buffer_size bs) : ostream_params(params...) { this->buffer_size = bs.value; } // Intel has a bug that results in failure to deduce a constructor // for empty parameter packs. # if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000 ostream_params(int new_oflag) : oflag(new_oflag) {} ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {} # endif }; } // namespace detail FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size(); /// A fast buffered output stream for writing from a single thread. Writing from /// multiple threads without external synchronization may result in a data race. class FMT_API ostream : private detail::buffer { private: file file_; ostream(cstring_view path, const detail::ostream_params& params); static void grow(buffer& buf, size_t); public: ostream(ostream&& other) noexcept; ~ostream(); operator writer() { detail::buffer& buf = *this; return buf; } inline void flush() { if (size() == 0) return; file_.write(data(), size() * sizeof(data()[0])); clear(); } template friend auto output_file(cstring_view path, T... params) -> ostream; inline void close() { flush(); file_.close(); } /// Formats `args` according to specifications in `fmt` and writes the /// output to the file. template void print(format_string fmt, T&&... args) { vformat_to(appender(*this), fmt.str, vargs{{args...}}); } }; /** * Opens a file for writing. Supported parameters passed in `params`: * * - ``: Flags passed to [open]( * https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html) * (`file::WRONLY | file::CREATE | file::TRUNC` by default) * - `buffer_size=`: Output buffer size * * **Example**: * * auto out = fmt::output_file("guide.txt"); * out.print("Don't {}", "Panic"); */ template inline auto output_file(cstring_view path, T... params) -> ostream { return {path, detail::ostream_params(params...)}; } #endif // FMT_USE_FCNTL FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_OS_H_ aristocratos-btop-d43a485/include/fmt/ostream.h000066400000000000000000000116431517514752700216060ustar00rootroot00000000000000// Formatting library for C++ - std::ostream support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_OSTREAM_H_ #define FMT_OSTREAM_H_ #ifndef FMT_MODULE # include // std::filebuf #endif #ifdef _WIN32 # ifdef __GLIBCXX__ # include # include # endif # include #endif #include "chrono.h" // formatbuf #ifdef _MSVC_STL_UPDATE # define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE #elif defined(_MSC_VER) && _MSC_VER < 1912 // VS 15.5 # define FMT_MSVC_STL_UPDATE _MSVC_LANG #else # define FMT_MSVC_STL_UPDATE 0 #endif FMT_BEGIN_NAMESPACE namespace detail { // Generate a unique explicit instantiation in every translation unit using a // tag type in an anonymous namespace. namespace { struct file_access_tag {}; } // namespace template class file_access { friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; } }; #if FMT_MSVC_STL_UPDATE template class file_access; auto get_file(std::filebuf&) -> FILE*; #endif // Write the content of buf to os. // It is a separate function rather than a part of vprint to simplify testing. template void write_buffer(std::basic_ostream& os, buffer& buf) { const Char* buf_data = buf.data(); using unsigned_streamsize = make_unsigned_t; unsigned_streamsize size = buf.size(); unsigned_streamsize max_size = to_unsigned(max_value()); do { unsigned_streamsize n = size <= max_size ? size : max_size; os.write(buf_data, static_cast(n)); buf_data += n; size -= n; } while (size != 0); } template struct streamed_view { const T& value; }; } // namespace detail // Formats an object of type T that has an overloaded ostream operator<<. template struct basic_ostream_formatter : formatter, Char> { void set_debug_format() = delete; template auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) { auto buffer = basic_memory_buffer(); auto&& formatbuf = detail::formatbuf>(buffer); auto&& output = std::basic_ostream(&formatbuf); output.imbue(std::locale::classic()); // The default is always unlocalized. output << value; output.exceptions(std::ios_base::failbit | std::ios_base::badbit); return formatter, Char>::format( {buffer.data(), buffer.size()}, ctx); } }; using ostream_formatter = basic_ostream_formatter; template struct formatter, Char> : basic_ostream_formatter { template auto format(detail::streamed_view view, Context& ctx) const -> decltype(ctx.out()) { return basic_ostream_formatter::format(view.value, ctx); } }; /** * Returns a view that formats `value` via an ostream `operator<<`. * * **Example**: * * fmt::print("Current thread id: {}\n", * fmt::streamed(std::this_thread::get_id())); */ template constexpr auto streamed(const T& value) -> detail::streamed_view { return {value}; } inline void vprint(std::ostream& os, string_view fmt, format_args args) { auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt, args); FILE* f = nullptr; #if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI if (auto* buf = dynamic_cast(os.rdbuf())) f = detail::get_file(*buf); #elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI auto* rdbuf = os.rdbuf(); if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf*>(rdbuf)) f = sfbuf->file(); else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf*>(rdbuf)) f = fbuf->file(); #endif #ifdef _WIN32 if (f) { int fd = _fileno(f); if (_isatty(fd)) { os.flush(); if (detail::write_console(fd, {buffer.data(), buffer.size()})) return; } } #endif detail::ignore_unused(f); detail::write_buffer(os, buffer); } /** * Prints formatted data to the stream `os`. * * **Example**: * * fmt::print(cerr, "Don't {}!", "panic"); */ FMT_EXPORT template void print(std::ostream& os, format_string fmt, T&&... args) { fmt::vargs vargs = {{args...}}; if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs); auto buffer = memory_buffer(); detail::vformat_to(buffer, fmt.str, vargs); detail::write_buffer(os, buffer); } FMT_EXPORT template void println(std::ostream& os, format_string fmt, T&&... args) { fmt::print(os, FMT_STRING("{}\n"), fmt::format(fmt, std::forward(args)...)); } FMT_END_NAMESPACE #endif // FMT_OSTREAM_H_ aristocratos-btop-d43a485/include/fmt/printf.h000066400000000000000000000470271517514752700214430ustar00rootroot00000000000000// Formatting library for C++ - legacy printf implementation // // Copyright (c) 2012 - 2016, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_PRINTF_H_ #define FMT_PRINTF_H_ #ifndef FMT_MODULE # include // std::find # include // std::numeric_limits #endif #include "format.h" FMT_BEGIN_NAMESPACE FMT_BEGIN_EXPORT template class basic_printf_context { private: basic_appender out_; basic_format_args args_; static_assert(std::is_same::value || std::is_same::value, "Unsupported code unit type."); public: using char_type = Char; enum { builtin_types = 1 }; /// Constructs a `printf_context` object. References to the arguments are /// stored in the context object so make sure they have appropriate lifetimes. basic_printf_context(basic_appender out, basic_format_args args) : out_(out), args_(args) {} auto out() -> basic_appender { return out_; } void advance_to(basic_appender) {} auto locale() -> locale_ref { return {}; } auto arg(int id) const -> basic_format_arg { return args_.get(id); } }; namespace detail { // Return the result via the out param to workaround gcc bug 77539. template FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool { for (out = first; out != last; ++out) { if (*out == value) return true; } return false; } template <> inline auto find(const char* first, const char* last, char value, const char*& out) -> bool { out = static_cast(memchr(first, value, to_unsigned(last - first))); return out != nullptr; } // Checks if a value fits in int - used to avoid warnings about comparing // signed and unsigned integers. template struct int_checker { template static auto fits_in_int(T value) -> bool { return value <= to_unsigned(max_value()); } inline static auto fits_in_int(bool) -> bool { return true; } }; template <> struct int_checker { template static auto fits_in_int(T value) -> bool { return value >= (std::numeric_limits::min)() && value <= max_value(); } inline static auto fits_in_int(int) -> bool { return true; } }; struct printf_precision_handler { template ::value)> auto operator()(T value) -> int { if (!int_checker::is_signed>::fits_in_int(value)) report_error("number is too big"); return max_of(static_cast(value), 0); } template ::value)> auto operator()(T) -> int { report_error("precision is not integer"); return 0; } }; // An argument visitor that returns true iff arg is a zero integer. struct is_zero_int { template ::value)> auto operator()(T value) -> bool { return value == 0; } template ::value)> auto operator()(T) -> bool { return false; } }; template struct make_unsigned_or_bool : std::make_unsigned {}; template <> struct make_unsigned_or_bool { using type = bool; }; template class arg_converter { private: using char_type = typename Context::char_type; basic_format_arg& arg_; char_type type_; public: arg_converter(basic_format_arg& arg, char_type type) : arg_(arg), type_(type) {} void operator()(bool value) { if (type_ != 's') operator()(value); } template ::value)> void operator()(U value) { bool is_signed = type_ == 'd' || type_ == 'i'; using target_type = conditional_t::value, U, T>; if (const_check(sizeof(target_type) <= sizeof(int))) { // Extra casts are used to silence warnings. using unsigned_type = typename make_unsigned_or_bool::type; if (is_signed) arg_ = static_cast(static_cast(value)); else arg_ = static_cast(static_cast(value)); } else { // glibc's printf doesn't sign extend arguments of smaller types: // std::printf("%lld", -42); // prints "4294967254" // but we don't have to do the same because it's a UB. if (is_signed) arg_ = static_cast(value); else arg_ = static_cast::type>(value); } } template ::value)> void operator()(U) {} // No conversion needed for non-integral types. }; // Converts an integer argument to T for printf, if T is an integral type. // If T is void, the argument is converted to corresponding signed or unsigned // type depending on the type specifier: 'd' and 'i' - signed, other - // unsigned). template void convert_arg(basic_format_arg& arg, Char type) { arg.visit(arg_converter(arg, type)); } // Converts an integer argument to char for printf. template class char_converter { private: basic_format_arg& arg_; public: explicit char_converter(basic_format_arg& arg) : arg_(arg) {} template ::value)> void operator()(T value) { arg_ = static_cast(value); } template ::value)> void operator()(T) {} // No conversion needed for non-integral types. }; // An argument visitor that return a pointer to a C string if argument is a // string or null otherwise. template struct get_cstring { template auto operator()(T) -> const Char* { return nullptr; } auto operator()(const Char* s) -> const Char* { return s; } }; // Checks if an argument is a valid printf width specifier and sets // left alignment if it is negative. class printf_width_handler { private: format_specs& specs_; public: inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {} template ::value)> auto operator()(T value) -> unsigned { auto width = static_cast>(value); if (detail::is_negative(value)) { specs_.set_align(align::left); width = 0 - width; } unsigned int_max = to_unsigned(max_value()); if (width > int_max) report_error("number is too big"); return static_cast(width); } template ::value)> auto operator()(T) -> unsigned { report_error("width is not integer"); return 0; } }; // Workaround for a bug with the XL compiler when initializing // printf_arg_formatter's base class. template auto make_arg_formatter(basic_appender iter, format_specs& s) -> arg_formatter { return {iter, s, locale_ref()}; } // The `printf` argument formatter. template class printf_arg_formatter : public arg_formatter { private: using base = arg_formatter; using context_type = basic_printf_context; context_type& context_; void write_null_pointer(bool is_string = false) { auto s = this->specs; s.set_type(presentation_type::none); write_bytes(this->out, is_string ? "(null)" : "(nil)", s); } template void write(T value) { detail::write(this->out, value, this->specs, this->locale); } public: printf_arg_formatter(basic_appender iter, format_specs& s, context_type& ctx) : base(make_arg_formatter(iter, s)), context_(ctx) {} void operator()(monostate value) { write(value); } template ::value)> void operator()(T value) { // MSVC2013 fails to compile separate overloads for bool and Char so use // std::is_same instead. if (!std::is_same::value) { write(value); return; } format_specs s = this->specs; if (s.type() != presentation_type::none && s.type() != presentation_type::chr) { return (*this)(static_cast(value)); } s.set_sign(sign::none); s.clear_alt(); s.set_fill(' '); // Ignore '0' flag for char types. // align::numeric needs to be overwritten here since the '0' flag is // ignored for non-numeric types if (s.align() == align::none || s.align() == align::numeric) s.set_align(align::right); detail::write(this->out, static_cast(value), s); } template ::value)> void operator()(T value) { write(value); } void operator()(const char* value) { if (value) write(value); else write_null_pointer(this->specs.type() != presentation_type::pointer); } void operator()(const wchar_t* value) { if (value) write(value); else write_null_pointer(this->specs.type() != presentation_type::pointer); } void operator()(basic_string_view value) { write(value); } void operator()(const void* value) { if (value) write(value); else write_null_pointer(); } void operator()(typename basic_format_arg::handle handle) { auto parse_ctx = parse_context({}); handle.format(parse_ctx, context_); } }; template void parse_flags(format_specs& specs, const Char*& it, const Char* end) { for (; it != end; ++it) { switch (*it) { case '-': specs.set_align(align::left); break; case '+': specs.set_sign(sign::plus); break; case '0': specs.set_fill('0'); break; case ' ': if (specs.sign() != sign::plus) specs.set_sign(sign::space); break; case '#': specs.set_alt(); break; default: return; } } } template auto parse_header(const Char*& it, const Char* end, format_specs& specs, GetArg get_arg) -> int { int arg_index = -1; Char c = *it; if (c >= '0' && c <= '9') { // Parse an argument index (if followed by '$') or a width possibly // preceded with '0' flag(s). int value = parse_nonnegative_int(it, end, -1); if (it != end && *it == '$') { // value is an argument index ++it; arg_index = value != -1 ? value : max_value(); } else { if (c == '0') specs.set_fill('0'); if (value != 0) { // Nonzero value means that we parsed width and don't need to // parse it or flags again, so return now. if (value == -1) report_error("number is too big"); specs.width = value; return arg_index; } } } parse_flags(specs, it, end); // Parse width. if (it != end) { if (*it >= '0' && *it <= '9') { specs.width = parse_nonnegative_int(it, end, -1); if (specs.width == -1) report_error("number is too big"); } else if (*it == '*') { ++it; specs.width = static_cast( get_arg(-1).visit(detail::printf_width_handler(specs))); } } return arg_index; } inline auto parse_printf_presentation_type(char c, type t, bool& upper) -> presentation_type { using pt = presentation_type; constexpr auto integral_set = sint_set | uint_set | bool_set | char_set; switch (c) { case 'd': return in(t, integral_set) ? pt::dec : pt::none; case 'o': return in(t, integral_set) ? pt::oct : pt::none; case 'X': upper = true; FMT_FALLTHROUGH; case 'x': return in(t, integral_set) ? pt::hex : pt::none; case 'E': upper = true; FMT_FALLTHROUGH; case 'e': return in(t, float_set) ? pt::exp : pt::none; case 'F': upper = true; FMT_FALLTHROUGH; case 'f': return in(t, float_set) ? pt::fixed : pt::none; case 'G': upper = true; FMT_FALLTHROUGH; case 'g': return in(t, float_set) ? pt::general : pt::none; case 'A': upper = true; FMT_FALLTHROUGH; case 'a': return in(t, float_set) ? pt::hexfloat : pt::none; case 'c': return in(t, integral_set) ? pt::chr : pt::none; case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none; case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none; default: return pt::none; } } template void vprintf(buffer& buf, basic_string_view format, basic_format_args args) { using iterator = basic_appender; auto out = iterator(buf); auto context = basic_printf_context(out, args); auto parse_ctx = parse_context(format); // Returns the argument with specified index or, if arg_index is -1, the next // argument. auto get_arg = [&](int arg_index) { if (arg_index < 0) arg_index = parse_ctx.next_arg_id(); else parse_ctx.check_arg_id(--arg_index); auto arg = context.arg(arg_index); if (!arg) report_error("argument not found"); return arg; }; const Char* start = parse_ctx.begin(); const Char* end = parse_ctx.end(); auto it = start; while (it != end) { if (!find(it, end, '%', it)) { it = end; // find leaves it == nullptr if it doesn't find '%'. break; } Char c = *it++; if (it != end && *it == c) { write(out, basic_string_view(start, to_unsigned(it - start))); start = ++it; continue; } write(out, basic_string_view(start, to_unsigned(it - 1 - start))); auto specs = format_specs(); specs.set_align(align::right); // Parse argument index, flags and width. int arg_index = parse_header(it, end, specs, get_arg); if (arg_index == 0) report_error("argument not found"); // Parse precision. if (it != end && *it == '.') { ++it; c = it != end ? *it : 0; if ('0' <= c && c <= '9') { specs.precision = parse_nonnegative_int(it, end, 0); } else if (c == '*') { ++it; specs.precision = static_cast(get_arg(-1).visit(printf_precision_handler())); } else { specs.precision = 0; } } auto arg = get_arg(arg_index); // For d, i, o, u, x, and X conversion specifiers, if a precision is // specified, the '0' flag is ignored if (specs.precision >= 0 && is_integral_type(arg.type())) { // Ignore '0' for non-numeric types or if '-' present. specs.set_fill(' '); } if (specs.precision >= 0 && arg.type() == type::cstring_type) { auto str = arg.visit(get_cstring()); auto str_end = str + specs.precision; auto nul = std::find(str, str_end, Char()); auto sv = basic_string_view( str, to_unsigned(nul != str_end ? nul - str : specs.precision)); arg = sv; } if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt(); if (specs.fill_unit() == '0') { if (is_arithmetic_type(arg.type()) && specs.align() != align::left) { specs.set_align(align::numeric); } else { // Ignore '0' flag for non-numeric types or if '-' flag is also present. specs.set_fill(' '); } } // Parse length and convert the argument to the required type. c = it != end ? *it++ : 0; Char t = it != end ? *it : 0; switch (c) { case 'h': if (t == 'h') { ++it; t = it != end ? *it : 0; convert_arg(arg, t); } else { convert_arg(arg, t); } break; case 'l': if (t == 'l') { ++it; t = it != end ? *it : 0; convert_arg(arg, t); } else { convert_arg(arg, t); } break; case 'j': convert_arg(arg, t); break; case 'z': convert_arg(arg, t); break; case 't': convert_arg(arg, t); break; case 'L': // printf produces garbage when 'L' is omitted for long double, no // need to do the same. break; default: --it; convert_arg(arg, c); } // Parse type. if (it == end) report_error("invalid format string"); char type = static_cast(*it++); if (is_integral_type(arg.type())) { // Normalize type. switch (type) { case 'i': case 'u': type = 'd'; break; case 'c': arg.visit(char_converter>(arg)); break; } } bool upper = false; specs.set_type(parse_printf_presentation_type(type, arg.type(), upper)); if (specs.type() == presentation_type::none) report_error("invalid format specifier"); if (upper) specs.set_upper(); start = it; // Format argument. arg.visit(printf_arg_formatter(out, specs, context)); } write(out, basic_string_view(start, to_unsigned(it - start))); } } // namespace detail using printf_context = basic_printf_context; using wprintf_context = basic_printf_context; using printf_args = basic_format_args; using wprintf_args = basic_format_args; /// Constructs an `format_arg_store` object that contains references to /// arguments and can be implicitly converted to `printf_args`. template inline auto make_printf_args(T&... args) -> decltype(fmt::make_format_args>(args...)) { return fmt::make_format_args>(args...); } template struct vprintf_args { using type = basic_format_args>; }; template inline auto vsprintf(basic_string_view fmt, typename vprintf_args::type args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vprintf(buf, fmt, args); return {buf.data(), buf.size()}; } /** * Formats `args` according to specifications in `fmt` and returns the result * as as string. * * **Example**: * * std::string message = fmt::sprintf("The answer is %d", 42); */ template inline auto sprintf(string_view fmt, const T&... args) -> std::string { return vsprintf(fmt, make_printf_args(args...)); } template FMT_DEPRECATED auto sprintf(basic_string_view fmt, const T&... args) -> std::wstring { return vsprintf(fmt, make_printf_args(args...)); } template auto vfprintf(std::FILE* f, basic_string_view fmt, typename vprintf_args::type args) -> int { auto buf = basic_memory_buffer(); detail::vprintf(buf, fmt, args); size_t size = buf.size(); return std::fwrite(buf.data(), sizeof(Char), size, f) < size ? -1 : static_cast(size); } /** * Formats `args` according to specifications in `fmt` and writes the output * to `f`. * * **Example**: * * fmt::fprintf(stderr, "Don't %s!", "panic"); */ template inline auto fprintf(std::FILE* f, string_view fmt, const T&... args) -> int { return vfprintf(f, fmt, make_printf_args(args...)); } template FMT_DEPRECATED auto fprintf(std::FILE* f, basic_string_view fmt, const T&... args) -> int { return vfprintf(f, fmt, make_printf_args(args...)); } /** * Formats `args` according to specifications in `fmt` and writes the output * to `stdout`. * * **Example**: * * fmt::printf("Elapsed time: %.2f seconds", 1.23); */ template inline auto printf(string_view fmt, const T&... args) -> int { return vfprintf(stdout, fmt, make_printf_args(args...)); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_PRINTF_H_ aristocratos-btop-d43a485/include/fmt/ranges.h000066400000000000000000000670061517514752700214170ustar00rootroot00000000000000// Formatting library for C++ - range and tuple support // // Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_RANGES_H_ #define FMT_RANGES_H_ #ifndef FMT_MODULE # include # include # include # include # include #endif #include "format.h" FMT_BEGIN_NAMESPACE FMT_EXPORT enum class range_format { disabled, map, set, sequence, string, debug_string }; namespace detail { template class is_map { template static auto check(U*) -> typename U::mapped_type; template static void check(...); public: static constexpr bool value = !std::is_void(nullptr))>::value; }; template class is_set { template static auto check(U*) -> typename U::key_type; template static void check(...); public: static constexpr bool value = !std::is_void(nullptr))>::value && !is_map::value; }; // C array overload template auto range_begin(const T (&arr)[N]) -> const T* { return arr; } template auto range_end(const T (&arr)[N]) -> const T* { return arr + N; } template struct has_member_fn_begin_end_t : std::false_type {}; template struct has_member_fn_begin_end_t().begin()), decltype(std::declval().end())>> : std::true_type {}; // Member function overloads. template auto range_begin(T&& rng) -> decltype(static_cast(rng).begin()) { return static_cast(rng).begin(); } template auto range_end(T&& rng) -> decltype(static_cast(rng).end()) { return static_cast(rng).end(); } // ADL overloads. Only participate in overload resolution if member functions // are not found. template auto range_begin(T&& rng) -> enable_if_t::value, decltype(begin(static_cast(rng)))> { return begin(static_cast(rng)); } template auto range_end(T&& rng) -> enable_if_t::value, decltype(end(static_cast(rng)))> { return end(static_cast(rng)); } template struct has_const_begin_end : std::false_type {}; template struct has_mutable_begin_end : std::false_type {}; template struct has_const_begin_end< T, void_t&>())), decltype(detail::range_end( std::declval&>()))>> : std::true_type {}; template struct has_mutable_begin_end< T, void_t())), decltype(detail::range_end(std::declval())), // the extra int here is because older versions of MSVC don't // SFINAE properly unless there are distinct types int>> : std::true_type {}; template struct is_range_ : std::false_type {}; template struct is_range_ : std::integral_constant::value || has_mutable_begin_end::value)> {}; // tuple_size and tuple_element check. template class is_tuple_like_ { template ::type> static auto check(U* p) -> decltype(std::tuple_size::value, 0); template static void check(...); public: static constexpr bool value = !std::is_void(nullptr))>::value; }; // Check for integer_sequence #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900 template using integer_sequence = std::integer_sequence; template using index_sequence = std::index_sequence; template using make_index_sequence = std::make_index_sequence; #else template struct integer_sequence { using value_type = T; static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); } }; template using index_sequence = integer_sequence; template struct make_integer_sequence : make_integer_sequence {}; template struct make_integer_sequence : integer_sequence {}; template using make_index_sequence = make_integer_sequence; #endif template using tuple_index_sequence = make_index_sequence::value>; template ::value> class is_tuple_formattable_ { public: static constexpr bool value = false; }; template class is_tuple_formattable_ { template static auto all_true(index_sequence, integer_sequence= 0)...>) -> std::true_type; static auto all_true(...) -> std::false_type; template static auto check(index_sequence) -> decltype(all_true( index_sequence{}, integer_sequence::type, C>::value)...>{})); public: static constexpr bool value = decltype(check(tuple_index_sequence{}))::value; }; template FMT_CONSTEXPR void for_each(index_sequence, Tuple&& t, F&& f) { using std::get; // Using a free function get(Tuple) now. const int unused[] = {0, ((void)f(get(t)), 0)...}; ignore_unused(unused); } template FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) { for_each(tuple_index_sequence>(), std::forward(t), std::forward(f)); } template void for_each2(index_sequence, Tuple1&& t1, Tuple2&& t2, F&& f) { using std::get; const int unused[] = {0, ((void)f(get(t1), get(t2)), 0)...}; ignore_unused(unused); } template void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) { for_each2(tuple_index_sequence>(), std::forward(t1), std::forward(t2), std::forward(f)); } namespace tuple { // Workaround a bug in MSVC 2019 (v140). template using result_t = std::tuple, Char>...>; using std::get; template auto get_formatters(index_sequence) -> result_t(std::declval()))...>; } // namespace tuple #if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920 // Older MSVC doesn't get the reference type correctly for arrays. template struct range_reference_type_impl { using type = decltype(*detail::range_begin(std::declval())); }; template struct range_reference_type_impl { using type = T&; }; template using range_reference_type = typename range_reference_type_impl::type; #else template using range_reference_type = decltype(*detail::range_begin(std::declval())); #endif // We don't use the Range's value_type for anything, but we do need the Range's // reference type, with cv-ref stripped. template using uncvref_type = remove_cvref_t>; template FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set) -> decltype(f.set_debug_format(set)) { f.set_debug_format(set); } template FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {} template struct range_format_kind_ : std::integral_constant, T>::value ? range_format::disabled : is_map::value ? range_format::map : is_set::value ? range_format::set : range_format::sequence> {}; template using range_format_constant = std::integral_constant; // These are not generic lambdas for compatibility with C++11. template struct parse_empty_specs { template FMT_CONSTEXPR void operator()(Formatter& f) { f.parse(ctx); detail::maybe_set_debug_format(f, true); } parse_context& ctx; }; template struct format_tuple_element { using char_type = typename FormatContext::char_type; template void operator()(const formatter& f, const T& v) { if (i > 0) ctx.advance_to(detail::copy(separator, ctx.out())); ctx.advance_to(f.format(v, ctx)); ++i; } int i; FormatContext& ctx; basic_string_view separator; }; } // namespace detail FMT_EXPORT template struct is_tuple_like { static constexpr bool value = detail::is_tuple_like_::value && !detail::is_range_::value; }; FMT_EXPORT template struct is_tuple_formattable { static constexpr bool value = detail::is_tuple_formattable_::value; }; template struct formatter::value && fmt::is_tuple_formattable::value>> { private: decltype(detail::tuple::get_formatters( detail::tuple_index_sequence())) formatters_; basic_string_view separator_ = detail::string_literal{}; basic_string_view opening_bracket_ = detail::string_literal{}; basic_string_view closing_bracket_ = detail::string_literal{}; public: FMT_CONSTEXPR formatter() {} FMT_CONSTEXPR void set_separator(basic_string_view sep) { separator_ = sep; } FMT_CONSTEXPR void set_brackets(basic_string_view open, basic_string_view close) { opening_bracket_ = open; closing_bracket_ = close; } FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); if (it != end && detail::to_ascii(*it) == 'n') { ++it; set_brackets({}, {}); set_separator({}); } if (it != end && *it != '}') report_error("invalid format specifier"); ctx.advance_to(it); detail::for_each(formatters_, detail::parse_empty_specs{ctx}); return it; } template auto format(const Tuple& value, FormatContext& ctx) const -> decltype(ctx.out()) { ctx.advance_to(detail::copy(opening_bracket_, ctx.out())); detail::for_each2( formatters_, value, detail::format_tuple_element{0, ctx, separator_}); return detail::copy(closing_bracket_, ctx.out()); } }; FMT_EXPORT template struct is_range { static constexpr bool value = detail::is_range_::value && !detail::has_to_string_view::value; }; namespace detail { template using range_formatter_type = formatter, Char>; template using maybe_const_range = conditional_t::value, const R, R>; template struct is_formattable_delayed : is_formattable>, Char> {}; } // namespace detail template struct conjunction : std::true_type {}; template struct conjunction

: P {}; template struct conjunction : conditional_t, P1> {}; FMT_EXPORT template struct range_formatter; template struct range_formatter< T, Char, enable_if_t>, is_formattable>::value>> { private: detail::range_formatter_type underlying_; basic_string_view separator_ = detail::string_literal{}; basic_string_view opening_bracket_ = detail::string_literal{}; basic_string_view closing_bracket_ = detail::string_literal{}; bool is_debug = false; template ::value)> auto write_debug_string(Output& out, It it, Sentinel end) const -> Output { auto buf = basic_memory_buffer(); for (; it != end; ++it) buf.push_back(*it); auto specs = format_specs(); specs.set_type(presentation_type::debug); return detail::write( out, basic_string_view(buf.data(), buf.size()), specs); } template ::value)> auto write_debug_string(Output& out, It, Sentinel) const -> Output { return out; } public: FMT_CONSTEXPR range_formatter() {} FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type& { return underlying_; } FMT_CONSTEXPR void set_separator(basic_string_view sep) { separator_ = sep; } FMT_CONSTEXPR void set_brackets(basic_string_view open, basic_string_view close) { opening_bracket_ = open; closing_bracket_ = close; } FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); detail::maybe_set_debug_format(underlying_, true); if (it == end) return underlying_.parse(ctx); switch (detail::to_ascii(*it)) { case 'n': set_brackets({}, {}); ++it; break; case '?': is_debug = true; set_brackets({}, {}); ++it; if (it == end || *it != 's') report_error("invalid format specifier"); FMT_FALLTHROUGH; case 's': if (!std::is_same::value) report_error("invalid format specifier"); if (!is_debug) { set_brackets(detail::string_literal{}, detail::string_literal{}); set_separator({}); detail::maybe_set_debug_format(underlying_, false); } ++it; return it; } if (it != end && *it != '}') { if (*it != ':') report_error("invalid format specifier"); detail::maybe_set_debug_format(underlying_, false); ++it; } ctx.advance_to(it); return underlying_.parse(ctx); } template auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); auto it = detail::range_begin(range); auto end = detail::range_end(range); if (is_debug) return write_debug_string(out, std::move(it), end); out = detail::copy(opening_bracket_, out); int i = 0; for (; it != end; ++it) { if (i > 0) out = detail::copy(separator_, out); ctx.advance_to(out); auto&& item = *it; // Need an lvalue out = underlying_.format(item, ctx); ++i; } out = detail::copy(closing_bracket_, out); return out; } }; FMT_EXPORT template struct range_format_kind : conditional_t< is_range::value, detail::range_format_kind_, std::integral_constant> {}; template struct formatter< R, Char, enable_if_t::value != range_format::disabled && range_format_kind::value != range_format::map && range_format_kind::value != range_format::string && range_format_kind::value != range_format::debug_string>, detail::is_formattable_delayed>::value>> { private: using range_type = detail::maybe_const_range; range_formatter, Char> range_formatter_; public: using nonlocking = void; FMT_CONSTEXPR formatter() { if (detail::const_check(range_format_kind::value != range_format::set)) return; range_formatter_.set_brackets(detail::string_literal{}, detail::string_literal{}); } FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return range_formatter_.parse(ctx); } template auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) { return range_formatter_.format(range, ctx); } }; // A map formatter. template struct formatter< R, Char, enable_if_t::value == range_format::map>, detail::is_formattable_delayed>::value>> { private: using map_type = detail::maybe_const_range; using element_type = detail::uncvref_type; decltype(detail::tuple::get_formatters( detail::tuple_index_sequence())) formatters_; bool no_delimiters_ = false; public: FMT_CONSTEXPR formatter() {} FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { auto it = ctx.begin(); auto end = ctx.end(); if (it != end) { if (detail::to_ascii(*it) == 'n') { no_delimiters_ = true; ++it; } if (it != end && *it != '}') { if (*it != ':') report_error("invalid format specifier"); ++it; } ctx.advance_to(it); } detail::for_each(formatters_, detail::parse_empty_specs{ctx}); return it; } template auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); basic_string_view open = detail::string_literal{}; if (!no_delimiters_) out = detail::copy(open, out); int i = 0; basic_string_view sep = detail::string_literal{}; for (auto&& value : map) { if (i > 0) out = detail::copy(sep, out); ctx.advance_to(out); detail::for_each2(formatters_, value, detail::format_tuple_element{ 0, ctx, detail::string_literal{}}); ++i; } basic_string_view close = detail::string_literal{}; if (!no_delimiters_) out = detail::copy(close, out); return out; } }; // A (debug_)string formatter. template struct formatter< R, Char, enable_if_t::value == range_format::string || range_format_kind::value == range_format::debug_string>> { private: using range_type = detail::maybe_const_range; using string_type = conditional_t, decltype(detail::range_begin(std::declval())), decltype(detail::range_end(std::declval()))>::value, detail::std_string_view, std::basic_string>; formatter underlying_; public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return underlying_.parse(ctx); } template auto format(range_type& range, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); if (detail::const_check(range_format_kind::value == range_format::debug_string)) *out++ = '"'; out = underlying_.format( string_type{detail::range_begin(range), detail::range_end(range)}, ctx); if (detail::const_check(range_format_kind::value == range_format::debug_string)) *out++ = '"'; return out; } }; template struct join_view : detail::view { It begin; Sentinel end; basic_string_view sep; join_view(It b, Sentinel e, basic_string_view s) : begin(std::move(b)), end(e), sep(s) {} }; template struct formatter, Char> { private: using value_type = #ifdef __cpp_lib_ranges std::iter_value_t; #else typename std::iterator_traits::value_type; #endif formatter, Char> value_formatter_; using view = conditional_t::value, const join_view, join_view>; public: using nonlocking = void; FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return value_formatter_.parse(ctx); } template auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) { using iter = conditional_t::value, It, It&>; iter it = value.begin; auto out = ctx.out(); if (it == value.end) return out; out = value_formatter_.format(*it, ctx); ++it; while (it != value.end) { out = detail::copy(value.sep.begin(), value.sep.end(), out); ctx.advance_to(out); out = value_formatter_.format(*it, ctx); ++it; } return out; } }; FMT_EXPORT template struct tuple_join_view : detail::view { const Tuple& tuple; basic_string_view sep; tuple_join_view(const Tuple& t, basic_string_view s) : tuple(t), sep{s} {} }; // Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers // support in tuple_join. It is disabled by default because of issues with // the dynamic width and precision. #ifndef FMT_TUPLE_JOIN_SPECIFIERS # define FMT_TUPLE_JOIN_SPECIFIERS 0 #endif template struct formatter, Char, enable_if_t::value>> { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return do_parse(ctx, std::tuple_size()); } template auto format(const tuple_join_view& value, FormatContext& ctx) const -> typename FormatContext::iterator { return do_format(value, ctx, std::tuple_size()); } private: decltype(detail::tuple::get_formatters( detail::tuple_index_sequence())) formatters_; FMT_CONSTEXPR auto do_parse(parse_context& ctx, std::integral_constant) -> const Char* { return ctx.begin(); } template FMT_CONSTEXPR auto do_parse(parse_context& ctx, std::integral_constant) -> const Char* { auto end = ctx.begin(); #if FMT_TUPLE_JOIN_SPECIFIERS end = std::get::value - N>(formatters_).parse(ctx); if (N > 1) { auto end1 = do_parse(ctx, std::integral_constant()); if (end != end1) report_error("incompatible format specs for tuple elements"); } #endif return end; } template auto do_format(const tuple_join_view&, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator { return ctx.out(); } template auto do_format(const tuple_join_view& value, FormatContext& ctx, std::integral_constant) const -> typename FormatContext::iterator { using std::get; auto out = std::get::value - N>(formatters_) .format(get::value - N>(value.tuple), ctx); if (N <= 1) return out; out = detail::copy(value.sep, out); ctx.advance_to(out); return do_format(value, ctx, std::integral_constant()); } }; namespace detail { // Check if T has an interface like a container adaptor (e.g. std::stack, // std::queue, std::priority_queue). template class is_container_adaptor_like { template static auto check(U* p) -> typename U::container_type; template static void check(...); public: static constexpr bool value = !std::is_void(nullptr))>::value; }; template struct all { const Container& c; auto begin() const -> typename Container::const_iterator { return c.begin(); } auto end() const -> typename Container::const_iterator { return c.end(); } }; } // namespace detail template struct formatter< T, Char, enable_if_t, bool_constant::value == range_format::disabled>>::value>> : formatter, Char> { using all = detail::all; template auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) { struct getter : T { static auto get(const T& v) -> all { return {v.*(&getter::c)}; // Access c through the derived class. } }; return formatter::format(getter::get(value), ctx); } }; FMT_BEGIN_EXPORT /// Returns a view that formats the iterator range `[begin, end)` with elements /// separated by `sep`. template auto join(It begin, Sentinel end, string_view sep) -> join_view { return {std::move(begin), end, sep}; } /** * Returns a view that formats `range` with elements separated by `sep`. * * **Example**: * * auto v = std::vector{1, 2, 3}; * fmt::print("{}", fmt::join(v, ", ")); * // Output: 1, 2, 3 * * `fmt::join` applies passed format specifiers to the range elements: * * fmt::print("{:02}", fmt::join(v, ", ")); * // Output: 01, 02, 03 */ template ::value)> auto join(Range&& r, string_view sep) -> join_view { return {detail::range_begin(r), detail::range_end(r), sep}; } /** * Returns an object that formats `std::tuple` with elements separated by `sep`. * * **Example**: * * auto t = std::tuple{1, 'a'}; * fmt::print("{}", fmt::join(t, ", ")); * // Output: 1, a */ template ::value)> FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep) -> tuple_join_view { return {tuple, sep}; } /** * Returns an object that formats `std::initializer_list` with elements * separated by `sep`. * * **Example**: * * fmt::print("{}", fmt::join({1, 2, 3}, ", ")); * // Output: "1, 2, 3" */ template auto join(std::initializer_list list, string_view sep) -> join_view { return join(std::begin(list), std::end(list), sep); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_RANGES_H_ aristocratos-btop-d43a485/include/fmt/std.h000066400000000000000000000536211517514752700207300ustar00rootroot00000000000000// Formatting library for C++ - formatters for standard library types // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_STD_H_ #define FMT_STD_H_ #include "format.h" #include "ostream.h" #ifndef FMT_MODULE # include # include # include # include # include // std::reference_wrapper # include # include # include # include // std::type_info # include // std::make_index_sequence // Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC. # if FMT_CPLUSPLUS >= 201703L # if FMT_HAS_INCLUDE() && \ (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0) # include # endif # if FMT_HAS_INCLUDE() # include # endif # if FMT_HAS_INCLUDE() # include # endif # endif // Use > instead of >= in the version check because may be // available after C++17 but before C++20 is marked as implemented. # if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE() # include # endif # if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE() # include # endif #endif // FMT_MODULE #if FMT_HAS_INCLUDE() # include #endif // GCC 4 does not support FMT_HAS_INCLUDE. #if FMT_HAS_INCLUDE() || defined(__GLIBCXX__) # include // Android NDK with gabi++ library on some architectures does not implement // abi::__cxa_demangle(). # ifndef __GABIXX_CXXABI_H__ # define FMT_HAS_ABI_CXA_DEMANGLE # endif #endif #ifdef FMT_CPP_LIB_FILESYSTEM // Use the provided definition. #elif defined(__cpp_lib_filesystem) # define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem #else # define FMT_CPP_LIB_FILESYSTEM 0 #endif #ifdef FMT_CPP_LIB_VARIANT // Use the provided definition. #elif defined(__cpp_lib_variant) # define FMT_CPP_LIB_VARIANT __cpp_lib_variant #else # define FMT_CPP_LIB_VARIANT 0 #endif FMT_BEGIN_NAMESPACE namespace detail { #if FMT_CPP_LIB_FILESYSTEM template auto get_path_string(const std::filesystem::path& p, const std::basic_string& native) { if constexpr (std::is_same_v && std::is_same_v) return to_utf8(native, to_utf8_error_policy::replace); else return p.string(); } template void write_escaped_path(basic_memory_buffer& quoted, const std::filesystem::path& p, const std::basic_string& native) { if constexpr (std::is_same_v && std::is_same_v) { auto buf = basic_memory_buffer(); write_escaped_string(std::back_inserter(buf), native); bool valid = to_utf8::convert(quoted, {buf.data(), buf.size()}); FMT_ASSERT(valid, "invalid utf16"); } else if constexpr (std::is_same_v) { write_escaped_string( std::back_inserter(quoted), native); } else { write_escaped_string(std::back_inserter(quoted), p.string()); } } #endif // FMT_CPP_LIB_FILESYSTEM #if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT template auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt { if constexpr (has_to_string_view::value) return write_escaped_string(out, detail::to_string_view(v)); if constexpr (std::is_same_v) return write_escaped_char(out, v); return write(out, v); } #endif #if FMT_CPP_LIB_VARIANT template struct is_variant_like_ : std::false_type {}; template struct is_variant_like_> : std::true_type {}; template class is_variant_formattable { template static auto check(std::index_sequence) -> std::conjunction< is_formattable, Char>...>; public: static constexpr bool value = decltype(check( std::make_index_sequence::value>()))::value; }; #endif // FMT_CPP_LIB_VARIANT #if FMT_USE_RTTI template auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt { # ifdef FMT_HAS_ABI_CXA_DEMANGLE int status = 0; size_t size = 0; std::unique_ptr demangled_name_ptr( abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free); string_view demangled_name_view; if (demangled_name_ptr) { demangled_name_view = demangled_name_ptr.get(); // Normalization of stdlib inline namespace names. // libc++ inline namespaces. // std::__1::* -> std::* // std::__1::__fs::* -> std::* // libstdc++ inline namespaces. // std::__cxx11::* -> std::* // std::filesystem::__cxx11::* -> std::filesystem::* if (demangled_name_view.starts_with("std::")) { char* begin = demangled_name_ptr.get(); char* to = begin + 5; // std:: for (char *from = to, *end = begin + demangled_name_view.size(); from < end;) { // This is safe, because demangled_name is NUL-terminated. if (from[0] == '_' && from[1] == '_') { char* next = from + 1; while (next < end && *next != ':') next++; if (next[0] == ':' && next[1] == ':') { from = next + 2; continue; } } *to++ = *from++; } demangled_name_view = {begin, detail::to_unsigned(to - begin)}; } } else { demangled_name_view = string_view(ti.name()); } return detail::write_bytes(out, demangled_name_view); # elif FMT_MSC_VERSION const string_view demangled_name(ti.name()); for (size_t i = 0; i < demangled_name.size(); ++i) { auto sub = demangled_name; sub.remove_prefix(i); if (sub.starts_with("enum ")) { i += 4; continue; } if (sub.starts_with("class ") || sub.starts_with("union ")) { i += 5; continue; } if (sub.starts_with("struct ")) { i += 6; continue; } if (*sub.begin() != ' ') *out++ = *sub.begin(); } return out; # else return detail::write_bytes(out, string_view(ti.name())); # endif } #endif // FMT_USE_RTTI template struct has_flip : std::false_type {}; template struct has_flip().flip())>> : std::true_type {}; template struct is_bit_reference_like { static constexpr bool value = std::is_convertible::value && std::is_nothrow_assignable::value && has_flip::value; }; // Workaround for libc++ incompatibility with C++ standard. // According to the Standard, `bitset::operator[] const` returns bool. #if defined(_LIBCPP_VERSION) && !defined(FMT_IMPORT_STD) template struct is_bit_reference_like> { static constexpr bool value = true; }; #endif template struct has_format_as : std::false_type {}; template struct has_format_as()))>> : std::true_type {}; template struct has_format_as_member : std::false_type {}; template struct has_format_as_member< T, void_t::format_as(std::declval()))>> : std::true_type {}; } // namespace detail template auto ptr(const std::unique_ptr& p) -> const void* { return p.get(); } template auto ptr(const std::shared_ptr& p) -> const void* { return p.get(); } #if FMT_CPP_LIB_FILESYSTEM class path : public std::filesystem::path { public: auto display_string() const -> std::string { const std::filesystem::path& base = *this; return fmt::format(FMT_STRING("{}"), base); } auto system_string() const -> std::string { return string(); } auto generic_display_string() const -> std::string { const std::filesystem::path& base = *this; return fmt::format(FMT_STRING("{:g}"), base); } auto generic_system_string() const -> std::string { return generic_string(); } }; template struct formatter { private: format_specs specs_; detail::arg_ref width_ref_; bool debug_ = false; char path_type_ = 0; public: FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; } FMT_CONSTEXPR auto parse(parse_context& ctx) { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; it = detail::parse_align(it, end, specs_); if (it == end) return it; Char c = *it; if ((c >= '0' && c <= '9') || c == '{') it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it != end && *it == '?') { debug_ = true; ++it; } if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++); return it; } template auto format(const std::filesystem::path& p, FormatContext& ctx) const { auto specs = specs_; auto path_string = !path_type_ ? p.native() : p.generic_string(); detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); if (!debug_) { auto s = detail::get_path_string(p, path_string); return detail::write(ctx.out(), basic_string_view(s), specs); } auto quoted = basic_memory_buffer(); detail::write_escaped_path(quoted, p, path_string); return detail::write(ctx.out(), basic_string_view(quoted.data(), quoted.size()), specs); } }; #endif // FMT_CPP_LIB_FILESYSTEM template struct formatter, Char> : nested_formatter, Char> { private: // This is a functor because C++11 doesn't support generic lambdas. struct writer { const std::bitset& bs; template FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt { for (auto pos = N; pos > 0; --pos) out = detail::write(out, bs[pos - 1] ? Char('1') : Char('0')); return out; } }; public: template auto format(const std::bitset& bs, FormatContext& ctx) const -> decltype(ctx.out()) { return this->write_padded(ctx, writer{bs}); } }; template struct formatter : basic_ostream_formatter {}; #ifdef __cpp_lib_optional template struct formatter, Char, std::enable_if_t::value>> { private: formatter underlying_; static constexpr basic_string_view optional = detail::string_literal{}; static constexpr basic_string_view none = detail::string_literal{}; template FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set) -> decltype(u.set_debug_format(set)) { u.set_debug_format(set); } template FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {} public: FMT_CONSTEXPR auto parse(parse_context& ctx) { maybe_set_debug_format(underlying_, true); return underlying_.parse(ctx); } template auto format(const std::optional& opt, FormatContext& ctx) const -> decltype(ctx.out()) { if (!opt) return detail::write(ctx.out(), none); auto out = ctx.out(); out = detail::write(out, optional); ctx.advance_to(out); out = underlying_.format(*opt, ctx); return detail::write(out, ')'); } }; #endif // __cpp_lib_optional #ifdef __cpp_lib_expected template struct formatter, Char, std::enable_if_t<(std::is_void::value || is_formattable::value) && is_formattable::value>> { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return ctx.begin(); } template auto format(const std::expected& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); if (value.has_value()) { out = detail::write(out, "expected("); if constexpr (!std::is_void::value) out = detail::write_escaped_alternative(out, *value); } else { out = detail::write(out, "unexpected("); out = detail::write_escaped_alternative(out, value.error()); } *out++ = ')'; return out; } }; #endif // __cpp_lib_expected #ifdef __cpp_lib_source_location template <> struct formatter { FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); } template auto format(const std::source_location& loc, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write(out, loc.file_name()); out = detail::write(out, ':'); out = detail::write(out, loc.line()); out = detail::write(out, ':'); out = detail::write(out, loc.column()); out = detail::write(out, ": "); out = detail::write(out, loc.function_name()); return out; } }; #endif #if FMT_CPP_LIB_VARIANT template struct is_variant_like { static constexpr bool value = detail::is_variant_like_::value; }; template struct formatter { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return ctx.begin(); } template auto format(const std::monostate&, FormatContext& ctx) const -> decltype(ctx.out()) { return detail::write(ctx.out(), "monostate"); } }; template struct formatter, detail::is_variant_formattable>>> { FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { return ctx.begin(); } template auto format(const Variant& value, FormatContext& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); out = detail::write(out, "variant("); FMT_TRY { std::visit( [&](const auto& v) { out = detail::write_escaped_alternative(out, v); }, value); } FMT_CATCH(const std::bad_variant_access&) { detail::write(out, "valueless by exception"); } *out++ = ')'; return out; } }; #endif // FMT_CPP_LIB_VARIANT template <> struct formatter { private: format_specs specs_; detail::arg_ref width_ref_; bool debug_ = false; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { auto it = ctx.begin(), end = ctx.end(); if (it == end) return it; it = detail::parse_align(it, end, specs_); char c = *it; if (it != end && ((c >= '0' && c <= '9') || c == '{')) it = detail::parse_width(it, end, specs_, width_ref_, ctx); if (it != end && *it == '?') { debug_ = true; ++it; } if (it != end && *it == 's') { specs_.set_type(presentation_type::string); ++it; } return it; } template FMT_CONSTEXPR20 auto format(const std::error_code& ec, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_, ctx); auto buf = memory_buffer(); if (specs_.type() == presentation_type::string) { buf.append(ec.message()); } else { buf.append(string_view(ec.category().name())); buf.push_back(':'); detail::write(appender(buf), ec.value()); } auto quoted = memory_buffer(); auto str = string_view(buf.data(), buf.size()); if (debug_) { detail::write_escaped_string(std::back_inserter(quoted), str); str = string_view(quoted.data(), quoted.size()); } return detail::write(ctx.out(), str, specs); } }; #if FMT_USE_RTTI template <> struct formatter { public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { return ctx.begin(); } template auto format(const std::type_info& ti, Context& ctx) const -> decltype(ctx.out()) { return detail::write_demangled_name(ctx.out(), ti); } }; #endif // FMT_USE_RTTI template struct formatter< T, char, typename std::enable_if::value>::type> { private: bool with_typename_ = false; public: FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* { auto it = ctx.begin(); auto end = ctx.end(); if (it == end || *it == '}') return it; if (*it == 't') { ++it; with_typename_ = FMT_USE_RTTI != 0; } return it; } template auto format(const std::exception& ex, Context& ctx) const -> decltype(ctx.out()) { auto out = ctx.out(); #if FMT_USE_RTTI if (with_typename_) { out = detail::write_demangled_name(out, typeid(ex)); *out++ = ':'; *out++ = ' '; } #endif return detail::write_bytes(out, string_view(ex.what())); } }; // We can't use std::vector::reference and // std::bitset::reference because the compiler can't deduce Allocator and N // in partial specialization. template struct formatter::value>> : formatter { template FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter::format(v, ctx); } }; template struct formatter, Char, enable_if_t::value>> : formatter { template auto format(const std::atomic& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter::format(v.load(), ctx); } }; #ifdef __cpp_lib_atomic_flag_test template struct formatter : formatter { template auto format(const std::atomic_flag& v, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter::format(v.test(), ctx); } }; #endif // __cpp_lib_atomic_flag_test template struct formatter, Char> { private: detail::dynamic_format_specs specs_; template FMT_CONSTEXPR auto do_format(const std::complex& c, detail::dynamic_format_specs& specs, FormatContext& ctx, OutputIt out) const -> OutputIt { if (c.real() != 0) { *out++ = Char('('); out = detail::write(out, c.real(), specs, ctx.locale()); specs.set_sign(sign::plus); out = detail::write(out, c.imag(), specs, ctx.locale()); if (!detail::isfinite(c.imag())) *out++ = Char(' '); *out++ = Char('i'); *out++ = Char(')'); return out; } out = detail::write(out, c.imag(), specs, ctx.locale()); if (!detail::isfinite(c.imag())) *out++ = Char(' '); *out++ = Char('i'); return out; } public: FMT_CONSTEXPR auto parse(parse_context& ctx) -> const Char* { if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin(); return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type_constant::value); } template auto format(const std::complex& c, FormatContext& ctx) const -> decltype(ctx.out()) { auto specs = specs_; if (specs.dynamic()) { detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, specs.width_ref, ctx); detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision, specs.precision_ref, ctx); } if (specs.width == 0) return do_format(c, specs, ctx, ctx.out()); auto buf = basic_memory_buffer(); auto outer_specs = format_specs(); outer_specs.width = specs.width; outer_specs.copy_fill_from(specs); outer_specs.set_align(specs.align()); specs.width = 0; specs.set_fill({}); specs.set_align(align::none); do_format(c, specs, ctx, basic_appender(buf)); return detail::write(ctx.out(), basic_string_view(buf.data(), buf.size()), outer_specs); } }; template struct formatter, Char, // Guard against format_as because reference_wrapper is // implicitly convertible to T&. enable_if_t, Char>::value && !detail::has_format_as::value && !detail::has_format_as_member::value>> : formatter, Char> { template auto format(std::reference_wrapper ref, FormatContext& ctx) const -> decltype(ctx.out()) { return formatter, Char>::format(ref.get(), ctx); } }; FMT_END_NAMESPACE #endif // FMT_STD_H_ aristocratos-btop-d43a485/include/fmt/xchar.h000066400000000000000000000314521517514752700212410ustar00rootroot00000000000000// Formatting library for C++ - optional wchar_t and exotic character support // // Copyright (c) 2012 - present, Victor Zverovich // All rights reserved. // // For the license information refer to format.h. #ifndef FMT_XCHAR_H_ #define FMT_XCHAR_H_ #include "color.h" #include "format.h" #include "ostream.h" #include "ranges.h" #ifndef FMT_MODULE # include # if FMT_USE_LOCALE # include # endif #endif FMT_BEGIN_NAMESPACE namespace detail { template using is_exotic_char = bool_constant::value>; template struct format_string_char {}; template struct format_string_char< S, void_t())))>> { using type = char_t; }; template struct format_string_char< S, enable_if_t::value>> { using type = typename S::char_type; }; template using format_string_char_t = typename format_string_char::type; inline auto write_loc(basic_appender out, loc_value value, const format_specs& specs, locale_ref loc) -> bool { #if FMT_USE_LOCALE auto& numpunct = std::use_facet>(loc.get()); auto separator = std::wstring(); auto grouping = numpunct.grouping(); if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep()); return value.visit(loc_writer{out, specs, separator, grouping, {}}); #endif return false; } template void vformat_to(buffer& buf, basic_string_view fmt, basic_format_args> args, locale_ref loc = {}) { static_assert(!std::is_same::value, ""); auto out = basic_appender(buf); parse_format_string( fmt, format_handler{parse_context(fmt), {out, args, loc}}); } } // namespace detail FMT_BEGIN_EXPORT using wstring_view = basic_string_view; using wformat_parse_context = parse_context; using wformat_context = buffered_context; using wformat_args = basic_format_args; using wmemory_buffer = basic_memory_buffer; template struct basic_fstring { private: basic_string_view str_; static constexpr int num_static_named_args = detail::count_static_named_args(); using checker = detail::format_string_checker< Char, static_cast(sizeof...(T)), num_static_named_args, num_static_named_args != detail::count_named_args()>; using arg_pack = detail::arg_pack; public: using t = basic_fstring; template >::value)> FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) { if (FMT_USE_CONSTEVAL) detail::parse_format_string(s, checker(s, arg_pack())); } template ::value&& std::is_same::value)> FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) { FMT_CONSTEXPR auto sv = basic_string_view(S()); FMT_CONSTEXPR int ignore = (parse_format_string(sv, checker(sv, arg_pack())), 0); detail::ignore_unused(ignore); } basic_fstring(runtime_format_string fmt) : str_(fmt.str) {} operator basic_string_view() const { return str_; } auto get() const -> basic_string_view { return str_; } }; template using basic_format_string = basic_fstring; template using wformat_string = typename basic_format_string::t; inline auto runtime(wstring_view s) -> runtime_format_string { return {{s}}; } template constexpr auto make_wformat_args(T&... args) -> decltype(fmt::make_format_args(args...)) { return fmt::make_format_args(args...); } #if !FMT_USE_NONTYPE_TEMPLATE_ARGS inline namespace literals { inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg { return {s}; } } // namespace literals #endif template auto join(It begin, Sentinel end, wstring_view sep) -> join_view { return {begin, end, sep}; } template ::value)> auto join(Range&& range, wstring_view sep) -> join_view { return join(std::begin(range), std::end(range), sep); } template auto join(std::initializer_list list, wstring_view sep) -> join_view { return join(std::begin(list), std::end(list), sep); } template ::value)> auto join(const Tuple& tuple, basic_string_view sep) -> tuple_join_view { return {tuple, sep}; } template ::value)> auto vformat(basic_string_view fmt, basic_format_args> args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vformat_to(buf, fmt, args); return {buf.data(), buf.size()}; } template auto format(wformat_string fmt, T&&... args) -> std::wstring { return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } template auto format_to(OutputIt out, wformat_string fmt, T&&... args) -> OutputIt { return vformat_to(out, fmt::wstring_view(fmt), fmt::make_wformat_args(args...)); } // Pass char_t as a default template parameter instead of using // std::basic_string> to reduce the symbol size. template , FMT_ENABLE_IF(!std::is_same::value && !std::is_same::value)> auto format(const S& fmt, T&&... args) -> std::basic_string { return vformat(detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_exotic_char::value)> inline auto vformat(locale_ref loc, const S& fmt, basic_format_args> args) -> std::basic_string { auto buf = basic_memory_buffer(); detail::vformat_to(buf, detail::to_string_view(fmt), args, loc); return {buf.data(), buf.size()}; } template , FMT_ENABLE_IF(detail::is_exotic_char::value)> inline auto format(locale_ref loc, const S& fmt, T&&... args) -> std::basic_string { return vformat(loc, detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> auto vformat_to(OutputIt out, const S& fmt, basic_format_args> args) -> OutputIt { auto&& buf = detail::get_buffer(out); detail::vformat_to(buf, detail::to_string_view(fmt), args); return detail::get_iterator(buf, out); } template , FMT_ENABLE_IF(detail::is_output_iterator::value && !std::is_same::value && !std::is_same::value)> inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt { return vformat_to(out, detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> inline auto vformat_to(OutputIt out, locale_ref loc, const S& fmt, basic_format_args> args) -> OutputIt { auto&& buf = detail::get_buffer(out); vformat_to(buf, detail::to_string_view(fmt), args, loc); return detail::get_iterator(buf, out); } template , bool enable = detail::is_output_iterator::value && detail::is_exotic_char::value> inline auto format_to(OutputIt out, locale_ref loc, const S& fmt, T&&... args) -> typename std::enable_if::type { return vformat_to(out, loc, detail::to_string_view(fmt), fmt::make_format_args>(args...)); } template ::value&& detail::is_exotic_char::value)> inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view fmt, basic_format_args> args) -> format_to_n_result { using traits = detail::fixed_buffer_traits; auto buf = detail::iterator_buffer(out, n); detail::vformat_to(buf, fmt, args); return {buf.out(), buf.count()}; } template , FMT_ENABLE_IF(detail::is_output_iterator::value&& detail::is_exotic_char::value)> inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args) -> format_to_n_result { return vformat_to_n(out, n, fmt::basic_string_view(fmt), fmt::make_format_args>(args...)); } template , FMT_ENABLE_IF(detail::is_exotic_char::value)> inline auto formatted_size(const S& fmt, T&&... args) -> size_t { auto buf = detail::counting_buffer(); detail::vformat_to(buf, detail::to_string_view(fmt), fmt::make_format_args>(args...)); return buf.count(); } inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) { auto buf = wmemory_buffer(); detail::vformat_to(buf, fmt, args); buf.push_back(L'\0'); if (std::fputws(buf.data(), f) == -1) FMT_THROW(system_error(errno, FMT_STRING("cannot write to file"))); } inline void vprint(wstring_view fmt, wformat_args args) { vprint(stdout, fmt, args); } template void print(std::FILE* f, wformat_string fmt, T&&... args) { return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...)); } template void print(wformat_string fmt, T&&... args) { return vprint(wstring_view(fmt), fmt::make_wformat_args(args...)); } template void println(std::FILE* f, wformat_string fmt, T&&... args) { return print(f, L"{}\n", fmt::format(fmt, std::forward(args)...)); } template void println(wformat_string fmt, T&&... args) { return print(L"{}\n", fmt::format(fmt, std::forward(args)...)); } inline auto vformat(text_style ts, wstring_view fmt, wformat_args args) -> std::wstring { auto buf = wmemory_buffer(); detail::vformat_to(buf, ts, fmt, args); return {buf.data(), buf.size()}; } template inline auto format(text_style ts, wformat_string fmt, T&&... args) -> std::wstring { return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...)); } inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) { auto buffer = basic_memory_buffer(); detail::vformat_to(buffer, fmt, args); detail::write_buffer(os, buffer); } template void print(std::wostream& os, wformat_string fmt, T&&... args) { vprint(os, fmt, fmt::make_format_args>(args...)); } template void println(std::wostream& os, wformat_string fmt, T&&... args) { print(os, L"{}\n", fmt::format(fmt, std::forward(args)...)); } /// Converts `value` to `std::wstring` using the default format for type `T`. template inline auto to_wstring(const T& value) -> std::wstring { return format(FMT_STRING(L"{}"), value); } FMT_END_EXPORT FMT_END_NAMESPACE #endif // FMT_XCHAR_H_ aristocratos-btop-d43a485/include/widechar_width.hpp000066400000000000000000001134751517514752700227010ustar00rootroot00000000000000/** * widechar_width.h for Unicode 17.0.0 * See https://github.com/ridiculousfish/widecharwidth/ * * SHA1 file hashes: * ( * the hashes for generate.py and the template are git object hashes, * use `git log --all --find-object=` in the widecharwidth repository * to see which commit they correspond to, * or run `git hash-object` on the file to compare. * The other hashes are simple `sha1sum` style hashes. * ) * * generate.py: b35da43f176cc0d5880c67356ebb064048c5bac4 * template.js: 1249763c5b7c1e308aeb4ca64f1e15bce1fab9b3 * UnicodeData.txt: 50dffef1b7d1f97b72e4c2adceb9b2245f0f34ba * EastAsianWidth.txt: 2cadc5034b6206ad84b75898a1d4186bb38fc12b * emoji-data.txt: 3d123e12f70f63e609c4281ce83dfdd9ac7443d2 */ #ifndef WIDECHAR_WIDTH_H #define WIDECHAR_WIDTH_H #include #include #include #include namespace { /* Special width values */ enum { widechar_nonprint = 0, // The character is not printable. widechar_combining = 0, // The character is a zero-width combiner. widechar_ambiguous = 1, // The character is East-Asian ambiguous width. widechar_private_use = 1, // The character is for private use. widechar_unassigned = 0, // The character is unassigned. widechar_widened_in_9 = 2, // Width is 1 in Unicode 8, 2 in Unicode 9+. widechar_non_character = 0 // The character is a noncharacter. }; /* An inclusive range of characters. */ struct widechar_range { uint32_t lo; uint32_t hi; }; /* Simple ASCII characters - used a lot, so we check them first. */ static const struct widechar_range widechar_ascii_table[] = { {0x00020, 0x0007E} }; /* Private usage range. */ static const struct widechar_range widechar_private_table[] = { {0x0E000, 0x0F8FF}, {0xF0000, 0xFFFFD}, {0x100000, 0x10FFFD} }; /* Nonprinting characters. */ static const struct widechar_range widechar_nonprint_table[] = { {0x00000, 0x0001F}, {0x0007F, 0x0009F}, {0x000AD, 0x000AD}, {0x00600, 0x00605}, {0x0061C, 0x0061C}, {0x006DD, 0x006DD}, {0x0070F, 0x0070F}, {0x00890, 0x00891}, {0x008E2, 0x008E2}, {0x0180E, 0x0180E}, {0x0200B, 0x0200F}, {0x02028, 0x0202E}, {0x02060, 0x02064}, {0x02066, 0x0206F}, {0x0D800, 0x0DFFF}, {0x0FEFF, 0x0FEFF}, {0x0FFF9, 0x0FFFB}, {0x110BD, 0x110BD}, {0x110CD, 0x110CD}, {0x13430, 0x1343F}, {0x1BCA0, 0x1BCA3}, {0x1D173, 0x1D17A}, {0xE0001, 0xE0001}, {0xE0020, 0xE007F} }; /* Width 0 combining marks. */ static const struct widechar_range widechar_combining_table[] = { {0x00300, 0x0036F}, {0x00483, 0x00489}, {0x00591, 0x005BD}, {0x005BF, 0x005BF}, {0x005C1, 0x005C2}, {0x005C4, 0x005C5}, {0x005C7, 0x005C7}, {0x00610, 0x0061A}, {0x0064B, 0x0065F}, {0x00670, 0x00670}, {0x006D6, 0x006DC}, {0x006DF, 0x006E4}, {0x006E7, 0x006E8}, {0x006EA, 0x006ED}, {0x00711, 0x00711}, {0x00730, 0x0074A}, {0x007A6, 0x007B0}, {0x007EB, 0x007F3}, {0x007FD, 0x007FD}, {0x00816, 0x00819}, {0x0081B, 0x00823}, {0x00825, 0x00827}, {0x00829, 0x0082D}, {0x00859, 0x0085B}, {0x00897, 0x0089F}, {0x008CA, 0x008E1}, {0x008E3, 0x00903}, {0x0093A, 0x0093C}, {0x0093E, 0x0094F}, {0x00951, 0x00957}, {0x00962, 0x00963}, {0x00981, 0x00983}, {0x009BC, 0x009BC}, {0x009BE, 0x009C4}, {0x009C7, 0x009C8}, {0x009CB, 0x009CD}, {0x009D7, 0x009D7}, {0x009E2, 0x009E3}, {0x009FE, 0x009FE}, {0x00A01, 0x00A03}, {0x00A3C, 0x00A3C}, {0x00A3E, 0x00A42}, {0x00A47, 0x00A48}, {0x00A4B, 0x00A4D}, {0x00A51, 0x00A51}, {0x00A70, 0x00A71}, {0x00A75, 0x00A75}, {0x00A81, 0x00A83}, {0x00ABC, 0x00ABC}, {0x00ABE, 0x00AC5}, {0x00AC7, 0x00AC9}, {0x00ACB, 0x00ACD}, {0x00AE2, 0x00AE3}, {0x00AFA, 0x00AFF}, {0x00B01, 0x00B03}, {0x00B3C, 0x00B3C}, {0x00B3E, 0x00B44}, {0x00B47, 0x00B48}, {0x00B4B, 0x00B4D}, {0x00B55, 0x00B57}, {0x00B62, 0x00B63}, {0x00B82, 0x00B82}, {0x00BBE, 0x00BC2}, {0x00BC6, 0x00BC8}, {0x00BCA, 0x00BCD}, {0x00BD7, 0x00BD7}, {0x00C00, 0x00C04}, {0x00C3C, 0x00C3C}, {0x00C3E, 0x00C44}, {0x00C46, 0x00C48}, {0x00C4A, 0x00C4D}, {0x00C55, 0x00C56}, {0x00C62, 0x00C63}, {0x00C81, 0x00C83}, {0x00CBC, 0x00CBC}, {0x00CBE, 0x00CC4}, {0x00CC6, 0x00CC8}, {0x00CCA, 0x00CCD}, {0x00CD5, 0x00CD6}, {0x00CE2, 0x00CE3}, {0x00CF3, 0x00CF3}, {0x00D00, 0x00D03}, {0x00D3B, 0x00D3C}, {0x00D3E, 0x00D44}, {0x00D46, 0x00D48}, {0x00D4A, 0x00D4D}, {0x00D57, 0x00D57}, {0x00D62, 0x00D63}, {0x00D81, 0x00D83}, {0x00DCA, 0x00DCA}, {0x00DCF, 0x00DD4}, {0x00DD6, 0x00DD6}, {0x00DD8, 0x00DDF}, {0x00DF2, 0x00DF3}, {0x00E31, 0x00E31}, {0x00E34, 0x00E3A}, {0x00E47, 0x00E4E}, {0x00EB1, 0x00EB1}, {0x00EB4, 0x00EBC}, {0x00EC8, 0x00ECE}, {0x00F18, 0x00F19}, {0x00F35, 0x00F35}, {0x00F37, 0x00F37}, {0x00F39, 0x00F39}, {0x00F3E, 0x00F3F}, {0x00F71, 0x00F84}, {0x00F86, 0x00F87}, {0x00F8D, 0x00F97}, {0x00F99, 0x00FBC}, {0x00FC6, 0x00FC6}, {0x0102B, 0x0103E}, {0x01056, 0x01059}, {0x0105E, 0x01060}, {0x01062, 0x01064}, {0x01067, 0x0106D}, {0x01071, 0x01074}, {0x01082, 0x0108D}, {0x0108F, 0x0108F}, {0x0109A, 0x0109D}, {0x0135D, 0x0135F}, {0x01712, 0x01715}, {0x01732, 0x01734}, {0x01752, 0x01753}, {0x01772, 0x01773}, {0x017B4, 0x017D3}, {0x017DD, 0x017DD}, {0x0180B, 0x0180D}, {0x0180F, 0x0180F}, {0x01885, 0x01886}, {0x018A9, 0x018A9}, {0x01920, 0x0192B}, {0x01930, 0x0193B}, {0x01A17, 0x01A1B}, {0x01A55, 0x01A5E}, {0x01A60, 0x01A7C}, {0x01A7F, 0x01A7F}, {0x01AB0, 0x01ADD}, {0x01AE0, 0x01AEB}, {0x01B00, 0x01B04}, {0x01B34, 0x01B44}, {0x01B6B, 0x01B73}, {0x01B80, 0x01B82}, {0x01BA1, 0x01BAD}, {0x01BE6, 0x01BF3}, {0x01C24, 0x01C37}, {0x01CD0, 0x01CD2}, {0x01CD4, 0x01CE8}, {0x01CED, 0x01CED}, {0x01CF4, 0x01CF4}, {0x01CF7, 0x01CF9}, {0x01DC0, 0x01DFF}, {0x020D0, 0x020F0}, {0x02CEF, 0x02CF1}, {0x02D7F, 0x02D7F}, {0x02DE0, 0x02DFF}, {0x0302A, 0x0302F}, {0x03099, 0x0309A}, {0x0A66F, 0x0A672}, {0x0A674, 0x0A67D}, {0x0A69E, 0x0A69F}, {0x0A6F0, 0x0A6F1}, {0x0A802, 0x0A802}, {0x0A806, 0x0A806}, {0x0A80B, 0x0A80B}, {0x0A823, 0x0A827}, {0x0A82C, 0x0A82C}, {0x0A880, 0x0A881}, {0x0A8B4, 0x0A8C5}, {0x0A8E0, 0x0A8F1}, {0x0A8FF, 0x0A8FF}, {0x0A926, 0x0A92D}, {0x0A947, 0x0A953}, {0x0A980, 0x0A983}, {0x0A9B3, 0x0A9C0}, {0x0A9E5, 0x0A9E5}, {0x0AA29, 0x0AA36}, {0x0AA43, 0x0AA43}, {0x0AA4C, 0x0AA4D}, {0x0AA7B, 0x0AA7D}, {0x0AAB0, 0x0AAB0}, {0x0AAB2, 0x0AAB4}, {0x0AAB7, 0x0AAB8}, {0x0AABE, 0x0AABF}, {0x0AAC1, 0x0AAC1}, {0x0AAEB, 0x0AAEF}, {0x0AAF5, 0x0AAF6}, {0x0ABE3, 0x0ABEA}, {0x0ABEC, 0x0ABED}, {0x0FB1E, 0x0FB1E}, {0x0FE00, 0x0FE0F}, {0x0FE20, 0x0FE2F}, {0x101FD, 0x101FD}, {0x102E0, 0x102E0}, {0x10376, 0x1037A}, {0x10A01, 0x10A03}, {0x10A05, 0x10A06}, {0x10A0C, 0x10A0F}, {0x10A38, 0x10A3A}, {0x10A3F, 0x10A3F}, {0x10AE5, 0x10AE6}, {0x10D24, 0x10D27}, {0x10D69, 0x10D6D}, {0x10EAB, 0x10EAC}, {0x10EFA, 0x10EFF}, {0x10F46, 0x10F50}, {0x10F82, 0x10F85}, {0x11000, 0x11002}, {0x11038, 0x11046}, {0x11070, 0x11070}, {0x11073, 0x11074}, {0x1107F, 0x11082}, {0x110B0, 0x110BA}, {0x110C2, 0x110C2}, {0x11100, 0x11102}, {0x11127, 0x11134}, {0x11145, 0x11146}, {0x11173, 0x11173}, {0x11180, 0x11182}, {0x111B3, 0x111C0}, {0x111C9, 0x111CC}, {0x111CE, 0x111CF}, {0x1122C, 0x11237}, {0x1123E, 0x1123E}, {0x11241, 0x11241}, {0x112DF, 0x112EA}, {0x11300, 0x11303}, {0x1133B, 0x1133C}, {0x1133E, 0x11344}, {0x11347, 0x11348}, {0x1134B, 0x1134D}, {0x11357, 0x11357}, {0x11362, 0x11363}, {0x11366, 0x1136C}, {0x11370, 0x11374}, {0x113B8, 0x113C0}, {0x113C2, 0x113C2}, {0x113C5, 0x113C5}, {0x113C7, 0x113CA}, {0x113CC, 0x113D0}, {0x113D2, 0x113D2}, {0x113E1, 0x113E2}, {0x11435, 0x11446}, {0x1145E, 0x1145E}, {0x114B0, 0x114C3}, {0x115AF, 0x115B5}, {0x115B8, 0x115C0}, {0x115DC, 0x115DD}, {0x11630, 0x11640}, {0x116AB, 0x116B7}, {0x1171D, 0x1172B}, {0x1182C, 0x1183A}, {0x11930, 0x11935}, {0x11937, 0x11938}, {0x1193B, 0x1193E}, {0x11940, 0x11940}, {0x11942, 0x11943}, {0x119D1, 0x119D7}, {0x119DA, 0x119E0}, {0x119E4, 0x119E4}, {0x11A01, 0x11A0A}, {0x11A33, 0x11A39}, {0x11A3B, 0x11A3E}, {0x11A47, 0x11A47}, {0x11A51, 0x11A5B}, {0x11A8A, 0x11A99}, {0x11B60, 0x11B67}, {0x11C2F, 0x11C36}, {0x11C38, 0x11C3F}, {0x11C92, 0x11CA7}, {0x11CA9, 0x11CB6}, {0x11D31, 0x11D36}, {0x11D3A, 0x11D3A}, {0x11D3C, 0x11D3D}, {0x11D3F, 0x11D45}, {0x11D47, 0x11D47}, {0x11D8A, 0x11D8E}, {0x11D90, 0x11D91}, {0x11D93, 0x11D97}, {0x11EF3, 0x11EF6}, {0x11F00, 0x11F01}, {0x11F03, 0x11F03}, {0x11F34, 0x11F3A}, {0x11F3E, 0x11F42}, {0x11F5A, 0x11F5A}, {0x13440, 0x13440}, {0x13447, 0x13455}, {0x1611E, 0x1612F}, {0x16AF0, 0x16AF4}, {0x16B30, 0x16B36}, {0x16F4F, 0x16F4F}, {0x16F51, 0x16F87}, {0x16F8F, 0x16F92}, {0x16FE4, 0x16FE4}, {0x16FF0, 0x16FF1}, {0x1BC9D, 0x1BC9E}, {0x1CF00, 0x1CF2D}, {0x1CF30, 0x1CF46}, {0x1D165, 0x1D169}, {0x1D16D, 0x1D172}, {0x1D17B, 0x1D182}, {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD}, {0x1D242, 0x1D244}, {0x1DA00, 0x1DA36}, {0x1DA3B, 0x1DA6C}, {0x1DA75, 0x1DA75}, {0x1DA84, 0x1DA84}, {0x1DA9B, 0x1DA9F}, {0x1DAA1, 0x1DAAF}, {0x1E000, 0x1E006}, {0x1E008, 0x1E018}, {0x1E01B, 0x1E021}, {0x1E023, 0x1E024}, {0x1E026, 0x1E02A}, {0x1E08F, 0x1E08F}, {0x1E130, 0x1E136}, {0x1E2AE, 0x1E2AE}, {0x1E2EC, 0x1E2EF}, {0x1E4EC, 0x1E4EF}, {0x1E5EE, 0x1E5EF}, {0x1E6E3, 0x1E6E3}, {0x1E6E6, 0x1E6E6}, {0x1E6EE, 0x1E6EF}, {0x1E6F5, 0x1E6F5}, {0x1E8D0, 0x1E8D6}, {0x1E944, 0x1E94A}, {0xE0100, 0xE01EF} }; /* Width 0 combining letters. */ static const struct widechar_range widechar_combiningletters_table[] = { {0x01160, 0x011FF}, {0x0D7B0, 0x0D7FF} }; /* Width 2 characters. */ static const struct widechar_range widechar_doublewide_table[] = { {0x01100, 0x0115F}, {0x02329, 0x0232A}, {0x02630, 0x02637}, {0x0268A, 0x0268F}, {0x02E80, 0x02E99}, {0x02E9B, 0x02EF3}, {0x02F00, 0x02FD5}, {0x02FF0, 0x0303E}, {0x03041, 0x03096}, {0x03099, 0x030FF}, {0x03105, 0x0312F}, {0x03131, 0x0318E}, {0x03190, 0x031E5}, {0x031EF, 0x0321E}, {0x03220, 0x03247}, {0x03250, 0x0A48C}, {0x0A490, 0x0A4C6}, {0x0A960, 0x0A97C}, {0x0AC00, 0x0D7A3}, {0x0F900, 0x0FAFF}, {0x0FE10, 0x0FE19}, {0x0FE30, 0x0FE52}, {0x0FE54, 0x0FE66}, {0x0FE68, 0x0FE6B}, {0x0FF01, 0x0FF60}, {0x0FFE0, 0x0FFE6}, {0x16FE0, 0x16FE4}, {0x16FF0, 0x16FF6}, {0x17000, 0x18CD5}, {0x18CFF, 0x18D1E}, {0x18D80, 0x18DF2}, {0x1AFF0, 0x1AFF3}, {0x1AFF5, 0x1AFFB}, {0x1AFFD, 0x1AFFE}, {0x1B000, 0x1B122}, {0x1B132, 0x1B132}, {0x1B150, 0x1B152}, {0x1B155, 0x1B155}, {0x1B164, 0x1B167}, {0x1B170, 0x1B2FB}, {0x1D300, 0x1D356}, {0x1D360, 0x1D376}, {0x1F200, 0x1F200}, {0x1F202, 0x1F202}, {0x1F210, 0x1F219}, {0x1F21B, 0x1F22E}, {0x1F230, 0x1F231}, {0x1F237, 0x1F237}, {0x1F23B, 0x1F23B}, {0x1F240, 0x1F248}, {0x1F260, 0x1F265}, {0x1F57A, 0x1F57A}, {0x1F5A4, 0x1F5A4}, {0x1F6D1, 0x1F6D2}, {0x1F6D5, 0x1F6D8}, {0x1F6DC, 0x1F6DF}, {0x1F6F4, 0x1F6FC}, {0x1F7E0, 0x1F7EB}, {0x1F7F0, 0x1F7F0}, {0x1F90C, 0x1F90F}, {0x1F919, 0x1F93A}, {0x1F93C, 0x1F945}, {0x1F947, 0x1F97F}, {0x1F985, 0x1F9BF}, {0x1F9C1, 0x1F9FF}, {0x1FA70, 0x1FA7C}, {0x1FA80, 0x1FA8A}, {0x1FA8E, 0x1FAC6}, {0x1FAC8, 0x1FAC8}, {0x1FACD, 0x1FADC}, {0x1FADF, 0x1FAEA}, {0x1FAEF, 0x1FAF8}, {0x20000, 0x2FFFD}, {0x30000, 0x3FFFD} }; /* Ambiguous-width characters. */ static const struct widechar_range widechar_ambiguous_table[] = { {0x000A1, 0x000A1}, {0x000A4, 0x000A4}, {0x000A7, 0x000A8}, {0x000AA, 0x000AA}, {0x000AD, 0x000AE}, {0x000B0, 0x000B4}, {0x000B6, 0x000BA}, {0x000BC, 0x000BF}, {0x000C6, 0x000C6}, {0x000D0, 0x000D0}, {0x000D7, 0x000D8}, {0x000DE, 0x000E1}, {0x000E6, 0x000E6}, {0x000E8, 0x000EA}, {0x000EC, 0x000ED}, {0x000F0, 0x000F0}, {0x000F2, 0x000F3}, {0x000F7, 0x000FA}, {0x000FC, 0x000FC}, {0x000FE, 0x000FE}, {0x00101, 0x00101}, {0x00111, 0x00111}, {0x00113, 0x00113}, {0x0011B, 0x0011B}, {0x00126, 0x00127}, {0x0012B, 0x0012B}, {0x00131, 0x00133}, {0x00138, 0x00138}, {0x0013F, 0x00142}, {0x00144, 0x00144}, {0x00148, 0x0014B}, {0x0014D, 0x0014D}, {0x00152, 0x00153}, {0x00166, 0x00167}, {0x0016B, 0x0016B}, {0x001CE, 0x001CE}, {0x001D0, 0x001D0}, {0x001D2, 0x001D2}, {0x001D4, 0x001D4}, {0x001D6, 0x001D6}, {0x001D8, 0x001D8}, {0x001DA, 0x001DA}, {0x001DC, 0x001DC}, {0x00251, 0x00251}, {0x00261, 0x00261}, {0x002C4, 0x002C4}, {0x002C7, 0x002C7}, {0x002C9, 0x002CB}, {0x002CD, 0x002CD}, {0x002D0, 0x002D0}, {0x002D8, 0x002DB}, {0x002DD, 0x002DD}, {0x002DF, 0x002DF}, {0x00300, 0x0036F}, {0x00391, 0x003A1}, {0x003A3, 0x003A9}, {0x003B1, 0x003C1}, {0x003C3, 0x003C9}, {0x00401, 0x00401}, {0x00410, 0x0044F}, {0x00451, 0x00451}, {0x02010, 0x02010}, {0x02013, 0x02016}, {0x02018, 0x02019}, {0x0201C, 0x0201D}, {0x02020, 0x02022}, {0x02024, 0x02027}, {0x02030, 0x02030}, {0x02032, 0x02033}, {0x02035, 0x02035}, {0x0203B, 0x0203B}, {0x0203E, 0x0203E}, {0x02074, 0x02074}, {0x0207F, 0x0207F}, {0x02081, 0x02084}, {0x020AC, 0x020AC}, {0x02103, 0x02103}, {0x02105, 0x02105}, {0x02109, 0x02109}, {0x02113, 0x02113}, {0x02116, 0x02116}, {0x02121, 0x02122}, {0x02126, 0x02126}, {0x0212B, 0x0212B}, {0x02153, 0x02154}, {0x0215B, 0x0215E}, {0x02160, 0x0216B}, {0x02170, 0x02179}, {0x02189, 0x02189}, {0x02190, 0x02199}, {0x021B8, 0x021B9}, {0x021D2, 0x021D2}, {0x021D4, 0x021D4}, {0x021E7, 0x021E7}, {0x02200, 0x02200}, {0x02202, 0x02203}, {0x02207, 0x02208}, {0x0220B, 0x0220B}, {0x0220F, 0x0220F}, {0x02211, 0x02211}, {0x02215, 0x02215}, {0x0221A, 0x0221A}, {0x0221D, 0x02220}, {0x02223, 0x02223}, {0x02225, 0x02225}, {0x02227, 0x0222C}, {0x0222E, 0x0222E}, {0x02234, 0x02237}, {0x0223C, 0x0223D}, {0x02248, 0x02248}, {0x0224C, 0x0224C}, {0x02252, 0x02252}, {0x02260, 0x02261}, {0x02264, 0x02267}, {0x0226A, 0x0226B}, {0x0226E, 0x0226F}, {0x02282, 0x02283}, {0x02286, 0x02287}, {0x02295, 0x02295}, {0x02299, 0x02299}, {0x022A5, 0x022A5}, {0x022BF, 0x022BF}, {0x02312, 0x02312}, {0x02460, 0x024E9}, {0x024EB, 0x0254B}, {0x02550, 0x02573}, {0x02580, 0x0258F}, {0x02592, 0x02595}, {0x025A0, 0x025A1}, {0x025A3, 0x025A9}, {0x025B2, 0x025B3}, {0x025B6, 0x025B7}, {0x025BC, 0x025BD}, {0x025C0, 0x025C1}, {0x025C6, 0x025C8}, {0x025CB, 0x025CB}, {0x025CE, 0x025D1}, {0x025E2, 0x025E5}, {0x025EF, 0x025EF}, {0x02605, 0x02606}, {0x02609, 0x02609}, {0x0260E, 0x0260F}, {0x0261C, 0x0261C}, {0x0261E, 0x0261E}, {0x02640, 0x02640}, {0x02642, 0x02642}, {0x02660, 0x02661}, {0x02663, 0x02665}, {0x02667, 0x0266A}, {0x0266C, 0x0266D}, {0x0266F, 0x0266F}, {0x0269E, 0x0269F}, {0x026BF, 0x026BF}, {0x026C6, 0x026CD}, {0x026CF, 0x026D3}, {0x026D5, 0x026E1}, {0x026E3, 0x026E3}, {0x026E8, 0x026E9}, {0x026EB, 0x026F1}, {0x026F4, 0x026F4}, {0x026F6, 0x026F9}, {0x026FB, 0x026FC}, {0x026FE, 0x026FF}, {0x0273D, 0x0273D}, {0x02776, 0x0277F}, {0x02B56, 0x02B59}, {0x03248, 0x0324F}, {0x0E000, 0x0F8FF}, {0x0FE00, 0x0FE0F}, {0x0FFFD, 0x0FFFD}, {0x1F100, 0x1F10A}, {0x1F110, 0x1F12D}, {0x1F130, 0x1F169}, {0x1F170, 0x1F18D}, {0x1F18F, 0x1F190}, {0x1F19B, 0x1F1AC}, {0xE0100, 0xE01EF}, {0xF0000, 0xFFFFD}, {0x100000, 0x10FFFD} }; /* Unassigned characters. */ static const struct widechar_range widechar_unassigned_table[] = { {0x00378, 0x00379}, {0x00380, 0x00383}, {0x0038B, 0x0038B}, {0x0038D, 0x0038D}, {0x003A2, 0x003A2}, {0x00530, 0x00530}, {0x00557, 0x00558}, {0x0058B, 0x0058C}, {0x00590, 0x00590}, {0x005C8, 0x005CF}, {0x005EB, 0x005EE}, {0x005F5, 0x005FF}, {0x0070E, 0x0070E}, {0x0074B, 0x0074C}, {0x007B2, 0x007BF}, {0x007FB, 0x007FC}, {0x0082E, 0x0082F}, {0x0083F, 0x0083F}, {0x0085C, 0x0085D}, {0x0085F, 0x0085F}, {0x0086B, 0x0086F}, {0x00892, 0x00896}, {0x00984, 0x00984}, {0x0098D, 0x0098E}, {0x00991, 0x00992}, {0x009A9, 0x009A9}, {0x009B1, 0x009B1}, {0x009B3, 0x009B5}, {0x009BA, 0x009BB}, {0x009C5, 0x009C6}, {0x009C9, 0x009CA}, {0x009CF, 0x009D6}, {0x009D8, 0x009DB}, {0x009DE, 0x009DE}, {0x009E4, 0x009E5}, {0x009FF, 0x00A00}, {0x00A04, 0x00A04}, {0x00A0B, 0x00A0E}, {0x00A11, 0x00A12}, {0x00A29, 0x00A29}, {0x00A31, 0x00A31}, {0x00A34, 0x00A34}, {0x00A37, 0x00A37}, {0x00A3A, 0x00A3B}, {0x00A3D, 0x00A3D}, {0x00A43, 0x00A46}, {0x00A49, 0x00A4A}, {0x00A4E, 0x00A50}, {0x00A52, 0x00A58}, {0x00A5D, 0x00A5D}, {0x00A5F, 0x00A65}, {0x00A77, 0x00A80}, {0x00A84, 0x00A84}, {0x00A8E, 0x00A8E}, {0x00A92, 0x00A92}, {0x00AA9, 0x00AA9}, {0x00AB1, 0x00AB1}, {0x00AB4, 0x00AB4}, {0x00ABA, 0x00ABB}, {0x00AC6, 0x00AC6}, {0x00ACA, 0x00ACA}, {0x00ACE, 0x00ACF}, {0x00AD1, 0x00ADF}, {0x00AE4, 0x00AE5}, {0x00AF2, 0x00AF8}, {0x00B00, 0x00B00}, {0x00B04, 0x00B04}, {0x00B0D, 0x00B0E}, {0x00B11, 0x00B12}, {0x00B29, 0x00B29}, {0x00B31, 0x00B31}, {0x00B34, 0x00B34}, {0x00B3A, 0x00B3B}, {0x00B45, 0x00B46}, {0x00B49, 0x00B4A}, {0x00B4E, 0x00B54}, {0x00B58, 0x00B5B}, {0x00B5E, 0x00B5E}, {0x00B64, 0x00B65}, {0x00B78, 0x00B81}, {0x00B84, 0x00B84}, {0x00B8B, 0x00B8D}, {0x00B91, 0x00B91}, {0x00B96, 0x00B98}, {0x00B9B, 0x00B9B}, {0x00B9D, 0x00B9D}, {0x00BA0, 0x00BA2}, {0x00BA5, 0x00BA7}, {0x00BAB, 0x00BAD}, {0x00BBA, 0x00BBD}, {0x00BC3, 0x00BC5}, {0x00BC9, 0x00BC9}, {0x00BCE, 0x00BCF}, {0x00BD1, 0x00BD6}, {0x00BD8, 0x00BE5}, {0x00BFB, 0x00BFF}, {0x00C0D, 0x00C0D}, {0x00C11, 0x00C11}, {0x00C29, 0x00C29}, {0x00C3A, 0x00C3B}, {0x00C45, 0x00C45}, {0x00C49, 0x00C49}, {0x00C4E, 0x00C54}, {0x00C57, 0x00C57}, {0x00C5B, 0x00C5B}, {0x00C5E, 0x00C5F}, {0x00C64, 0x00C65}, {0x00C70, 0x00C76}, {0x00C8D, 0x00C8D}, {0x00C91, 0x00C91}, {0x00CA9, 0x00CA9}, {0x00CB4, 0x00CB4}, {0x00CBA, 0x00CBB}, {0x00CC5, 0x00CC5}, {0x00CC9, 0x00CC9}, {0x00CCE, 0x00CD4}, {0x00CD7, 0x00CDB}, {0x00CDF, 0x00CDF}, {0x00CE4, 0x00CE5}, {0x00CF0, 0x00CF0}, {0x00CF4, 0x00CFF}, {0x00D0D, 0x00D0D}, {0x00D11, 0x00D11}, {0x00D45, 0x00D45}, {0x00D49, 0x00D49}, {0x00D50, 0x00D53}, {0x00D64, 0x00D65}, {0x00D80, 0x00D80}, {0x00D84, 0x00D84}, {0x00D97, 0x00D99}, {0x00DB2, 0x00DB2}, {0x00DBC, 0x00DBC}, {0x00DBE, 0x00DBF}, {0x00DC7, 0x00DC9}, {0x00DCB, 0x00DCE}, {0x00DD5, 0x00DD5}, {0x00DD7, 0x00DD7}, {0x00DE0, 0x00DE5}, {0x00DF0, 0x00DF1}, {0x00DF5, 0x00E00}, {0x00E3B, 0x00E3E}, {0x00E5C, 0x00E80}, {0x00E83, 0x00E83}, {0x00E85, 0x00E85}, {0x00E8B, 0x00E8B}, {0x00EA4, 0x00EA4}, {0x00EA6, 0x00EA6}, {0x00EBE, 0x00EBF}, {0x00EC5, 0x00EC5}, {0x00EC7, 0x00EC7}, {0x00ECF, 0x00ECF}, {0x00EDA, 0x00EDB}, {0x00EE0, 0x00EFF}, {0x00F48, 0x00F48}, {0x00F6D, 0x00F70}, {0x00F98, 0x00F98}, {0x00FBD, 0x00FBD}, {0x00FCD, 0x00FCD}, {0x00FDB, 0x00FFF}, {0x010C6, 0x010C6}, {0x010C8, 0x010CC}, {0x010CE, 0x010CF}, {0x01249, 0x01249}, {0x0124E, 0x0124F}, {0x01257, 0x01257}, {0x01259, 0x01259}, {0x0125E, 0x0125F}, {0x01289, 0x01289}, {0x0128E, 0x0128F}, {0x012B1, 0x012B1}, {0x012B6, 0x012B7}, {0x012BF, 0x012BF}, {0x012C1, 0x012C1}, {0x012C6, 0x012C7}, {0x012D7, 0x012D7}, {0x01311, 0x01311}, {0x01316, 0x01317}, {0x0135B, 0x0135C}, {0x0137D, 0x0137F}, {0x0139A, 0x0139F}, {0x013F6, 0x013F7}, {0x013FE, 0x013FF}, {0x0169D, 0x0169F}, {0x016F9, 0x016FF}, {0x01716, 0x0171E}, {0x01737, 0x0173F}, {0x01754, 0x0175F}, {0x0176D, 0x0176D}, {0x01771, 0x01771}, {0x01774, 0x0177F}, {0x017DE, 0x017DF}, {0x017EA, 0x017EF}, {0x017FA, 0x017FF}, {0x0181A, 0x0181F}, {0x01879, 0x0187F}, {0x018AB, 0x018AF}, {0x018F6, 0x018FF}, {0x0191F, 0x0191F}, {0x0192C, 0x0192F}, {0x0193C, 0x0193F}, {0x01941, 0x01943}, {0x0196E, 0x0196F}, {0x01975, 0x0197F}, {0x019AC, 0x019AF}, {0x019CA, 0x019CF}, {0x019DB, 0x019DD}, {0x01A1C, 0x01A1D}, {0x01A5F, 0x01A5F}, {0x01A7D, 0x01A7E}, {0x01A8A, 0x01A8F}, {0x01A9A, 0x01A9F}, {0x01AAE, 0x01AAF}, {0x01ADE, 0x01ADF}, {0x01AEC, 0x01AFF}, {0x01B4D, 0x01B4D}, {0x01BF4, 0x01BFB}, {0x01C38, 0x01C3A}, {0x01C4A, 0x01C4C}, {0x01C8B, 0x01C8F}, {0x01CBB, 0x01CBC}, {0x01CC8, 0x01CCF}, {0x01CFB, 0x01CFF}, {0x01F16, 0x01F17}, {0x01F1E, 0x01F1F}, {0x01F46, 0x01F47}, {0x01F4E, 0x01F4F}, {0x01F58, 0x01F58}, {0x01F5A, 0x01F5A}, {0x01F5C, 0x01F5C}, {0x01F5E, 0x01F5E}, {0x01F7E, 0x01F7F}, {0x01FB5, 0x01FB5}, {0x01FC5, 0x01FC5}, {0x01FD4, 0x01FD5}, {0x01FDC, 0x01FDC}, {0x01FF0, 0x01FF1}, {0x01FF5, 0x01FF5}, {0x01FFF, 0x01FFF}, {0x02065, 0x02065}, {0x02072, 0x02073}, {0x0208F, 0x0208F}, {0x0209D, 0x0209F}, {0x020C2, 0x020CF}, {0x020F1, 0x020FF}, {0x0218C, 0x0218F}, {0x0242A, 0x0243F}, {0x0244B, 0x0245F}, {0x02B74, 0x02B75}, {0x02CF4, 0x02CF8}, {0x02D26, 0x02D26}, {0x02D28, 0x02D2C}, {0x02D2E, 0x02D2F}, {0x02D68, 0x02D6E}, {0x02D71, 0x02D7E}, {0x02D97, 0x02D9F}, {0x02DA7, 0x02DA7}, {0x02DAF, 0x02DAF}, {0x02DB7, 0x02DB7}, {0x02DBF, 0x02DBF}, {0x02DC7, 0x02DC7}, {0x02DCF, 0x02DCF}, {0x02DD7, 0x02DD7}, {0x02DDF, 0x02DDF}, {0x02E5E, 0x02E7F}, {0x02E9A, 0x02E9A}, {0x02EF4, 0x02EFF}, {0x02FD6, 0x02FEF}, {0x03040, 0x03040}, {0x03097, 0x03098}, {0x03100, 0x03104}, {0x03130, 0x03130}, {0x0318F, 0x0318F}, {0x031E6, 0x031EE}, {0x0321F, 0x0321F}, {0x03401, 0x04DBE}, {0x04E01, 0x09FFE}, {0x0A48D, 0x0A48F}, {0x0A4C7, 0x0A4CF}, {0x0A62C, 0x0A63F}, {0x0A6F8, 0x0A6FF}, {0x0A7DD, 0x0A7F0}, {0x0A82D, 0x0A82F}, {0x0A83A, 0x0A83F}, {0x0A878, 0x0A87F}, {0x0A8C6, 0x0A8CD}, {0x0A8DA, 0x0A8DF}, {0x0A954, 0x0A95E}, {0x0A97D, 0x0A97F}, {0x0A9CE, 0x0A9CE}, {0x0A9DA, 0x0A9DD}, {0x0A9FF, 0x0A9FF}, {0x0AA37, 0x0AA3F}, {0x0AA4E, 0x0AA4F}, {0x0AA5A, 0x0AA5B}, {0x0AAC3, 0x0AADA}, {0x0AAF7, 0x0AB00}, {0x0AB07, 0x0AB08}, {0x0AB0F, 0x0AB10}, {0x0AB17, 0x0AB1F}, {0x0AB27, 0x0AB27}, {0x0AB2F, 0x0AB2F}, {0x0AB6C, 0x0AB6F}, {0x0ABEE, 0x0ABEF}, {0x0ABFA, 0x0ABFF}, {0x0AC01, 0x0D7A2}, {0x0D7A4, 0x0D7AF}, {0x0D7C7, 0x0D7CA}, {0x0D7FC, 0x0D7FF}, {0x0FA6E, 0x0FA6F}, {0x0FADA, 0x0FAFF}, {0x0FB07, 0x0FB12}, {0x0FB18, 0x0FB1C}, {0x0FB37, 0x0FB37}, {0x0FB3D, 0x0FB3D}, {0x0FB3F, 0x0FB3F}, {0x0FB42, 0x0FB42}, {0x0FB45, 0x0FB45}, {0x0FE1A, 0x0FE1F}, {0x0FE53, 0x0FE53}, {0x0FE67, 0x0FE67}, {0x0FE6C, 0x0FE6F}, {0x0FE75, 0x0FE75}, {0x0FEFD, 0x0FEFE}, {0x0FF00, 0x0FF00}, {0x0FFBF, 0x0FFC1}, {0x0FFC8, 0x0FFC9}, {0x0FFD0, 0x0FFD1}, {0x0FFD8, 0x0FFD9}, {0x0FFDD, 0x0FFDF}, {0x0FFE7, 0x0FFE7}, {0x0FFEF, 0x0FFF8}, {0x1000C, 0x1000C}, {0x10027, 0x10027}, {0x1003B, 0x1003B}, {0x1003E, 0x1003E}, {0x1004E, 0x1004F}, {0x1005E, 0x1007F}, {0x100FB, 0x100FF}, {0x10103, 0x10106}, {0x10134, 0x10136}, {0x1018F, 0x1018F}, {0x1019D, 0x1019F}, {0x101A1, 0x101CF}, {0x101FE, 0x1027F}, {0x1029D, 0x1029F}, {0x102D1, 0x102DF}, {0x102FC, 0x102FF}, {0x10324, 0x1032C}, {0x1034B, 0x1034F}, {0x1037B, 0x1037F}, {0x1039E, 0x1039E}, {0x103C4, 0x103C7}, {0x103D6, 0x103FF}, {0x1049E, 0x1049F}, {0x104AA, 0x104AF}, {0x104D4, 0x104D7}, {0x104FC, 0x104FF}, {0x10528, 0x1052F}, {0x10564, 0x1056E}, {0x1057B, 0x1057B}, {0x1058B, 0x1058B}, {0x10593, 0x10593}, {0x10596, 0x10596}, {0x105A2, 0x105A2}, {0x105B2, 0x105B2}, {0x105BA, 0x105BA}, {0x105BD, 0x105BF}, {0x105F4, 0x105FF}, {0x10737, 0x1073F}, {0x10756, 0x1075F}, {0x10768, 0x1077F}, {0x10786, 0x10786}, {0x107B1, 0x107B1}, {0x107BB, 0x107FF}, {0x10806, 0x10807}, {0x10809, 0x10809}, {0x10836, 0x10836}, {0x10839, 0x1083B}, {0x1083D, 0x1083E}, {0x10856, 0x10856}, {0x1089F, 0x108A6}, {0x108B0, 0x108DF}, {0x108F3, 0x108F3}, {0x108F6, 0x108FA}, {0x1091C, 0x1091E}, {0x1093A, 0x1093E}, {0x1095A, 0x1097F}, {0x109B8, 0x109BB}, {0x109D0, 0x109D1}, {0x10A04, 0x10A04}, {0x10A07, 0x10A0B}, {0x10A14, 0x10A14}, {0x10A18, 0x10A18}, {0x10A36, 0x10A37}, {0x10A3B, 0x10A3E}, {0x10A49, 0x10A4F}, {0x10A59, 0x10A5F}, {0x10AA0, 0x10ABF}, {0x10AE7, 0x10AEA}, {0x10AF7, 0x10AFF}, {0x10B36, 0x10B38}, {0x10B56, 0x10B57}, {0x10B73, 0x10B77}, {0x10B92, 0x10B98}, {0x10B9D, 0x10BA8}, {0x10BB0, 0x10BFF}, {0x10C49, 0x10C7F}, {0x10CB3, 0x10CBF}, {0x10CF3, 0x10CF9}, {0x10D28, 0x10D2F}, {0x10D3A, 0x10D3F}, {0x10D66, 0x10D68}, {0x10D86, 0x10D8D}, {0x10D90, 0x10E5F}, {0x10E7F, 0x10E7F}, {0x10EAA, 0x10EAA}, {0x10EAE, 0x10EAF}, {0x10EB2, 0x10EC1}, {0x10EC8, 0x10ECF}, {0x10ED9, 0x10EF9}, {0x10F28, 0x10F2F}, {0x10F5A, 0x10F6F}, {0x10F8A, 0x10FAF}, {0x10FCC, 0x10FDF}, {0x10FF7, 0x10FFF}, {0x1104E, 0x11051}, {0x11076, 0x1107E}, {0x110C3, 0x110CC}, {0x110CE, 0x110CF}, {0x110E9, 0x110EF}, {0x110FA, 0x110FF}, {0x11135, 0x11135}, {0x11148, 0x1114F}, {0x11177, 0x1117F}, {0x111E0, 0x111E0}, {0x111F5, 0x111FF}, {0x11212, 0x11212}, {0x11242, 0x1127F}, {0x11287, 0x11287}, {0x11289, 0x11289}, {0x1128E, 0x1128E}, {0x1129E, 0x1129E}, {0x112AA, 0x112AF}, {0x112EB, 0x112EF}, {0x112FA, 0x112FF}, {0x11304, 0x11304}, {0x1130D, 0x1130E}, {0x11311, 0x11312}, {0x11329, 0x11329}, {0x11331, 0x11331}, {0x11334, 0x11334}, {0x1133A, 0x1133A}, {0x11345, 0x11346}, {0x11349, 0x1134A}, {0x1134E, 0x1134F}, {0x11351, 0x11356}, {0x11358, 0x1135C}, {0x11364, 0x11365}, {0x1136D, 0x1136F}, {0x11375, 0x1137F}, {0x1138A, 0x1138A}, {0x1138C, 0x1138D}, {0x1138F, 0x1138F}, {0x113B6, 0x113B6}, {0x113C1, 0x113C1}, {0x113C3, 0x113C4}, {0x113C6, 0x113C6}, {0x113CB, 0x113CB}, {0x113D6, 0x113D6}, {0x113D9, 0x113E0}, {0x113E3, 0x113FF}, {0x1145C, 0x1145C}, {0x11462, 0x1147F}, {0x114C8, 0x114CF}, {0x114DA, 0x1157F}, {0x115B6, 0x115B7}, {0x115DE, 0x115FF}, {0x11645, 0x1164F}, {0x1165A, 0x1165F}, {0x1166D, 0x1167F}, {0x116BA, 0x116BF}, {0x116CA, 0x116CF}, {0x116E4, 0x116FF}, {0x1171B, 0x1171C}, {0x1172C, 0x1172F}, {0x11747, 0x117FF}, {0x1183C, 0x1189F}, {0x118F3, 0x118FE}, {0x11907, 0x11908}, {0x1190A, 0x1190B}, {0x11914, 0x11914}, {0x11917, 0x11917}, {0x11936, 0x11936}, {0x11939, 0x1193A}, {0x11947, 0x1194F}, {0x1195A, 0x1199F}, {0x119A8, 0x119A9}, {0x119D8, 0x119D9}, {0x119E5, 0x119FF}, {0x11A48, 0x11A4F}, {0x11AA3, 0x11AAF}, {0x11AF9, 0x11AFF}, {0x11B0A, 0x11B5F}, {0x11B68, 0x11BBF}, {0x11BE2, 0x11BEF}, {0x11BFA, 0x11BFF}, {0x11C09, 0x11C09}, {0x11C37, 0x11C37}, {0x11C46, 0x11C4F}, {0x11C6D, 0x11C6F}, {0x11C90, 0x11C91}, {0x11CA8, 0x11CA8}, {0x11CB7, 0x11CFF}, {0x11D07, 0x11D07}, {0x11D0A, 0x11D0A}, {0x11D37, 0x11D39}, {0x11D3B, 0x11D3B}, {0x11D3E, 0x11D3E}, {0x11D48, 0x11D4F}, {0x11D5A, 0x11D5F}, {0x11D66, 0x11D66}, {0x11D69, 0x11D69}, {0x11D8F, 0x11D8F}, {0x11D92, 0x11D92}, {0x11D99, 0x11D9F}, {0x11DAA, 0x11DAF}, {0x11DDC, 0x11DDF}, {0x11DEA, 0x11EDF}, {0x11EF9, 0x11EFF}, {0x11F11, 0x11F11}, {0x11F3B, 0x11F3D}, {0x11F5B, 0x11FAF}, {0x11FB1, 0x11FBF}, {0x11FF2, 0x11FFE}, {0x1239A, 0x123FF}, {0x1246F, 0x1246F}, {0x12475, 0x1247F}, {0x12544, 0x12F8F}, {0x12FF3, 0x12FFF}, {0x13456, 0x1345F}, {0x143FB, 0x143FF}, {0x14647, 0x160FF}, {0x1613A, 0x167FF}, {0x16A39, 0x16A3F}, {0x16A5F, 0x16A5F}, {0x16A6A, 0x16A6D}, {0x16ABF, 0x16ABF}, {0x16ACA, 0x16ACF}, {0x16AEE, 0x16AEF}, {0x16AF6, 0x16AFF}, {0x16B46, 0x16B4F}, {0x16B5A, 0x16B5A}, {0x16B62, 0x16B62}, {0x16B78, 0x16B7C}, {0x16B90, 0x16D3F}, {0x16D7A, 0x16E3F}, {0x16E9B, 0x16E9F}, {0x16EB9, 0x16EBA}, {0x16ED4, 0x16EFF}, {0x16F4B, 0x16F4E}, {0x16F88, 0x16F8E}, {0x16FA0, 0x16FDF}, {0x16FE5, 0x16FEF}, {0x16FF7, 0x16FFF}, {0x17001, 0x187FE}, {0x18CD6, 0x18CFE}, {0x18D01, 0x18D1D}, {0x18D1F, 0x18D7F}, {0x18DF3, 0x1AFEF}, {0x1AFF4, 0x1AFF4}, {0x1AFFC, 0x1AFFC}, {0x1AFFF, 0x1AFFF}, {0x1B123, 0x1B131}, {0x1B133, 0x1B14F}, {0x1B153, 0x1B154}, {0x1B156, 0x1B163}, {0x1B168, 0x1B16F}, {0x1B2FC, 0x1BBFF}, {0x1BC6B, 0x1BC6F}, {0x1BC7D, 0x1BC7F}, {0x1BC89, 0x1BC8F}, {0x1BC9A, 0x1BC9B}, {0x1BCA4, 0x1CBFF}, {0x1CCFD, 0x1CCFF}, {0x1CEB4, 0x1CEB9}, {0x1CED1, 0x1CEDF}, {0x1CEF1, 0x1CEFF}, {0x1CF2E, 0x1CF2F}, {0x1CF47, 0x1CF4F}, {0x1CFC4, 0x1CFFF}, {0x1D0F6, 0x1D0FF}, {0x1D127, 0x1D128}, {0x1D1EB, 0x1D1FF}, {0x1D246, 0x1D2BF}, {0x1D2D4, 0x1D2DF}, {0x1D2F4, 0x1D2FF}, {0x1D357, 0x1D35F}, {0x1D379, 0x1D3FF}, {0x1D455, 0x1D455}, {0x1D49D, 0x1D49D}, {0x1D4A0, 0x1D4A1}, {0x1D4A3, 0x1D4A4}, {0x1D4A7, 0x1D4A8}, {0x1D4AD, 0x1D4AD}, {0x1D4BA, 0x1D4BA}, {0x1D4BC, 0x1D4BC}, {0x1D4C4, 0x1D4C4}, {0x1D506, 0x1D506}, {0x1D50B, 0x1D50C}, {0x1D515, 0x1D515}, {0x1D51D, 0x1D51D}, {0x1D53A, 0x1D53A}, {0x1D53F, 0x1D53F}, {0x1D545, 0x1D545}, {0x1D547, 0x1D549}, {0x1D551, 0x1D551}, {0x1D6A6, 0x1D6A7}, {0x1D7CC, 0x1D7CD}, {0x1DA8C, 0x1DA9A}, {0x1DAA0, 0x1DAA0}, {0x1DAB0, 0x1DEFF}, {0x1DF1F, 0x1DF24}, {0x1DF2B, 0x1DFFF}, {0x1E007, 0x1E007}, {0x1E019, 0x1E01A}, {0x1E022, 0x1E022}, {0x1E025, 0x1E025}, {0x1E02B, 0x1E02F}, {0x1E06E, 0x1E08E}, {0x1E090, 0x1E0FF}, {0x1E12D, 0x1E12F}, {0x1E13E, 0x1E13F}, {0x1E14A, 0x1E14D}, {0x1E150, 0x1E28F}, {0x1E2AF, 0x1E2BF}, {0x1E2FA, 0x1E2FE}, {0x1E300, 0x1E4CF}, {0x1E4FA, 0x1E5CF}, {0x1E5FB, 0x1E5FE}, {0x1E600, 0x1E6BF}, {0x1E6DF, 0x1E6DF}, {0x1E6F6, 0x1E6FD}, {0x1E700, 0x1E7DF}, {0x1E7E7, 0x1E7E7}, {0x1E7EC, 0x1E7EC}, {0x1E7EF, 0x1E7EF}, {0x1E7FF, 0x1E7FF}, {0x1E8C5, 0x1E8C6}, {0x1E8D7, 0x1E8FF}, {0x1E94C, 0x1E94F}, {0x1E95A, 0x1E95D}, {0x1E960, 0x1EC70}, {0x1ECB5, 0x1ED00}, {0x1ED3E, 0x1EDFF}, {0x1EE04, 0x1EE04}, {0x1EE20, 0x1EE20}, {0x1EE23, 0x1EE23}, {0x1EE25, 0x1EE26}, {0x1EE28, 0x1EE28}, {0x1EE33, 0x1EE33}, {0x1EE38, 0x1EE38}, {0x1EE3A, 0x1EE3A}, {0x1EE3C, 0x1EE41}, {0x1EE43, 0x1EE46}, {0x1EE48, 0x1EE48}, {0x1EE4A, 0x1EE4A}, {0x1EE4C, 0x1EE4C}, {0x1EE50, 0x1EE50}, {0x1EE53, 0x1EE53}, {0x1EE55, 0x1EE56}, {0x1EE58, 0x1EE58}, {0x1EE5A, 0x1EE5A}, {0x1EE5C, 0x1EE5C}, {0x1EE5E, 0x1EE5E}, {0x1EE60, 0x1EE60}, {0x1EE63, 0x1EE63}, {0x1EE65, 0x1EE66}, {0x1EE6B, 0x1EE6B}, {0x1EE73, 0x1EE73}, {0x1EE78, 0x1EE78}, {0x1EE7D, 0x1EE7D}, {0x1EE7F, 0x1EE7F}, {0x1EE8A, 0x1EE8A}, {0x1EE9C, 0x1EEA0}, {0x1EEA4, 0x1EEA4}, {0x1EEAA, 0x1EEAA}, {0x1EEBC, 0x1EEEF}, {0x1EEF2, 0x1EFFF}, {0x1F02C, 0x1F02F}, {0x1F094, 0x1F09F}, {0x1F0AF, 0x1F0B0}, {0x1F0C0, 0x1F0C0}, {0x1F0D0, 0x1F0D0}, {0x1F0F6, 0x1F0FF}, {0x1F1AE, 0x1F1E5}, {0x1F203, 0x1F20F}, {0x1F23C, 0x1F23F}, {0x1F249, 0x1F24F}, {0x1F252, 0x1F25F}, {0x1F266, 0x1F2FF}, {0x1F6D9, 0x1F6DB}, {0x1F6ED, 0x1F6EF}, {0x1F6FD, 0x1F6FF}, {0x1F7DA, 0x1F7DF}, {0x1F7EC, 0x1F7EF}, {0x1F7F1, 0x1F7FF}, {0x1F80C, 0x1F80F}, {0x1F848, 0x1F84F}, {0x1F85A, 0x1F85F}, {0x1F888, 0x1F88F}, {0x1F8AE, 0x1F8AF}, {0x1F8BC, 0x1F8BF}, {0x1F8C2, 0x1F8CF}, {0x1F8D9, 0x1F8FF}, {0x1FA58, 0x1FA5F}, {0x1FA6E, 0x1FA6F}, {0x1FA7D, 0x1FA7F}, {0x1FA8B, 0x1FA8D}, {0x1FAC7, 0x1FAC7}, {0x1FAC9, 0x1FACC}, {0x1FADD, 0x1FADE}, {0x1FAEB, 0x1FAEE}, {0x1FAF9, 0x1FAFF}, {0x1FB93, 0x1FB93}, {0x1FBFB, 0x1FFFD}, {0x20001, 0x2A6DE}, {0x2A6E0, 0x2A6FF}, {0x2A701, 0x2B73E}, {0x2B741, 0x2B81C}, {0x2B81E, 0x2B81F}, {0x2B821, 0x2CEAC}, {0x2CEAE, 0x2CEAF}, {0x2CEB1, 0x2EBDF}, {0x2EBE1, 0x2EBEF}, {0x2EBF1, 0x2EE5C}, {0x2EE5E, 0x2F7FF}, {0x2FA1E, 0x2FFFD}, {0x30001, 0x31349}, {0x3134B, 0x3134F}, {0x31351, 0x323AE}, {0x323B1, 0x33478}, {0x3347A, 0x3FFFD}, {0x40000, 0x4FFFD}, {0x50000, 0x5FFFD}, {0x60000, 0x6FFFD}, {0x70000, 0x7FFFD}, {0x80000, 0x8FFFD}, {0x90000, 0x9FFFD}, {0xA0000, 0xAFFFD}, {0xB0000, 0xBFFFD}, {0xC0000, 0xCFFFD}, {0xD0000, 0xDFFFD}, {0xE0000, 0xE0000}, {0xE0002, 0xE001F}, {0xE0080, 0xE00FF}, {0xE01F0, 0xEFFFD} }; /* Non-characters. */ static const struct widechar_range widechar_nonchar_table[] = { {0x0FDD0, 0x0FDEF}, {0x0FFFE, 0x0FFFF}, {0x1FFFE, 0x1FFFF}, {0x2FFFE, 0x2FFFF}, {0x3FFFE, 0x3FFFF}, {0x4FFFE, 0x4FFFF}, {0x5FFFE, 0x5FFFF}, {0x6FFFE, 0x6FFFF}, {0x7FFFE, 0x7FFFF}, {0x8FFFE, 0x8FFFF}, {0x9FFFE, 0x9FFFF}, {0xAFFFE, 0xAFFFF}, {0xBFFFE, 0xBFFFF}, {0xCFFFE, 0xCFFFF}, {0xDFFFE, 0xDFFFF}, {0xEFFFE, 0xEFFFF}, {0xFFFFE, 0xFFFFF}, {0x10FFFE, 0x10FFFF} }; /* Characters that were widened from width 1 to 2 in Unicode 9. */ static const struct widechar_range widechar_widened_table[] = { {0x0231A, 0x0231B}, {0x023E9, 0x023EC}, {0x023F0, 0x023F0}, {0x023F3, 0x023F3}, {0x025FD, 0x025FE}, {0x02614, 0x02615}, {0x02648, 0x02653}, {0x0267F, 0x0267F}, {0x02693, 0x02693}, {0x026A1, 0x026A1}, {0x026AA, 0x026AB}, {0x026BD, 0x026BE}, {0x026C4, 0x026C5}, {0x026CE, 0x026CE}, {0x026D4, 0x026D4}, {0x026EA, 0x026EA}, {0x026F2, 0x026F3}, {0x026F5, 0x026F5}, {0x026FA, 0x026FA}, {0x026FD, 0x026FD}, {0x02705, 0x02705}, {0x0270A, 0x0270B}, {0x02728, 0x02728}, {0x0274C, 0x0274C}, {0x0274E, 0x0274E}, {0x02753, 0x02755}, {0x02757, 0x02757}, {0x02795, 0x02797}, {0x027B0, 0x027B0}, {0x027BF, 0x027BF}, {0x02B1B, 0x02B1C}, {0x02B50, 0x02B50}, {0x02B55, 0x02B55}, {0x1F004, 0x1F004}, {0x1F0CF, 0x1F0CF}, {0x1F18E, 0x1F18E}, {0x1F191, 0x1F19A}, {0x1F201, 0x1F201}, {0x1F21A, 0x1F21A}, {0x1F22F, 0x1F22F}, {0x1F232, 0x1F236}, {0x1F238, 0x1F23A}, {0x1F250, 0x1F251}, {0x1F300, 0x1F320}, {0x1F32D, 0x1F335}, {0x1F337, 0x1F37C}, {0x1F37E, 0x1F393}, {0x1F3A0, 0x1F3CA}, {0x1F3CF, 0x1F3D3}, {0x1F3E0, 0x1F3F0}, {0x1F3F4, 0x1F3F4}, {0x1F3F8, 0x1F43E}, {0x1F440, 0x1F440}, {0x1F442, 0x1F4FC}, {0x1F4FF, 0x1F53D}, {0x1F54B, 0x1F54E}, {0x1F550, 0x1F567}, {0x1F595, 0x1F596}, {0x1F5FB, 0x1F64F}, {0x1F680, 0x1F6C5}, {0x1F6CC, 0x1F6CC}, {0x1F6D0, 0x1F6D0}, {0x1F6EB, 0x1F6EC}, {0x1F910, 0x1F918}, {0x1F980, 0x1F984}, {0x1F9C0, 0x1F9C0} }; template bool widechar_in_table(const Collection &arr, uint32_t c) { auto where = std::lower_bound(std::begin(arr), std::end(arr), c, [](widechar_range p, uint32_t c) { return p.hi < c; }); return where != std::end(arr) && where->lo <= c; } /* Return the width of character c, or a special negative value. */ int widechar_wcwidth(uint32_t c) { if (widechar_in_table(widechar_ascii_table, c)) return 1; if (widechar_in_table(widechar_private_table, c)) return widechar_private_use; if (widechar_in_table(widechar_nonprint_table, c)) return widechar_nonprint; if (widechar_in_table(widechar_nonchar_table, c)) return widechar_non_character; if (widechar_in_table(widechar_combining_table, c)) return widechar_combining; if (widechar_in_table(widechar_combiningletters_table, c)) return widechar_combining; if (widechar_in_table(widechar_doublewide_table, c)) return 2; if (widechar_in_table(widechar_ambiguous_table, c)) return widechar_ambiguous; if (widechar_in_table(widechar_unassigned_table, c)) return widechar_unassigned; if (widechar_in_table(widechar_widened_table, c)) return widechar_widened_in_9; return 1; } } // namespace #endif // WIDECHAR_WIDTH_Haristocratos-btop-d43a485/manpage.md000066400000000000000000000034401517514752700175000ustar00rootroot00000000000000% btop(1) | User Commands % % 2025-05-01 # NAME btop - Resource monitor that shows usage and stats for processor, memory, disks, network, and processes. # SYNOPSIS **btop** [**-c** _file_] [**-d**] [**-f** _filter_] [**-l**] [**-p** _id_] [**-t**] [**-u** _ms_] [**\-\-force-utf**] [**\-\-themes-dir** _dir_] **btop** [**\-\-default-config** | {**-h** | **\-\-help**} | {**-V** | **\-\-version**}] # DESCRIPTION **btop** is a program that shows usage and stats for processor, memory, disks, network, and processes. # OPTIONS The program follows the usual GNU command line syntax, with long options starting with two dashes ('-'). A summary of options is included below. **-c**, **\-\-config _file_** : Path to a config file. **-d**, **\-\-debug** : Start in debug mode with additional logs and metrics. **-f**, **\-\-filter _filter_** : Set an initial process filter. **\-\-force-utf** : Force start even if no UTF-8 locale was detected. **-l**, **\-\-low-color** : Disable true color, 256 colors only. **-p**, **\-\-preset _id_** : Start with a preset (0-9). **-t**, **\-\-tty** : Force tty mode with ANSI graph symbols and 16 colors only. **\-\-no-tty** : Force disable tty mode. **\-\-themes-dir _dir_** : Path to a custom themes directory. When specified, this directory takes priority over the default theme search paths. **-u**, **\-\-update _ms_** : Set an initial update rate in milliseconds. **\-\-default-config** : Print default config to standard output. **-h**, **\-\-help** : Show summary of options. **-V**, **\-\-version** : Show version of program. # BUGS The upstream bug tracker can be found at https://github.com/aristocratos/btop/issues. # SEE ALSO **top**(1), **htop**(1) # AUTHOR **btop** was written by Jakob P. Liljenberg a.k.a. "Aristocratos". aristocratos-btop-d43a485/snap/000077500000000000000000000000001517514752700165065ustar00rootroot00000000000000aristocratos-btop-d43a485/snap/snapcraft.yaml000066400000000000000000000026131517514752700213550ustar00rootroot00000000000000name: btop adopt-info: btop summary: Resource monitor that shows usage and stats description: | Resource monitor that shows usage and stats for processor, memory, disks, network and processes. C++ version and continuation of bashtop and bpytop. license: Apache-2.0 base: core24 grade: stable confinement: strict compression: lzo contact: https://github.com/kz6fittycent/btop/issues issues: https://github.com/kz6fittycent/btop/issues source-code: https://github.com/aristocratos/btop platforms: amd64: build-on: [amd64] build-for: [amd64] arm64: build-on: [arm64] build-for: [arm64] apps: btop: command: usr/local/bin/btop environment: LC_ALL: C.UTF-8 LANG: C.UTF-8 plugs: - mount-observe - process-control - system-observe - hardware-observe - network - network-observe - home - removable-media - opengl parts: btop: source: https://github.com/aristocratos/btop source-type: git plugin: make make-parameters: - CC=gcc-14 - CXX=g++-14 - PREFIX=/usr/local - STATIC=true #required - ADDFLAGS="-D SNAPPED" #required build-packages: - coreutils - sed - git - build-essential - gcc-14 - g++-14 override-pull: | craftctl default craftctl set version="$(git describe --tags | sed 's/^v//' | cut -d "-" -f1)" aristocratos-btop-d43a485/src/000077500000000000000000000000001517514752700163345ustar00rootroot00000000000000aristocratos-btop-d43a485/src/btop.cpp000066400000000000000000001061251517514752700200110ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include "btop.hpp" #include #include #include #include #include #include #include #include #include #include #include #ifdef __FreeBSD__ #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __APPLE__ #include #include #include #endif #ifdef __NetBSD__ #include #include #include #endif #include #include #include "btop_cli.hpp" #include "btop_config.hpp" #include "btop_draw.hpp" #include "btop_input.hpp" #include "btop_log.hpp" #include "btop_menu.hpp" #include "btop_shared.hpp" #include "btop_theme.hpp" #include "btop_tools.hpp" using std::atomic; using std::cout; using std::flush; using std::min; using std::string; using std::string_view; using std::to_string; using std::vector; namespace fs = std::filesystem; using namespace Tools; using namespace std::chrono_literals; using namespace std::literals; namespace Global { const vector> Banner_src = { {"#E62525", "โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•— โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•— โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•— โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•—"}, {"#CD2121", "โ–ˆโ–ˆโ•”โ•โ•โ–ˆโ–ˆโ•—โ•šโ•โ•โ–ˆโ–ˆโ•”โ•โ•โ•โ–ˆโ–ˆโ•”โ•โ•โ•โ–ˆโ–ˆโ•—โ–ˆโ–ˆโ•”โ•โ•โ–ˆโ–ˆโ•— โ–ˆโ–ˆโ•— โ–ˆโ–ˆโ•—"}, {"#B31D1D", "โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•”โ• โ–ˆโ–ˆโ•‘ โ–ˆโ–ˆโ•‘ โ–ˆโ–ˆโ•‘โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•”โ• โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•—โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•—"}, {"#9A1919", "โ–ˆโ–ˆโ•”โ•โ•โ–ˆโ–ˆโ•— โ–ˆโ–ˆโ•‘ โ–ˆโ–ˆโ•‘ โ–ˆโ–ˆโ•‘โ–ˆโ–ˆโ•”โ•โ•โ•โ• โ•šโ•โ–ˆโ–ˆโ•”โ•โ•โ•šโ•โ–ˆโ–ˆโ•”โ•โ•"}, {"#801414", "โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•”โ• โ–ˆโ–ˆโ•‘ โ•šโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ•”โ•โ–ˆโ–ˆโ•‘ โ•šโ•โ• โ•šโ•โ•"}, {"#000000", "โ•šโ•โ•โ•โ•โ•โ• โ•šโ•โ• โ•šโ•โ•โ•โ•โ•โ• โ•šโ•โ•"}, }; const string Version = "1.4.7"; int coreCount; string overlay; string clock; string bg_black = "\x1b[0;40m"; string fg_white = "\x1b[1;97m"; string fg_green = "\x1b[1;92m"; string fg_red = "\x1b[0;91m"; uid_t real_uid, set_uid; fs::path self_path; string exit_error_msg; atomic thread_exception (false); bool debug{}; uint64_t start_time; atomic resized (false); atomic quitting (false); atomic should_quit (false); atomic should_sleep (false); atomic _runner_started (false); atomic init_conf (false); atomic reload_conf (false); } namespace Runner { static pthread_t runner_id; } // namespace Runner //* Handler for SIGWINCH and general resizing events, does nothing if terminal hasn't been resized unless force=true void term_resize(bool force) { static atomic resizing (false); if (Input::polling) { Global::resized = true; Input::interrupt(); return; } atomic_lock lck(resizing, true); if (auto refreshed = Term::refresh(true); refreshed or force) { if (force and refreshed) force = false; } else return; #ifdef GPU_SUPPORT static const array all_boxes = {"gpu5", "cpu", "mem", "net", "proc", "gpu0", "gpu1", "gpu2", "gpu3", "gpu4"}; #else static const array all_boxes = {"", "cpu", "mem", "net", "proc"}; #endif Global::resized = true; if (Runner::active) Runner::stop(); Term::refresh(); Config::unlock(); auto boxes = Config::getS("shown_boxes"); auto min_size = Term::get_min_size(boxes); auto minWidth = min_size.at(0), minHeight = min_size.at(1); while (not force or (Term::width < minWidth or Term::height < minHeight)) { sleep_ms(100); if (Term::width < minWidth or Term::height < minHeight) { int width = Term::width, height = Term::height; cout << fmt::format("{clear}{bg_black}{fg_white}" "{mv1}Terminal size too small:" "{mv2} Width = {fg_width}{width} {fg_white}Height = {fg_height}{height}" "{mv3}{fg_white}Needed for current config:" "{mv4}Width = {minWidth} Height = {minHeight}", "clear"_a = Term::clear, "bg_black"_a = Global::bg_black, "fg_white"_a = Global::fg_white, "mv1"_a = Mv::to((height / 2) - 2, (width / 2) - 11), "mv2"_a = Mv::to((height / 2) - 1, (width / 2) - 10), "fg_width"_a = (width < minWidth ? Global::fg_red : Global::fg_green), "width"_a = width, "fg_height"_a = (height < minHeight ? Global::fg_red : Global::fg_green), "height"_a = height, "mv3"_a = Mv::to((height / 2) + 1, (width / 2) - 12), "mv4"_a = Mv::to((height / 2) + 2, (width / 2) - 10), "minWidth"_a = minWidth, "minHeight"_a = minHeight ) << std::flush; bool got_key = false; for (; not Term::refresh() and not got_key; got_key = Input::poll(10)); if (got_key) { auto key = Input::get(); if (key == "q") clean_quit(0); else if (key.size() == 1 and isint(key)) { auto intKey = stoi(key); #ifdef GPU_SUPPORT if ((intKey == 0 and Gpu::count >= 5) or (intKey >= 5 and intKey - 4 <= Gpu::count)) { #else if (intKey > 0 and intKey < 5) { #endif const auto& box = all_boxes.at(intKey); Config::current_preset.reset(); Config::toggle_box(box); boxes = Config::getS("shown_boxes"); } } } min_size = Term::get_min_size(boxes); minWidth = min_size.at(0); minHeight = min_size.at(1); } else if (not Term::refresh()) break; } Input::interrupt(); } //* Exit handler; stops threads, restores terminal and saves config changes void clean_quit(int sig) { if (Global::quitting) return; Global::quitting = true; Runner::stop(); if (Global::_runner_started) { #if defined __APPLE__ || defined __OpenBSD__ || defined __NetBSD__ if (pthread_join(Runner::runner_id, nullptr) != 0) { Logger::warning("Failed to join _runner thread on exit!"); pthread_cancel(Runner::runner_id); } #else constexpr struct timespec ts { .tv_sec = 5, .tv_nsec = 0 }; if (pthread_timedjoin_np(Runner::runner_id, nullptr, &ts) != 0) { Logger::warning("Failed to join _runner thread on exit!"); pthread_cancel(Runner::runner_id); } #endif } #ifdef GPU_SUPPORT Gpu::Nvml::shutdown(); Gpu::Rsmi::shutdown(); #ifdef __APPLE__ Gpu::AppleSilicon::shutdown(); #endif #endif if (Config::getB("save_config_on_exit")) { Config::write(); } if (Term::initialized) { Input::clear(); Term::restore(); } if (not Global::exit_error_msg.empty()) { sig = 1; Logger::error("{}", Global::exit_error_msg); fmt::println(std::cerr, "{}ERROR: {}{}{}", Global::fg_red, Global::fg_white, Global::exit_error_msg, Fx::reset); } Logger::info("Quitting! Runtime: {}", sec_to_dhms(time_s() - Global::start_time)); const auto excode = (sig != -1 ? sig : 0); #if defined __APPLE__ || defined __OpenBSD__ || defined __NetBSD__ _Exit(excode); #else quick_exit(excode); #endif } //* Handler for SIGTSTP; stops threads, restores terminal and sends SIGSTOP static void _sleep() { Runner::stop(); Term::restore(); std::raise(SIGSTOP); } //* Handler for SIGCONT; re-initialize terminal and force a resize event static void _resume() { Term::init(); term_resize(true); } static void _exit_handler() { clean_quit(-1); } static void _crash_handler(const int sig) { // Restore terminal before crashing if (Term::initialized) { Term::restore(); } // Re-raise the signal to get default behavior (core dump) std::signal(sig, SIG_DFL); std::raise(sig); } static void _signal_handler(const int sig) { switch (sig) { case SIGINT: if (Runner::active) { Global::should_quit = true; Runner::stopping = true; Input::interrupt(); } else { clean_quit(0); } break; case SIGTSTP: if (Runner::active) { Global::should_sleep = true; Runner::stopping = true; Input::interrupt(); } else { _sleep(); } break; case SIGCONT: _resume(); break; case SIGWINCH: term_resize(); break; case SIGUSR1: // Input::poll interrupt break; case SIGUSR2: Global::reload_conf = true; Input::interrupt(); break; } } //* Config init void init_config(bool low_color, std::optional& filter) { atomic_lock lck(Global::init_conf); vector load_warnings; Config::load(Config::conf_file, load_warnings); Config::set("lowcolor", (low_color ? true : not Config::getB("truecolor"))); static bool first_init = true; if (Global::debug and first_init) { Logger::set_log_level(Logger::Level::DEBUG); Logger::debug("Running in DEBUG mode!"); } else Logger::set_log_level(Config::getS("log_level")); if (filter.has_value()) { Config::set("proc_filter", filter.value()); } static string log_level; if (const string current_level = Config::getS("log_level"); log_level != current_level) { log_level = current_level; Logger::info("Logger set to {}", (Global::debug ? "DEBUG" : log_level)); } for (const auto& err_str : load_warnings) Logger::warning("{}", err_str); first_init = false; } //* Manages secondary thread for collection and drawing of boxes namespace Runner { atomic active (false); atomic stopping (false); atomic waiting (false); atomic redraw (false); atomic coreNum_reset (false); static inline auto set_active(bool value) noexcept { active.store(value, std::memory_order_relaxed); active.notify_all(); } //* Setup semaphore for triggering thread to do work // TODO: This can be made a local without too much effort. std::binary_semaphore do_work { 0 }; inline void thread_wait() { do_work.acquire(); } inline void thread_trigger() { do_work.release(); } //* Wrapper for raising privileges when using SUID bit class gain_priv { int status = -1; public: gain_priv() { if (Global::real_uid != Global::set_uid) this->status = seteuid(Global::set_uid); } ~gain_priv() noexcept { if (status == 0) status = seteuid(Global::real_uid); } gain_priv(const gain_priv& other) = delete; gain_priv& operator=(const gain_priv& other) = delete; gain_priv(gain_priv&& other) = delete; gain_priv& operator=(gain_priv&& other) = delete; }; string output; string empty_bg; bool pause_output{}; sigset_t mask; std::mutex mtx; enum debug_actions { collect_begin, collect_done, draw_begin, draw_begin_only, draw_done }; enum debug_array { collect, draw }; string debug_bg; std::unordered_map> debug_times; class MyNumPunct : public std::numpunct { protected: virtual char do_thousands_sep() const override { return '\''; } virtual std::string do_grouping() const override { return "\03"; } }; struct runner_conf { vector boxes; bool no_update; bool force_redraw; bool background_update; string overlay; string clock; }; struct runner_conf current_conf; static void debug_timer(const char* name, const int action) { switch (action) { case collect_begin: debug_times[name].at(collect) = time_micros(); return; case collect_done: debug_times[name].at(collect) = time_micros() - debug_times[name].at(collect); debug_times["total"].at(collect) += debug_times[name].at(collect); return; case draw_begin_only: debug_times[name].at(draw) = time_micros(); return; case draw_begin: debug_times[name].at(draw) = time_micros(); debug_times[name].at(collect) = debug_times[name].at(draw) - debug_times[name].at(collect); debug_times["total"].at(collect) += debug_times[name].at(collect); return; case draw_done: debug_times[name].at(draw) = time_micros() - debug_times[name].at(draw); debug_times["total"].at(draw) += debug_times[name].at(draw); return; } } //? ------------------------------- Secondary thread: async launcher and drawing ---------------------------------- static void * _runner(void *) { //? Block some signals in this thread to avoid deadlock from any signal handlers trying to stop this thread sigemptyset(&mask); // sigaddset(&mask, SIGINT); // sigaddset(&mask, SIGTSTP); sigaddset(&mask, SIGWINCH); sigaddset(&mask, SIGTERM); pthread_sigmask(SIG_BLOCK, &mask, nullptr); // TODO: On first glance it looks redudant with `Runner::active`. std::lock_guard lock {mtx}; //* ----------------------------------------------- THREAD LOOP ----------------------------------------------- while (not Global::quitting) { thread_wait(); atomic_wait_for(active, true, 5000); if (active) { Global::exit_error_msg = "Runner thread failed to get active lock!"; Global::thread_exception = true; Input::interrupt(); stopping = true; } if (stopping or Global::resized) { sleep_ms(1); continue; } //? Atomic lock used for blocking non thread-safe actions in main thread atomic_lock lck(active); //? Set effective user if SUID bit is set gain_priv powers{}; auto& conf = current_conf; //! DEBUG stats if (Global::debug) { if (debug_bg.empty() or redraw) Runner::debug_bg = Draw::createBox(2, 2, 33, #ifdef GPU_SUPPORT 9, #else 8, #endif "", true, "ฮผs"); debug_times.clear(); debug_times["total"] = {0, 0}; } output.clear(); //* Run collection and draw functions for all boxes try { #if defined(GPU_SUPPORT) //? GPU data collection const bool gpu_in_cpu_panel = Gpu::gpu_names.size() > 0 and ( Config::getS("cpu_graph_lower").starts_with("gpu-") or (Config::getS("cpu_graph_lower") == "Auto") or Config::getS("cpu_graph_upper").starts_with("gpu-") or (Gpu::shown == 0 and Config::getS("show_gpu_info") != "Off") ); vector gpu_panels = {}; for (auto& box : conf.boxes) if (box.starts_with("gpu")) gpu_panels.push_back(box.back()-'0'); vector gpus; if (gpu_in_cpu_panel or not gpu_panels.empty()) { if (Global::debug) debug_timer("gpu", collect_begin); gpus = Gpu::collect(conf.no_update); if (Global::debug) debug_timer("gpu", collect_done); } auto& gpus_ref = gpus; #endif // GPU_SUPPORT //? CPU if (v_contains(conf.boxes, "cpu")) { try { if (Global::debug) debug_timer("cpu", collect_begin); //? Start collect auto cpu = Cpu::collect(conf.no_update); if (coreNum_reset) { coreNum_reset = false; Cpu::core_mapping = Cpu::get_core_mapping(); Global::resized = true; Input::interrupt(); continue; } if (Global::debug) debug_timer("cpu", draw_begin); //? Draw box if (not pause_output) { output += Cpu::draw( cpu, #if defined(GPU_SUPPORT) gpus_ref, #endif // GPU_SUPPORT conf.force_redraw, conf.no_update ); } if (Global::debug) debug_timer("cpu", draw_done); } catch (const std::exception& e) { throw std::runtime_error("Cpu:: -> " + string{e.what()}); } } #ifdef GPU_SUPPORT //? GPU if (not gpu_panels.empty() and not gpus_ref.empty()) { try { if (Global::debug) debug_timer("gpu", draw_begin_only); //? Draw box if (not pause_output) for (unsigned long i = 0; i < gpu_panels.size(); ++i) output += Gpu::draw(gpus_ref[gpu_panels[i]], i, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("gpu", draw_done); } catch (const std::exception& e) { throw std::runtime_error("Gpu:: -> " + string{e.what()}); } } #endif //? MEM if (v_contains(conf.boxes, "mem")) { try { if (Global::debug) debug_timer("mem", collect_begin); //? Start collect auto mem = Mem::collect(conf.no_update); if (Global::debug) debug_timer("mem", draw_begin); //? Draw box if (not pause_output) output += Mem::draw(mem, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("mem", draw_done); } catch (const std::exception& e) { throw std::runtime_error("Mem:: -> " + string{e.what()}); } } //? NET if (v_contains(conf.boxes, "net")) { try { if (Global::debug) debug_timer("net", collect_begin); //? Start collect auto net = Net::collect(conf.no_update); if (Global::debug) debug_timer("net", draw_begin); //? Draw box if (not pause_output) output += Net::draw(net, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("net", draw_done); } catch (const std::exception& e) { throw std::runtime_error("Net:: -> " + string{e.what()}); } } //? PROC if (v_contains(conf.boxes, "proc")) { try { if (Global::debug) debug_timer("proc", collect_begin); //? Start collect auto proc = Proc::collect(conf.no_update); if (Global::debug) debug_timer("proc", draw_begin); //? Draw box if (not pause_output) output += Proc::draw(proc, conf.force_redraw, conf.no_update); if (Global::debug) debug_timer("proc", draw_done); } catch (const std::exception& e) { throw std::runtime_error("Proc:: -> " + string{e.what()}); } } } catch (const std::exception& e) { Global::exit_error_msg = fmt::format("Exception in runner thread -> {}", e.what()); Global::thread_exception = true; Input::interrupt(); stopping = true; } if (stopping) { continue; } if (redraw or conf.force_redraw) { empty_bg.clear(); redraw = false; } if (not pause_output) output += conf.clock; if (not conf.overlay.empty() and not conf.background_update) pause_output = true; if (output.empty() and not pause_output) { if (empty_bg.empty()) { const int x = Term::width / 2 - 10, y = Term::height / 2 - 10; output += Term::clear; empty_bg = fmt::format( "{banner}" "{mv1}{titleFg}{b}No boxes shown!" "{mv2}{hiFg}1 {mainFg}| Show CPU box" "{mv3}{hiFg}2 {mainFg}| Show MEM box" "{mv4}{hiFg}3 {mainFg}| Show NET box" "{mv5}{hiFg}4 {mainFg}| Show PROC box" "{mv6}{hiFg}5-0 {mainFg}| Show GPU boxes" "{mv7}{hiFg}esc {mainFg}| Show menu" "{mv8}{hiFg}q {mainFg}| Quit", "banner"_a = Draw::banner_gen(y, 0, true), "titleFg"_a = Theme::c("title"), "b"_a = Fx::b, "hiFg"_a = Theme::c("hi_fg"), "mainFg"_a = Theme::c("main_fg"), "mv1"_a = Mv::to(y+6, x), "mv2"_a = Mv::to(y+8, x), "mv3"_a = Mv::to(y+9, x), "mv4"_a = Mv::to(y+10, x), "mv5"_a = Mv::to(y+11, x), "mv6"_a = Mv::to(y+12, x-2), "mv7"_a = Mv::to(y+13, x-2), "mv8"_a = Mv::to(y+14, x) ); } output += empty_bg; } //! DEBUG stats --> if (Global::debug and not Menu::active) { output += fmt::format("{pre}{box:5.5} {collect:>12.12} {draw:>12.12}{post}", "pre"_a = debug_bg + Theme::c("title") + Fx::b, "box"_a = "box", "collect"_a = "collect", "draw"_a = "draw", "post"_a = Theme::c("main_fg") + Fx::ub ); static auto loc = std::locale(std::locale::classic(), new MyNumPunct); #ifdef GPU_SUPPORT for (const string name : {"cpu", "mem", "net", "proc", "gpu", "total"}) { #else for (const string name : {"cpu", "mem", "net", "proc", "total"}) { #endif if (not debug_times.contains(name)) debug_times[name] = {0,0}; const auto& [time_collect, time_draw] = debug_times.at(name); if (name == "total") output += Fx::b; output += fmt::format(loc, "{mvLD}{name:5.5} {collect:12L} {draw:12L}", "mvLD"_a = Mv::l(31) + Mv::d(1), "name"_a = name, "collect"_a = time_collect, "draw"_a = time_draw ); } } //? If overlay isn't empty, print output without color and then print overlay on top const bool term_sync = Config::getB("terminal_sync"); cout << (term_sync ? Term::sync_start : "") << (conf.overlay.empty() ? output : (output.empty() ? "" : Fx::ub + Theme::c("inactive_fg") + Fx::uncolor(output)) + conf.overlay) << (term_sync ? Term::sync_end : "") << flush; } //* ----------------------------------------------- THREAD LOOP ----------------------------------------------- return {}; } //? ------------------------------------------ Secondary thread end ----------------------------------------------- //* Runs collect and draw in a secondary thread, unlocks and locks config to update cached values void run(const string& box, bool no_update, bool force_redraw) { atomic_wait_for(active, true, 5000); if (active) { Logger::error("Stall in Runner thread, restarting!"); set_active(false); // exit(1); pthread_cancel(Runner::runner_id); // Wait for the thread to actually terminate before creating a new one void* thread_result; int join_result = pthread_join(Runner::runner_id, &thread_result); if (join_result != 0) { Logger::warning("Failed to join cancelled thread: {}", strerror(join_result)); } if (pthread_create(&Runner::runner_id, nullptr, &Runner::_runner, nullptr) != 0) { Global::exit_error_msg = "Failed to re-create _runner thread!"; clean_quit(1); } } if (stopping or Global::resized) return; if (box == "overlay") { const bool term_sync = Config::getB("terminal_sync"); cout << (term_sync ? Term::sync_start : "") << Global::overlay << (term_sync ? Term::sync_end : "") << flush; } else if (box == "clock") { const bool term_sync = Config::getB("terminal_sync"); cout << (term_sync ? Term::sync_start : "") << Global::clock << (term_sync ? Term::sync_end : "") << flush; } else { Config::unlock(); Config::lock(); current_conf = { (box == "all" ? Config::current_boxes : vector{box}), no_update, force_redraw, (not Config::getB("tty_mode") and Config::getB("background_update")), Global::overlay, Global::clock }; if (Menu::active and not current_conf.background_update) Global::overlay.clear(); thread_trigger(); atomic_wait_for(active, false, 10); } } //* Stops any work being done in runner thread and checks for thread errors void stop() { stopping = true; auto lock = std::unique_lock {mtx, std::defer_lock}; const auto is_runner_busy = !lock.try_lock(); if (!is_runner_busy and not Global::quitting) { if (active) { set_active(false); } Global::exit_error_msg = "Runner thread died unexpectedly!"; clean_quit(1); } else if (is_runner_busy) { atomic_wait_for(active, true, 5000); if (active) { set_active(false); if (Global::quitting) { return; } else { Global::exit_error_msg = "No response from Runner thread, quitting!"; clean_quit(1); } } thread_trigger(); atomic_wait_for(active, false, 100); atomic_wait_for(active, true, 100); } stopping = false; } } static auto configure_tty_mode(std::optional force_tty) { if (force_tty.has_value()) { Config::set("tty_mode", force_tty.value()); Logger::debug("TTY mode set via command line"); } else if (Config::getB("force_tty")) { Config::set("tty_mode", true); Logger::debug("TTY mode set via config"); } #if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__NetBSD__) else if (Term::current_tty.starts_with("/dev/tty")) { Config::set("tty_mode", true); Logger::debug("Auto detect real TTY"); } #endif Logger::debug("TTY mode enabled: {}", Config::getB("tty_mode")); } //* --------------------------------------------- Main starts here! --------------------------------------------------- [[nodiscard]] auto btop_main(const std::span args) -> int { //? ------------------------------------------------ INIT --------------------------------------------------------- Global::start_time = time_s(); //? Save real and effective userid's and drop privileges until needed if running with SUID bit set Global::real_uid = getuid(); Global::set_uid = geteuid(); if (Global::real_uid != Global::set_uid) { if (seteuid(Global::real_uid) != 0) { Global::real_uid = Global::set_uid; Global::exit_error_msg = "Failed to change effective user ID. Unset btop SUID bit to ensure security on this system. Quitting!"; clean_quit(1); } } Cli::Cli cli; { // Get the cli options or return with an exit code auto result = Cli::parse(args); if (result.has_value()) { cli = result.value(); } else { auto error = result.error(); if (error != 0) { Cli::usage(); Cli::help_hint(); } return error; } } Global::debug = cli.debug; { const auto config_dir = Config::get_config_dir(); if (config_dir.has_value()) { Config::conf_dir = config_dir.value(); if (cli.config_file.has_value()) { Config::conf_file = cli.config_file.value(); } else { Config::conf_file = Config::conf_dir / "btop.conf"; } auto log_file = Config::get_log_file(); if (log_file.has_value()) { Logger::init(log_file.value()); } Theme::user_theme_dir = Config::conf_dir / "themes"; // If necessary create the user theme directory std::error_code error; if (not fs::exists(Theme::user_theme_dir, error) and not fs::create_directories(Theme::user_theme_dir, error)) { Theme::user_theme_dir.clear(); Logger::warning("Failed to create user theme directory: {}", error.message()); } } } //? Try to find global btop theme path relative to binary path #ifdef __linux__ { std::error_code ec; Global::self_path = fs::read_symlink("/proc/self/exe", ec).remove_filename(); } #elif __APPLE__ { char buf [PATH_MAX]; uint32_t bufsize = PATH_MAX; if(!_NSGetExecutablePath(buf, &bufsize)) Global::self_path = fs::path(buf).remove_filename(); } #elif __NetBSD__ { int mib[4]; char buf[PATH_MAX]; size_t bufsize = sizeof buf; mib[0] = CTL_KERN; mib[1] = KERN_PROC_ARGS; mib[2] = getpid(); mib[3] = KERN_PROC_PATHNAME; if (sysctl(mib, 4, buf, &bufsize, NULL, 0) == 0) Global::self_path = fs::path(buf).remove_filename(); } #endif if (std::error_code ec; not Global::self_path.empty()) { Theme::theme_dir = fs::canonical(Global::self_path / "../share/btop/themes", ec); if (ec or not fs::is_directory(Theme::theme_dir) or access(Theme::theme_dir.c_str(), R_OK) == -1) Theme::theme_dir.clear(); } //? If relative path failed, check two most common absolute paths if (Theme::theme_dir.empty()) { for (auto theme_path : {"/usr/local/share/btop/themes", "/usr/share/btop/themes"}) { if (fs::is_directory(fs::path(theme_path)) and access(theme_path, R_OK) != -1) { Theme::theme_dir = fs::path(theme_path); break; } } } //? Set custom themes directory from command line if provided if (cli.themes_dir.has_value()) { Theme::custom_theme_dir = cli.themes_dir.value(); Logger::info("Using custom themes directory: {}", Theme::custom_theme_dir.string()); } //? Config init init_config(cli.low_color, cli.filter); //? Try to find and set a UTF-8 locale if (std::setlocale(LC_ALL, "") != nullptr and not std::string_view { std::setlocale(LC_ALL, "") }.contains(";") and str_to_upper(s_replace((string)std::setlocale(LC_ALL, ""), "-", "")).ends_with("UTF8")) { Logger::debug("Using locale {}", std::locale().name()); } else { string found; bool set_failure{}; for (const auto loc_env : array{"LANG", "LC_ALL", "LC_CTYPE"}) { if (std::getenv(loc_env) != nullptr and str_to_upper(s_replace((string)std::getenv(loc_env), "-", "")).ends_with("UTF8")) { found = std::getenv(loc_env); if (std::setlocale(LC_ALL, found.c_str()) == nullptr) { set_failure = true; Logger::warning("Failed to set locale {} continuing anyway.", found); } } } if (found.empty()) { if (setenv("LC_ALL", "", 1) == 0 and setenv("LANG", "", 1) == 0) { try { if (const auto loc = std::locale("").name(); not loc.empty() and loc != "*") { for (auto& l : ssplit(loc, ';')) { if (str_to_upper(s_replace(l, "-", "")).ends_with("UTF8")) { found = l.substr(l.find('=') + 1); if (std::setlocale(LC_ALL, found.c_str()) != nullptr) { break; } } } } } catch (...) { found.clear(); } } } // #ifdef __APPLE__ if (found.empty()) { CFLocaleRef cflocale = CFLocaleCopyCurrent(); CFStringRef id_value = (CFStringRef)CFLocaleGetValue(cflocale, kCFLocaleIdentifier); auto loc_id = CFStringGetCStringPtr(id_value, kCFStringEncodingUTF8); CFRelease(cflocale); std::string cur_locale = (loc_id != nullptr ? loc_id : ""); if (cur_locale.empty()) { Logger::warning("No UTF-8 locale detected! Some symbols might not display correctly."); } else if (std::setlocale(LC_ALL, string(cur_locale + ".UTF-8").c_str()) != nullptr) { Logger::debug("Setting LC_ALL={}.UTF-8", cur_locale); } else if(std::setlocale(LC_ALL, "en_US.UTF-8") != nullptr) { Logger::debug("Setting LC_ALL=en_US.UTF-8"); } else { Logger::warning("Failed to set macos locale, continuing anyway."); } } #else if (found.empty() and cli.force_utf) { Logger::warning("No UTF-8 locale detected! Forcing start with --force-utf argument."); } else if (found.empty()) { Global::exit_error_msg = "No UTF-8 locale detected!\nUse --force-utf argument to force start if you're sure your terminal can handle it."; clean_quit(1); } #endif else if (not set_failure) { Logger::debug("Setting LC_ALL={}", found); } } //? Initialize terminal and set options if (not Term::init()) { Global::exit_error_msg = "No tty detected!\nbtop++ needs an interactive shell to run."; clean_quit(1); } if (Term::current_tty != "unknown") { Logger::info("Running on {}", Term::current_tty); } configure_tty_mode(cli.force_tty); //? Check for valid terminal dimensions { int t_count = 0; while (Term::width <= 0 or Term::width > 10000 or Term::height <= 0 or Term::height > 10000) { sleep_ms(10); Term::refresh(); if (++t_count == 100) { Global::exit_error_msg = "Failed to get size of terminal!"; clean_quit(1); } } } //? Platform dependent init and error check try { Shared::init(); } catch (const std::exception& e) { Global::exit_error_msg = fmt::format("Exception in Shared::init() -> {}", e.what()); clean_quit(1); } if (not Config::set_boxes(Config::getS("shown_boxes"))) { Config::set_boxes("cpu mem net proc"); Config::set("shown_boxes", "cpu mem net proc"s); } //? Update list of available themes and generate the selected theme Theme::updateThemes(); Theme::setTheme(); //? Setup signal handlers for CTRL-C, CTRL-Z, resume and terminal resize std::atexit(_exit_handler); std::signal(SIGINT, _signal_handler); std::signal(SIGTSTP, _signal_handler); std::signal(SIGCONT, _signal_handler); std::signal(SIGWINCH, _signal_handler); std::signal(SIGUSR1, _signal_handler); std::signal(SIGUSR2, _signal_handler); // Add crash handlers to restore terminal on crash std::signal(SIGSEGV, _crash_handler); std::signal(SIGABRT, _crash_handler); std::signal(SIGTRAP, _crash_handler); std::signal(SIGBUS, _crash_handler); std::signal(SIGILL, _crash_handler); sigset_t mask; sigemptyset(&mask); sigaddset(&mask, SIGUSR1); pthread_sigmask(SIG_BLOCK, &mask, &Input::signal_mask); if (pthread_create(&Runner::runner_id, nullptr, &Runner::_runner, nullptr) != 0) { Global::exit_error_msg = "Failed to create _runner thread!"; clean_quit(1); } else { Global::_runner_started = true; } //? Calculate sizes of all boxes Config::presetsValid(Config::getS("presets")); if (cli.preset.has_value()) { Config::current_preset = min(static_cast(cli.preset.value()), static_cast(Config::preset_list.size() - 1)); Config::apply_preset(Config::preset_list.at(Config::current_preset.value())); } { const auto [x, y] = Term::get_min_size(Config::getS("shown_boxes")); if (Term::height < y or Term::width < x) { pthread_sigmask(SIG_SETMASK, &Input::signal_mask, &mask); term_resize(true); pthread_sigmask(SIG_SETMASK, &mask, nullptr); Global::resized = false; } } Draw::calcSizes(); //? Print out box outlines const bool term_sync = Config::getB("terminal_sync"); cout << (term_sync ? Term::sync_start : "") << Cpu::box << Mem::box << Net::box << Proc::box << (term_sync ? Term::sync_end : "") << flush; //? ------------------------------------------------ MAIN LOOP ---------------------------------------------------- if (cli.updates.has_value()) { Config::set("update_ms", static_cast(cli.updates.value())); } uint64_t update_ms = Config::getI("update_ms"); auto future_time = time_ms(); try { while (not true not_eq not false) { //? Check for exceptions in secondary thread and exit with fail signal if true if (Global::thread_exception) { clean_quit(1); } else if (Global::should_quit) { clean_quit(0); } else if (Global::should_sleep) { Global::should_sleep = false; _sleep(); } //? Hot reload config from CTRL + R or SIGUSR2 else if (Global::reload_conf) { Global::reload_conf = false; if (Runner::active) Runner::stop(); Config::unlock(); init_config(cli.low_color, cli.filter); Theme::updateThemes(); Theme::setTheme(); Draw::banner_gen(0, 0, false, true); Global::resized = true; } //? Make sure terminal size hasn't changed (in case of SIGWINCH not working properly) term_resize(Global::resized); //? Trigger secondary thread to redraw if terminal has been resized if (Global::resized) { Draw::calcSizes(); Draw::update_clock(true); Global::resized = false; if (Menu::active) Menu::process(); else Runner::run("all", true, true); atomic_wait_for(Runner::active, true, 1000); } //? Update clock if needed if (Draw::update_clock() and not Menu::active) { Runner::run("clock"); } //? Start secondary collect & draw thread at the interval set by config value if (time_ms() >= future_time and not Global::resized) { Runner::run("all"); update_ms = Config::getI("update_ms"); future_time = time_ms() + update_ms; } //? Loop over input polling and input action processing for (auto current_time = time_ms(); current_time < future_time; current_time = time_ms()) { //? Check for external clock changes and for changes to the update timer if (std::cmp_not_equal(update_ms, Config::getI("update_ms"))) { update_ms = Config::getI("update_ms"); future_time = time_ms() + update_ms; } else if (future_time - current_time > update_ms) { future_time = current_time; } //? Poll for input and process any input detected else if (Input::poll(min((uint64_t)1000, future_time - current_time))) { if (not Runner::active) Config::unlock(); if (Menu::active) Menu::process(Input::get()); else Input::process(Input::get()); } //? Break the loop at 1000ms intervals or if input polling was interrupted else break; } } } catch (const std::exception& e) { Global::exit_error_msg = fmt::format("Exception in main loop -> {}", e.what()); clean_quit(1); } return 0; } aristocratos-btop-d43a485/src/btop.hpp000066400000000000000000000001651517514752700200130ustar00rootroot00000000000000#include #include [[nodiscard]] auto btop_main(std::span args) -> int; aristocratos-btop-d43a485/src/btop_cli.cpp000066400000000000000000000175461517514752700206500ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #include "btop_cli.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "btop_config.hpp" #include "btop_shared.hpp" #include "config.h" using namespace std::string_view_literals; static constexpr auto BOLD = "\033[1m"sv; static constexpr auto BOLD_UNDERLINE = "\033[1;4m"sv; static constexpr auto BOLD_RED = "\033[1;31m"sv; static constexpr auto BOLD_GREEN = "\033[1;32m"sv; static constexpr auto BOLD_YELLOW = "\033[1;33m"sv; static constexpr auto BOLD_BRIGHT_BLACK = "\033[1;90m"sv; static constexpr auto YELLOW = "\033[33m"sv; static constexpr auto RESET = "\033[0m"sv; static void version() noexcept { if constexpr (GIT_COMMIT.empty()) { fmt::println("btop version: {}{}{}", BOLD, Global::Version, RESET); } else { fmt::println("btop version: {}{}+{}{}", BOLD, Global::Version, GIT_COMMIT, RESET); } } static void build_info() noexcept { fmt::println("Compiled with: {} ({})", COMPILER, COMPILER_VERSION); fmt::println("Configured with: {}", CONFIGURE_COMMAND); } static void error(std::string_view msg) noexcept { fmt::println("{}error:{} {}\n", BOLD_RED, RESET, msg); } namespace Cli { [[nodiscard]] auto parse(const std::span args) noexcept -> Result { Cli cli {}; for (auto it = args.begin(); it != args.end(); ++it) { auto arg = *it; if (arg == "--default-config") { return default_config(); } if (arg == "-h" || arg == "--help") { usage(); help(); return std::unexpected { 0 }; } if (arg == "-v" || arg == "-V") { version(); return std::unexpected { 0 }; } if (arg == "--version") { version(); build_info(); return std::unexpected { 0 }; } if (arg == "-d" || arg == "--debug") { cli.debug = true; continue; } if (arg == "--force-utf") { cli.force_utf = true; continue; } if (arg == "-l" || arg == "--low-color") { cli.low_color = true; continue; } if (arg == "-t" || arg == "--tty") { if (cli.force_tty.has_value()) { error("tty mode can't be set twice"); return std::unexpected { 1 }; } cli.force_tty = std::make_optional(true); continue; } if (arg == "--no-tty") { if (cli.force_tty.has_value()) { error("tty mode can't be set twice"); return std::unexpected { 1 }; } cli.force_tty = std::make_optional(false); continue; } if (arg == "-c" || arg == "--config") { // This flag requires an argument. if (++it == args.end()) { error("Config requires an argument"); return std::unexpected { 1 }; } auto arg = *it; auto config_file = stdfs::path { arg }; if (stdfs::is_directory(config_file)) { error("Config file can't be a directory"); return std::unexpected { 1 }; } cli.config_file = std::make_optional(config_file); continue; } if (arg == "-f" || arg == "--filter") { // This flag requires an argument. if (++it == args.end()) { error("Filter requires an argument"); return std::unexpected { 1 }; } auto arg = *it; cli.filter = std::make_optional(arg); continue; } if (arg == "-p" || arg == "--preset") { // This flag requires an argument. if (++it == args.end()) { error("Preset requires an argument"); return std::unexpected { 1 }; } auto arg = *it; try { auto preset_id = std::clamp(std::stoi(arg.data()), 0, 9); cli.preset = std::make_optional(preset_id); } catch (std::invalid_argument& e) { error("Preset must be a positive number"); return std::unexpected { 1 }; } catch (std::out_of_range& e) { error(fmt::format("Preset argument is out of range: {}", arg.data())); return std::unexpected { 1 }; } continue; } if (arg == "--themes-dir") { // This flag requires an argument. if (++it == args.end()) { error("Themes directory requires an argument"); return std::unexpected { 1 }; } auto arg = *it; auto themes_dir = stdfs::path { arg }; if (not stdfs::is_directory(themes_dir)) { error("Themes directory does not exist or is not a directory"); return std::unexpected { 1 }; } cli.themes_dir = std::make_optional(themes_dir); continue; } if (arg == "-u" || arg == "--update") { // This flag requires an argument. if (++it == args.end()) { error("Update requires an argument"); return std::unexpected { 1 }; } auto arg = *it; try { auto refresh_rate = std::max(std::stoi(arg.data()), 100); cli.updates = refresh_rate; } catch (std::invalid_argument& e) { error("Update must be a positive number"); return std::unexpected { 1 }; } catch (std::out_of_range& e) { error(fmt::format("Update argument is out of range: {}", arg.data())); return std::unexpected { 1 }; } continue; } error(fmt::format("Unknown argument '{}{}{}'", YELLOW, arg, RESET)); return std::unexpected { 1 }; } return cli; } auto default_config() noexcept -> Result { // The idea of using `current_config` is that the CLI parser is run before loading the actual config and thus // provides default values. auto config = Config::current_config(); if (isatty(STDOUT_FILENO)) { std::string buffer {}; // The config buffer ends in `\n`. `std::views::split` will then create an empty element after the last // newline, which we would write as an additional empty line at the very end. auto trimmed_config = config.substr(0, config.length() - 1); for (const auto line : std::views::split(trimmed_config, '\n')) { auto line_view = std::string_view { line }; if (line_view.starts_with("#")) { fmt::format_to( std::back_inserter(buffer), "{1}{0}{2}\n", line_view, BOLD_BRIGHT_BLACK, RESET ); } else if (!line_view.empty()) { auto pos = line_view.find("="); if (pos == line_view.npos) { error("invalid default config: '=' not found"); return std::unexpected { 1 }; } auto name = line_view.substr(0, pos); auto value = line_view.substr(pos + 1); fmt::format_to( std::back_inserter(buffer), "{2}{0}{4}={3}{1}{4}\n", name, value, BOLD_YELLOW, BOLD_GREEN, RESET ); } else { fmt::format_to(std::back_inserter(buffer), "\n"); } } fmt::print("{}", buffer); } else { fmt::print("{}", config); } return std::unexpected { 0 }; } void usage() noexcept { fmt::println("{0}Usage:{1} {2}btop{1} [OPTIONS]\n", BOLD_UNDERLINE, RESET, BOLD); } void help() noexcept { fmt::print( "{0}Options:{1}\n" " {2}-c, --config{1} Path to a config file\n" " {2}-d, --debug{1} Start in debug mode with additional logs and metrics\n" " {2}-f, --filter{1} Set an initial process filter\n" " {2} --force-utf{1} Override automatic UTF locale detection\n" " {2}-l, --low-color{1} Disable true color, 256 colors only\n" " {2}-p, --preset{1} Start with a preset (0-9)\n" " {2}-t, --tty{1} Force tty mode with ANSI graph symbols and 16 colors only\n" " {2} --themes-dir{1}

Path to a custom themes directory\n" " {2} --no-tty{1} Force disable tty mode\n" " {2}-u, --update{1} Set an initial update rate in milliseconds\n" " {2} --default-config{1} Print default config to standard output\n" " {2}-h, --help{1} Show this help message and exit\n" " {2}-V, --version{1} Show a version message and exit (more with --version)\n", BOLD_UNDERLINE, RESET, BOLD ); } void help_hint() noexcept { fmt::println("For more information, try '{}--help{}'", BOLD, RESET); } } // namespace Cli aristocratos-btop-d43a485/src/btop_cli.hpp000066400000000000000000000026551517514752700206500ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include namespace Cli { namespace stdfs = std::filesystem; // Configuration options set via the command line. struct Cli { // Alternate path to a configuration file std::optional config_file; // Enable debug mode with additional logs and metrics bool debug {}; // Set an initial process filter. std::optional filter; // Only use ANSI supported graph symbols and colors std::optional force_tty; // Use UTF-8 locale even if not detected bool force_utf {}; // Disable true color and only use 256 color mode bool low_color {}; // Start with one of the provided presets std::optional preset; // Path to a custom themes directory std::optional themes_dir; // The initial refresh rate std::optional updates; }; using Result = std::expected; // Parse the command line arguments [[nodiscard]] auto parse(std::span args) noexcept -> Result; // Print default config to standard output [[nodiscard]] auto default_config() noexcept -> Result; // Print a usage header void usage() noexcept; // Print a help message void help() noexcept; // Print a hint on how to show more help void help_hint() noexcept; } // namespace Cli aristocratos-btop-d43a485/src/btop_config.cpp000066400000000000000000000756071517514752700213500ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "btop_config.hpp" #include "btop_log.hpp" #include "btop_shared.hpp" #include "btop_tools.hpp" using std::array; using std::atomic; using std::string_view; namespace fs = std::filesystem; namespace rng = std::ranges; using namespace std::literals; using namespace Tools; //* Functions and variables for reading and writing the btop config file namespace Config { atomic locked (false); atomic writelock (false); bool write_new; const vector> descriptions = { {"color_theme", "#* Name of a btop++/bpytop/bashtop formatted \".theme\" file, \"Default\" and \"TTY\" for builtin themes.\n" "#* Themes should be placed in \"../share/btop/themes\" relative to binary or \"$HOME/.config/btop/themes\""}, {"theme_background", "#* If the theme set background should be shown, set to False if you want terminal background transparency."}, {"truecolor", "#* Sets if 24-bit truecolor should be used, will convert 24-bit colors to 256 color (6x6x6 color cube) if false."}, {"force_tty", "#* Set to true to force tty mode regardless if a real tty has been detected or not.\n" "#* Will force 16-color mode and TTY theme, set all graph symbols to \"tty\" and swap out other non tty friendly symbols."}, {"disable_presets", "#* Option to disable presets. Either the default preset, custom presets, or all presets.\n" "#* \"Off\" All presets are enabled.\n" "#* \"Default\" preset is disabled." "#* \"Custom\" presets are disabled." "#* \"All\" presets are disabled."}, {"presets", "#* Define presets for the layout of the boxes. Preset 0 is always all boxes shown with default settings. Max 9 presets.\n" "#* Format: \"box_name:P:G,box_name:P:G\" P=(0 or 1) for alternate positions, G=graph symbol to use for box.\n" "#* Use whitespace \" \" as separator between different presets.\n" "#* Example: \"cpu:0:default,mem:0:tty,proc:1:default cpu:0:braille,proc:0:tty\""}, {"vim_keys", "#* Set to True to enable \"h,j,k,l,g,G\" keys for directional control in lists.\n" "#* Conflicting keys for h:\"help\" and k:\"kill\" is accessible while holding shift."}, {"disable_mouse", "#* Disable all mouse events."}, {"rounded_corners", "#* Rounded corners on boxes, is ignored if TTY mode is ON."}, {"terminal_sync", "#* Use terminal synchronized output sequences to reduce flickering on supported terminals."}, {"graph_symbol", "#* Default symbols to use for graph creation, \"braille\", \"block\" or \"tty\".\n" "#* \"braille\" offers the highest resolution but might not be included in all fonts.\n" "#* \"block\" has half the resolution of braille but uses more common characters.\n" "#* \"tty\" uses only 3 different symbols but will work with most fonts and should work in a real TTY.\n" "#* Note that \"tty\" only has half the horizontal resolution of the other two, so will show a shorter historical view."}, {"graph_symbol_cpu", "# Graph symbol to use for graphs in cpu box, \"default\", \"braille\", \"block\" or \"tty\"."}, #ifdef GPU_SUPPORT {"graph_symbol_gpu", "# Graph symbol to use for graphs in gpu box, \"default\", \"braille\", \"block\" or \"tty\"."}, #endif {"graph_symbol_mem", "# Graph symbol to use for graphs in cpu box, \"default\", \"braille\", \"block\" or \"tty\"."}, {"graph_symbol_net", "# Graph symbol to use for graphs in cpu box, \"default\", \"braille\", \"block\" or \"tty\"."}, {"graph_symbol_proc", "# Graph symbol to use for graphs in cpu box, \"default\", \"braille\", \"block\" or \"tty\"."}, {"shown_boxes", "#* Manually set which boxes to show. Available values are \"cpu mem net proc\" and \"gpu0\" through \"gpu5\", separate values with whitespace."}, {"update_ms", "#* Update time in milliseconds, recommended 2000 ms or above for better sample times for graphs."}, {"proc_sorting", "#* Processes sorting, \"pid\" \"program\" \"arguments\" \"threads\" \"user\" \"memory\" \"cpu lazy\" \"cpu direct\",\n" "#* \"cpu lazy\" sorts top process over time (easier to follow), \"cpu direct\" updates top process directly."}, {"proc_reversed", "#* Reverse sorting order, True or False."}, {"proc_tree", "#* Show processes as a tree."}, {"proc_colors", "#* Use the cpu graph colors in the process list."}, {"proc_gradient", "#* Use a darkening gradient in the process list."}, {"proc_per_core", "#* If process cpu usage should be of the core it's running on or usage of the total available cpu power."}, {"proc_mem_bytes", "#* Show process memory as bytes instead of percent."}, {"proc_cpu_graphs", "#* Show cpu graph for each process."}, {"proc_info_smaps", "#* Use /proc/[pid]/smaps for memory information in the process info box (very slow but more accurate)"}, {"proc_left", "#* Show proc box on left side of screen instead of right."}, {"proc_filter_kernel", "#* (Linux) Filter processes tied to the Linux kernel(similar behavior to htop)."}, {"proc_follow_detailed", "#* Should the process list follow the selected process when detailed view is open."}, {"proc_aggregate", "#* In tree-view, always accumulate child process resources in the parent process."}, {"keep_dead_proc_usage", "#* Should cpu and memory usage display be preserved for dead processes when paused."}, {"cpu_graph_upper", "#* Sets the CPU stat shown in upper half of the CPU graph, \"total\" is always available.\n" "#* Select from a list of detected attributes from the options menu."}, {"cpu_graph_lower", "#* Sets the CPU stat shown in lower half of the CPU graph, \"total\" is always available.\n" "#* Select from a list of detected attributes from the options menu."}, #ifdef GPU_SUPPORT {"show_gpu_info", "#* If gpu info should be shown in the cpu box. Available values = \"Auto\", \"On\" and \"Off\"."}, #endif {"cpu_invert_lower", "#* Toggles if the lower CPU graph should be inverted."}, {"cpu_single_graph", "#* Set to True to completely disable the lower CPU graph."}, {"cpu_bottom", "#* Show cpu box at bottom of screen instead of top."}, {"show_uptime", "#* Shows the system uptime in the CPU box."}, {"show_cpu_watts", "#* Shows the CPU package current power consumption in watts. Requires running `make setcap` or `make setuid` or running with sudo."}, {"check_temp", "#* Show cpu temperature."}, {"cpu_sensor", "#* Which sensor to use for cpu temperature, use options menu to select from list of available sensors."}, {"show_coretemp", "#* Show temperatures for cpu cores also if check_temp is True and sensors has been found."}, {"cpu_core_map", "#* Set a custom mapping between core and coretemp, can be needed on certain cpus to get correct temperature for correct core.\n" "#* Use lm-sensors or similar to see which cores are reporting temperatures on your machine.\n" "#* Format \"x:y\" x=core with wrong temp, y=core with correct temp, use space as separator between multiple entries.\n" "#* Example: \"4:0 5:1 6:3\""}, {"temp_scale", "#* Which temperature scale to use, available values: \"celsius\", \"fahrenheit\", \"kelvin\" and \"rankine\"."}, {"base_10_sizes", "#* Use base 10 for bits/bytes sizes, KB = 1000 instead of KiB = 1024."}, {"show_cpu_freq", "#* Show CPU frequency."}, #ifdef __linux__ {"freq_mode", "#* How to calculate CPU frequency, available values: \"first\", \"range\", \"lowest\", \"highest\" and \"average\"."}, #endif {"clock_format", "#* Draw a clock at top of screen, formatting according to strftime, empty string to disable.\n" "#* Special formatting: /host = hostname | /user = username | /uptime = system uptime"}, {"background_update", "#* Update main ui in background when menus are showing, set this to false if the menus is flickering too much for comfort."}, {"custom_cpu_name", "#* Custom cpu model name, empty string to disable."}, {"disks_filter", "#* Optional filter for shown disks, should be full path of a mountpoint, separate multiple values with whitespace \" \".\n" "#* Only disks matching the filter will be shown. Prepend exclude= to only show disks not matching the filter. Examples: disk_filter=\"/boot /home/user\", disks_filter=\"exclude=/boot /home/user\""}, {"mem_graphs", "#* Show graphs instead of meters for memory values."}, {"mem_below_net", "#* Show mem box below net box instead of above."}, {"zfs_arc_cached", "#* Count ZFS ARC in cached and available memory."}, {"show_swap", "#* If swap memory should be shown in memory box."}, {"swap_disk", "#* Show swap as a disk, ignores show_swap value above, inserts itself after first disk."}, {"show_disks", "#* If mem box should be split to also show disks info."}, {"only_physical", "#* Filter out non physical disks. Set this to False to include network disks, RAM disks and similar."}, {"use_fstab", "#* Read disks list from /etc/fstab. This also disables only_physical."}, {"zfs_hide_datasets", "#* Setting this to True will hide all datasets, and only show ZFS pools. (IO stats will be calculated per-pool)"}, {"disk_free_priv", "#* Set to true to show available disk space for privileged users."}, {"show_io_stat", "#* Toggles if io activity % (disk busy time) should be shown in regular disk usage view."}, {"io_mode", "#* Toggles io mode for disks, showing big graphs for disk read/write speeds."}, {"io_graph_combined", "#* Set to True to show combined read/write io graphs in io mode."}, {"io_graph_speeds", "#* Set the top speed for the io graphs in MiB/s (100 by default), use format \"mountpoint:speed\" separate disks with whitespace \" \".\n" "#* Example: \"/mnt/media:100 /:20 /boot:1\"."}, {"swap_upload_download", "#* Swap the positions of the upload and download speed graphs. When true, upload will be on top."}, {"net_download", "#* Set fixed values for network graphs in Mebibits. Is only used if net_auto is also set to False."}, {"net_upload", ""}, {"net_auto", "#* Use network graphs auto rescaling mode, ignores any values set above and rescales down to 10 Kibibytes at the lowest."}, {"net_sync", "#* Sync the auto scaling for download and upload to whichever currently has the highest scale."}, {"net_iface", "#* Starts with the Network Interface specified here."}, {"base_10_bitrate", "#* \"True\" shows bitrates in base 10 (Kbps, Mbps). \"False\" shows bitrates in binary sizes (Kibps, Mibps, etc.). \"Auto\" uses base_10_sizes."}, {"show_battery", "#* Show battery stats in top right if battery is present."}, {"selected_battery", "#* Which battery to use if multiple are present. \"Auto\" for auto detection."}, {"show_battery_watts", "#* Show power stats of battery next to charge indicator."}, {"log_level", "#* Set loglevel for \"~/.local/state/btop.log\" levels are: \"ERROR\" \"WARNING\" \"INFO\" \"DEBUG\".\n" "#* The level set includes all lower levels, i.e. \"DEBUG\" will show all logging info."}, {"save_config_on_exit", "#* Automatically save current settings to config file on exit."}, #ifdef GPU_SUPPORT {"nvml_measure_pcie_speeds", "#* Measure PCIe throughput on NVIDIA cards, may impact performance on certain cards."}, {"rsmi_measure_pcie_speeds", "#* Measure PCIe throughput on AMD cards, may impact performance on certain cards."}, {"gpu_mirror_graph", "#* Horizontally mirror the GPU graph."}, {"shown_gpus", "#* Set which GPU vendors to show. Available values are \"nvidia amd intel apple\""}, {"custom_gpu_name0", "#* Custom gpu0 model name, empty string to disable."}, {"custom_gpu_name1", "#* Custom gpu1 model name, empty string to disable."}, {"custom_gpu_name2", "#* Custom gpu2 model name, empty string to disable."}, {"custom_gpu_name3", "#* Custom gpu3 model name, empty string to disable."}, {"custom_gpu_name4", "#* Custom gpu4 model name, empty string to disable."}, {"custom_gpu_name5", "#* Custom gpu5 model name, empty string to disable."}, #endif }; std::unordered_map strings = { {"color_theme", "Default"}, {"shown_boxes", "cpu mem net proc"}, {"graph_symbol", "braille"}, {"disable_presets", "Off"}, {"presets", "cpu:1:default,proc:0:default cpu:0:default,mem:0:default,net:0:default cpu:0:block,net:0:tty"}, {"graph_symbol_cpu", "default"}, {"graph_symbol_gpu", "default"}, {"graph_symbol_mem", "default"}, {"graph_symbol_net", "default"}, {"graph_symbol_proc", "default"}, {"proc_sorting", "cpu lazy"}, {"cpu_graph_upper", "Auto"}, {"cpu_graph_lower", "Auto"}, {"cpu_sensor", "Auto"}, {"selected_battery", "Auto"}, {"cpu_core_map", ""}, {"temp_scale", "celsius"}, #ifdef __linux__ {"freq_mode", "first"}, #endif {"clock_format", "%X"}, {"custom_cpu_name", ""}, {"disks_filter", ""}, {"io_graph_speeds", ""}, {"net_iface", ""}, {"base_10_bitrate", "Auto"}, {"log_level", "WARNING"}, {"proc_filter", ""}, {"proc_command", ""}, {"selected_name", ""}, #ifdef GPU_SUPPORT {"custom_gpu_name0", ""}, {"custom_gpu_name1", ""}, {"custom_gpu_name2", ""}, {"custom_gpu_name3", ""}, {"custom_gpu_name4", ""}, {"custom_gpu_name5", ""}, {"show_gpu_info", "Auto"}, {"shown_gpus", "nvidia amd intel apple"} #endif }; std::unordered_map stringsTmp; std::unordered_map bools = { {"theme_background", true}, {"truecolor", true}, {"rounded_corners", true}, {"proc_reversed", false}, {"proc_tree", false}, {"proc_colors", true}, {"proc_gradient", true}, {"proc_per_core", false}, {"proc_mem_bytes", true}, {"proc_cpu_graphs", true}, {"proc_info_smaps", false}, {"proc_left", false}, {"proc_filter_kernel", false}, {"cpu_invert_lower", true}, {"cpu_single_graph", false}, {"cpu_bottom", false}, {"show_uptime", true}, {"show_cpu_watts", true}, {"check_temp", true}, {"show_coretemp", true}, {"show_cpu_freq", true}, {"background_update", true}, {"mem_graphs", true}, {"mem_below_net", false}, {"zfs_arc_cached", true}, {"show_swap", true}, {"swap_disk", true}, {"show_disks", true}, {"only_physical", true}, {"use_fstab", true}, {"zfs_hide_datasets", false}, {"show_io_stat", true}, {"io_mode", false}, {"swap_upload_download", false}, {"base_10_sizes", false}, {"io_graph_combined", false}, {"net_auto", true}, {"net_sync", true}, {"show_battery", true}, {"show_battery_watts", true}, {"vim_keys", false}, {"tty_mode", false}, {"disk_free_priv", false}, {"force_tty", false}, {"lowcolor", false}, {"show_detailed", false}, {"proc_filtering", false}, {"proc_aggregate", false}, {"pause_proc_list", false}, {"keep_dead_proc_usage", false}, {"proc_banner_shown", false}, {"proc_follow_detailed", true}, {"follow_process", false}, {"update_following", false}, {"should_selection_return_to_followed", false}, #ifdef GPU_SUPPORT {"nvml_measure_pcie_speeds", true}, {"rsmi_measure_pcie_speeds", true}, {"gpu_mirror_graph", true}, #endif {"terminal_sync", true}, {"save_config_on_exit", true}, {"disable_mouse", false}, }; std::unordered_map boolsTmp; std::unordered_map ints = { {"update_ms", 2000}, {"net_download", 100}, {"net_upload", 100}, {"detailed_pid", 0}, {"restore_detailed_pid", 0}, {"selected_pid", 0}, {"followed_pid", 0}, {"selected_depth", 0}, {"proc_start", 0}, {"proc_selected", 0}, {"proc_last_selected", 0}, {"proc_followed", 0}, }; std::unordered_map intsTmp; // Returns a valid config dir or an empty optional // The config dir might be read only, a warning is printed, but a path is returned anyway [[nodiscard]] std::optional get_config_dir() noexcept { fs::path config_dir; { std::error_code error; if (const auto xdg_config_home = std::getenv("XDG_CONFIG_HOME"); xdg_config_home != nullptr) { if (fs::exists(xdg_config_home, error)) { config_dir = fs::path(xdg_config_home) / "btop"; } } else if (const auto home = std::getenv("HOME"); home != nullptr) { error.clear(); if (fs::exists(home, error)) { config_dir = fs::path(home) / ".config" / "btop"; } if (error) { fmt::print(stderr, "\033[0;31mWarning: \033[0m{} could not be accessed: {}\n", config_dir.string(), error.message()); config_dir = ""; } } } // FIXME: This warnings can be noisy if the user deliberately has a non-writable config dir // offer an alternative | disable messages by default | disable messages if config dir is not writable | disable messages with a flag // FIXME: Make happy path not branch if (not config_dir.empty()) { std::error_code error; if (fs::exists(config_dir, error)) { if (fs::is_directory(config_dir, error)) { struct statvfs stats {}; if ((fs::status(config_dir, error).permissions() & fs::perms::owner_write) == fs::perms::owner_write and statvfs(config_dir.c_str(), &stats) == 0 and (stats.f_flag & ST_RDONLY) == 0) { return config_dir; } else { fmt::print(stderr, "\033[0;31mWarning: \033[0m`{}` is not writable\n", fs::absolute(config_dir).string()); // If the config is readable we can still use the provided config, but changes will not be persistent if ((fs::status(config_dir, error).permissions() & fs::perms::owner_read) == fs::perms::owner_read) { fmt::print(stderr, "\033[0;31mWarning: \033[0mLogging is disabled, config changes are not persistent\n"); return config_dir; } } } else { fmt::print(stderr, "\033[0;31mWarning: \033[0m`{}` is not a directory\n", fs::absolute(config_dir).string()); } } else { // Doesn't exist if (fs::create_directories(config_dir, error)) { return config_dir; } else { fmt::print(stderr, "\033[0;31mWarning: \033[0m`{}` could not be created: {}\n", fs::absolute(config_dir).string(), error.message()); } } } else { fmt::print(stderr, "\033[0;31mWarning: \033[0mCould not determine config path: Make sure `$XDG_CONFIG_HOME` or `$HOME` is set\n"); } fmt::print(stderr, "\033[0;31mWarning: \033[0mLogging is disabled, config changes are not persistent\n"); return {}; } bool _locked(const std::string_view name) { atomic_wait(writelock, true); if (not write_new and rng::find_if(descriptions, [&name](const auto& a) { return a.at(0) == name; }) != descriptions.end()) write_new = true; return locked.load(); } fs::path conf_dir; fs::path conf_file; vector available_batteries = {"Auto"}; vector current_boxes; vector preset_list = {"cpu:0:default,mem:0:default,net:0:default,proc:0:default"}; std::optional current_preset; bool presetsValid(const string& presets) { vector new_presets = {preset_list.at(0)}; for (int x = 0; const auto& preset : ssplit(presets)) { if (++x > 9) { validError = "Too many presets entered!"; return false; } for (int y = 0; const auto& box : ssplit(preset, ',')) { if (++y > 4) { validError = "Too many boxes entered for preset!"; return false; } const auto& vals = ssplit(box, ':'); if (vals.size() != 3) { validError = "Malformatted preset in config value presets!"; return false; } if (not is_in(vals.at(0), "cpu", "mem", "net", "proc", "gpu0", "gpu1", "gpu2", "gpu3", "gpu4", "gpu5")) { validError = "Invalid box name in config value presets!"; return false; } if (not is_in(vals.at(1), "0", "1")) { validError = "Invalid position value in config value presets!"; return false; } if (not v_contains(valid_graph_symbols_def, vals.at(2))) { validError = "Invalid graph name in config value presets!"; return false; } } new_presets.push_back(preset); } preset_list = std::move(new_presets); return true; } //* Apply selected preset bool apply_preset(const string& preset) { string boxes; for (const auto& box : ssplit(preset, ',')) { const auto& vals = ssplit(box, ':'); boxes += vals.at(0) + ' '; } if (not boxes.empty()) boxes.pop_back(); auto min_size = Term::get_min_size(boxes); if (Term::width < min_size.at(0) or Term::height < min_size.at(1)) { return false; } for (const auto& box : ssplit(preset, ',')) { const auto& vals = ssplit(box, ':'); if (vals.at(0) == "cpu") { set("cpu_bottom", (vals.at(1) != "0")); } else if (vals.at(0) == "mem") { set("mem_below_net", (vals.at(1) != "0")); } else if (vals.at(0) == "proc") { set("proc_left", (vals.at(1) != "0")); } if (vals.at(0).starts_with("gpu")) { set("graph_symbol_gpu", vals.at(2)); } else { set(strings.find("graph_symbol_" + vals.at(0))->first, vals.at(2)); } } if (set_boxes(boxes)) { set("shown_boxes", boxes); return true; } return false; } void lock() { atomic_wait(writelock); locked = true; } string validError; bool intValid(const std::string_view name, const string& value) { int i_value; try { i_value = stoi(value); } catch (const std::invalid_argument&) { validError = "Invalid numerical value!"; return false; } catch (const std::out_of_range&) { validError = "Value out of range!"; return false; } catch (const std::exception& e) { validError = string{e.what()}; return false; } if (name == "update_ms" and i_value < 100) validError = "Config value update_ms set too low (<100)."; else if (name == "update_ms" and i_value > ONE_DAY_MILLIS) validError = fmt::format("Config value update_ms set too high (>{}).", ONE_DAY_MILLIS); else return true; return false; } bool validBoxSizes(const string& boxes) { auto min_size = Term::get_min_size(boxes); return (Term::width >= min_size.at(0) and Term::height >= min_size.at(1)); } bool stringValid(const std::string_view name, const string& value) { if (name == "log_level" and not v_contains(Logger::log_levels, value)) validError = "Invalid log_level: " + value; else if (name == "graph_symbol" and not v_contains(valid_graph_symbols, value)) validError = "Invalid graph symbol identifier: " + value; else if (name.starts_with("graph_symbol_") and (value != "default" and not v_contains(valid_graph_symbols, value))) validError = fmt::format("Invalid graph symbol identifier for {}: {}", name, value); else if (name == "shown_boxes" and not Global::init_conf) { if (value.empty()) validError = "No boxes selected!"; else if (not validBoxSizes(value)) validError = "Terminal too small to display entered boxes!"; else if (not set_boxes(value)) validError = "Invalid box name(s) in shown_boxes!"; else return true; } #ifdef GPU_SUPPORT else if (name == "show_gpu_info" and not v_contains(show_gpu_values, value)) validError = "Invalid value for show_gpu_info: " + value; #endif else if (name == "presets" and not presetsValid(value)) return false; else if (name == "cpu_core_map") { const auto maps = ssplit(value); bool all_good = true; for (const auto& map : maps) { const auto map_split = ssplit(map, ':'); if (map_split.size() != 2) all_good = false; else if (not isint(map_split.at(0)) or not isint(map_split.at(1))) all_good = false; if (not all_good) { validError = "Invalid formatting of cpu_core_map!"; return false; } } return true; } else if (name == "io_graph_speeds") { const auto maps = ssplit(value); bool all_good = true; for (const auto& map : maps) { const auto map_split = ssplit(map, ':'); if (map_split.size() != 2) all_good = false; else if (map_split.at(0).empty() or not isint(map_split.at(1))) all_good = false; if (not all_good) { validError = "Invalid formatting of io_graph_speeds!"; return false; } } return true; } else return true; return false; } string getAsString(const std::string_view name) { if (auto it = bools.find(name); it != bools.end()) return it->second ? "True" : "False"; if (auto it = ints.find(name); it != ints.end()) return to_string(it->second); if (auto it = strings.find(name); it != strings.end()) return it->second; return ""; } void flip(const std::string_view name) { if (_locked(name)) { if (boolsTmp.contains(name)) boolsTmp.at(name) = not boolsTmp.at(name); else boolsTmp.insert_or_assign(name, (not bools.at(name))); } else bools.at(name) = not bools.at(name); } void unlock() { if (not locked) return; atomic_wait(Runner::active); atomic_lock lck(writelock, true); try { if (Proc::shown) { ints.at("selected_pid") = Proc::selected_pid; strings.at("selected_name") = Proc::selected_name; ints.at("proc_start") = Proc::start; ints.at("proc_selected") = Proc::selected; ints.at("selected_depth") = Proc::selected_depth; } for (auto& item : stringsTmp) { strings.at(item.first) = item.second; } stringsTmp.clear(); for (auto& item : intsTmp) { ints.at(item.first) = item.second; } intsTmp.clear(); for (auto& item : boolsTmp) { bools.at(item.first) = item.second; } boolsTmp.clear(); } catch (const std::exception& e) { Global::exit_error_msg = fmt::format("Exception during Config::unlock() : {}", e.what()); clean_quit(1); } locked = false; } bool set_boxes(const string& boxes) { auto new_boxes = ssplit(boxes); for (auto& box : new_boxes) { if (not v_contains(valid_boxes, box)) return false; #ifdef GPU_SUPPORT if (box.starts_with("gpu")) { int gpu_num = stoi(box.substr(3)) + 1; if (gpu_num > Gpu::count) return false; } #endif } current_boxes = std::move(new_boxes); return true; } bool toggle_box(const string& box) { auto old_boxes = current_boxes; auto box_pos = rng::find(current_boxes, box); if (box_pos == current_boxes.end()) current_boxes.push_back(box); else current_boxes.erase(box_pos); string new_boxes; if (not current_boxes.empty()) { for (const auto& b : current_boxes) new_boxes += b + ' '; new_boxes.pop_back(); } auto min_size = Term::get_min_size(new_boxes); if (Term::width < min_size.at(0) or Term::height < min_size.at(1)) { current_boxes = old_boxes; return false; } Config::set("shown_boxes", new_boxes); return true; } void load(const fs::path& conf_file, vector& load_warnings) { std::error_code error; if (conf_file.empty()) return; else if (not fs::exists(conf_file, error)) { write_new = true; return; } if (error) { return; } std::ifstream cread(conf_file); if (cread.good()) { vector valid_names; valid_names.reserve(descriptions.size()); for (const auto &n : descriptions) valid_names.push_back(n[0]); if (string v_string; cread.peek() != '#' or (getline(cread, v_string, '\n') and not v_string.contains(Global::Version))) write_new = true; while (not cread.eof()) { cread >> std::ws; if (cread.peek() == '#') { cread.ignore(SSmax, '\n'); continue; } string name, value; getline(cread, name, '='); if (name.ends_with(' ')) name = trim(name); if (not v_contains(valid_names, name)) { cread.ignore(SSmax, '\n'); continue; } cread >> std::ws; if (bools.contains(name)) { cread >> value; if (not isbool(value)) load_warnings.push_back("Got an invalid bool value for config name: " + name); else bools.at(name) = stobool(value); } else if (ints.contains(name)) { cread >> value; if (not isint(value)) load_warnings.push_back("Got an invalid integer value for config name: " + name); else if (not intValid(name, value)) { load_warnings.push_back(validError); } else ints.at(name) = stoi(value); } else if (strings.contains(name)) { if (cread.peek() == '"') { cread.ignore(1); getline(cread, value, '"'); } else cread >> value; if (not stringValid(name, value)) load_warnings.push_back(validError); else strings.at(name) = value; } cread.ignore(SSmax, '\n'); } if (not load_warnings.empty()) write_new = true; } } void write() { if (conf_file.empty() or not write_new) return; Logger::debug("Writing new config file"); if (geteuid() != Global::real_uid and seteuid(Global::real_uid) != 0) return; std::ofstream cwrite(conf_file, std::ios::trunc); // TODO: Report error when stream is in a bad state. if (cwrite.good()) { cwrite << current_config(); } } static constexpr auto get_xdg_state_dir() -> std::optional { std::optional xdg_state_home; { const auto* xdg_state_home_ptr = std::getenv("XDG_STATE_HOME"); if (xdg_state_home_ptr != nullptr) { xdg_state_home = std::make_optional(fs::path(xdg_state_home_ptr)); } else { const auto* home_ptr = std::getenv("HOME"); if (home_ptr != nullptr) { xdg_state_home = std::make_optional(fs::path(home_ptr) / ".local" / "state"); } } } if (xdg_state_home.has_value()) { std::error_code err; fs::create_directories(xdg_state_home.value(), err); if (err) { return std::nullopt; } return xdg_state_home; } return std::nullopt; } auto get_log_file() -> std::optional { return get_xdg_state_dir().transform([](auto&& state_home) -> auto { return state_home / "btop.log"; }); } auto current_config() -> std::string { auto buffer = std::string {}; fmt::format_to(std::back_inserter(buffer), "#? Config file for btop v.{}\n", Global::Version); for (const auto& [name, description] : descriptions) { // Write a description comment if available. fmt::format_to(std::back_inserter(buffer), "\n"); if (!description.empty()) { fmt::format_to(std::back_inserter(buffer), "{}\n", description); } fmt::format_to(std::back_inserter(buffer), "{} = ", name); // Lookup default value by name and write it out. if (strings.contains(name)) { fmt::format_to(std::back_inserter(buffer), R"("{}")", strings[name]); } else if (ints.contains(name)) { fmt::format_to(std::back_inserter(buffer), std::locale::classic(), "{:L}", ints[name]); } else if (bools.contains(name)) { fmt::format_to(std::back_inserter(buffer), "{}", bools[name] ? "true" : "false"); } fmt::format_to(std::back_inserter(buffer), "\n"); } return buffer; } } aristocratos-btop-d43a485/src/btop_config.hpp000066400000000000000000000110251517514752700213350ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include using std::string; using std::vector; //* Functions and variables for reading and writing the btop config file namespace Config { extern std::filesystem::path conf_dir; extern std::filesystem::path conf_file; extern std::unordered_map strings; extern std::unordered_map stringsTmp; extern std::unordered_map bools; extern std::unordered_map boolsTmp; extern std::unordered_map ints; extern std::unordered_map intsTmp; const vector valid_graph_symbols = { "braille", "block", "tty" }; const vector valid_graph_symbols_def = { "default", "braille", "block", "tty" }; const vector valid_boxes = { "cpu", "mem", "net", "proc" #ifdef GPU_SUPPORT ,"gpu0", "gpu1", "gpu2", "gpu3", "gpu4", "gpu5" #endif }; const vector temp_scales = { "celsius", "fahrenheit", "kelvin", "rankine" }; #ifdef __linux__ const vector freq_modes = { "first", "range", "lowest", "highest", "average" }; #endif #ifdef GPU_SUPPORT const vector show_gpu_values = { "Auto", "On", "Off" }; #endif const vector base_10_bitrate_values = { "Auto", "True", "False" }; extern vector current_boxes; extern vector preset_list; const vector disable_preset_options = { "Off", "Default", "Custom", "All" }; extern vector available_batteries; extern std::optional current_preset; extern bool write_new; constexpr int ONE_DAY_MILLIS = 1000 * 60 * 60 * 24; [[nodiscard]] std::optional get_config_dir() noexcept; //* Check if string only contains space separated valid names for boxes and set current_boxes bool set_boxes(const string& boxes); bool validBoxSizes(const string& boxes); //* Toggle box and update config string shown_boxes bool toggle_box(const string& box); //* Parse and setup config value presets bool presetsValid(const string& presets); //* Apply selected preset bool apply_preset(const string& preset); bool _locked(const std::string_view name); //* Return bool for config key inline bool getB(const std::string_view name) { return bools.at(name); } //* Return integer for config key inline const int& getI(const std::string_view name) { return ints.at(name); } //* Return string for config key inline const string& getS(const std::string_view name) { return strings.at(name); } string getAsString(const std::string_view name); extern string validError; bool intValid(const std::string_view name, const string& value); bool stringValid(const std::string_view name, const string& value); //* Set config key to bool inline void set(const std::string_view name, bool value) { if (_locked(name)) boolsTmp.insert_or_assign(name, value); else bools.at(name) = value; } //* Set config key to int inline void set(const std::string_view name, const int value) { if (_locked(name)) intsTmp.insert_or_assign(name, value); else ints.at(name) = value; } //* Set config key to string inline void set(const std::string_view name, const string& value) { if (_locked(name)) stringsTmp.insert_or_assign(name, value); else strings.at(name) = value; } //* Flip config key bool void flip(const std::string_view name); //* Lock config and cache changes until unlocked void lock(); //* Unlock config and write any cached values to config void unlock(); //* Load the config file from disk void load(const std::filesystem::path& conf_file, vector& load_warnings); //* Write the config file to disk void write(); auto get_log_file() -> std::optional; // Write default config to an in-memory buffer [[nodiscard]] auto current_config() -> std::string; } aristocratos-btop-d43a485/src/btop_draw.cpp000066400000000000000000003262301517514752700210270ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include #include #include #include "btop_config.hpp" #include "btop_draw.hpp" #include "btop_input.hpp" #include "btop_log.hpp" #include "btop_menu.hpp" #include "btop_shared.hpp" #include "btop_theme.hpp" #include "btop_tools.hpp" using std::array; using std::clamp; using std::cmp_equal; using std::cmp_greater; using std::cmp_less; using std::cmp_less_equal; using std::floor; using std::max; using std::min; using std::round; using std::to_string; using std::views::iota; using namespace Tools; using namespace std::literals; // for operator""s namespace rng = std::ranges; namespace Symbols { const string meter = "โ– "; const array superscript = { "โฐ", "ยน", "ยฒ", "ยณ", "โด", "โต", "โถ", "โท", "โธ", "โน" }; const std::unordered_map> graph_symbols = { { "braille_up", { " ", "โข€", "โข ", "โขฐ", "โขธ", "โก€", "โฃ€", "โฃ ", "โฃฐ", "โฃธ", "โก„", "โฃ„", "โฃค", "โฃด", "โฃผ", "โก†", "โฃ†", "โฃฆ", "โฃถ", "โฃพ", "โก‡", "โฃ‡", "โฃง", "โฃท", "โฃฟ" }}, {"braille_down", { " ", "โ ˆ", "โ ˜", "โ ธ", "โขธ", "โ ", "โ ‰", "โ ™", "โ น", "โขน", "โ ƒ", "โ ‹", "โ ›", "โ ป", "โขป", "โ ‡", "โ ", "โ Ÿ", "โ ฟ", "โขฟ", "โก‡", "โก", "โกŸ", "โกฟ", "โฃฟ" }}, {"block_up", { " ", "โ–—", "โ–—", "โ–", "โ–", "โ––", "โ–„", "โ–„", "โ–Ÿ", "โ–Ÿ", "โ––", "โ–„", "โ–„", "โ–Ÿ", "โ–Ÿ", "โ–Œ", "โ–™", "โ–™", "โ–ˆ", "โ–ˆ", "โ–Œ", "โ–™", "โ–™", "โ–ˆ", "โ–ˆ" }}, {"block_down", { " ", "โ–", "โ–", "โ–", "โ–", "โ–˜", "โ–€", "โ–€", "โ–œ", "โ–œ", "โ–˜", "โ–€", "โ–€", "โ–œ", "โ–œ", "โ–Œ", "โ–›", "โ–›", "โ–ˆ", "โ–ˆ", "โ–Œ", "โ–›", "โ–›", "โ–ˆ", "โ–ˆ" }}, {"tty_up", { " ", "โ–‘", "โ–‘", "โ–’", "โ–’", "โ–‘", "โ–‘", "โ–’", "โ–’", "โ–ˆ", "โ–‘", "โ–’", "โ–’", "โ–’", "โ–ˆ", "โ–’", "โ–’", "โ–’", "โ–ˆ", "โ–ˆ", "โ–’", "โ–ˆ", "โ–ˆ", "โ–ˆ", "โ–ˆ" }}, {"tty_down", { " ", "โ–‘", "โ–‘", "โ–’", "โ–’", "โ–‘", "โ–‘", "โ–’", "โ–’", "โ–ˆ", "โ–‘", "โ–’", "โ–’", "โ–’", "โ–ˆ", "โ–’", "โ–’", "โ–’", "โ–ˆ", "โ–ˆ", "โ–’", "โ–ˆ", "โ–ˆ", "โ–ˆ", "โ–ˆ" }} }; } namespace Draw { string banner_gen(int y, int x, bool centered, bool redraw) { static string banner; static size_t width = 0; if (redraw) banner.clear(); if (banner.empty()) { string b_color, bg, fg, oc, letter; auto lowcolor = Config::getB("lowcolor"); auto tty_mode = Config::getB("tty_mode"); for (size_t z = 0; const auto& line : Global::Banner_src) { if (const auto w = ulen(line[1]); w > width) width = w; if (tty_mode) { fg = (z > 2) ? "\x1b[31m" : "\x1b[91m"; bg = (z > 2) ? "\x1b[90m" : "\x1b[37m"; } else { fg = Theme::hex_to_color(line[0], lowcolor); int bg_i = 120 - z * 12; bg = Theme::dec_to_color(bg_i, bg_i, bg_i, lowcolor); } for (size_t i = 0; i < line[1].size(); i += 3) { if (line[1][i] == ' ') { letter = Mv::r(1); i -= 2; } else letter = line[1].substr(i, 3); b_color = (letter == "โ–ˆ") ? fg : bg; if (b_color != oc) banner += b_color; banner += letter; oc = b_color; } if (++z < Global::Banner_src.size()) banner += Mv::l(ulen(line[1])) + Mv::d(1); } banner += Mv::r(18 - Global::Version.size()) + Theme::c("main_fg") + Fx::b + Fx::i + "v" + Global::Version + Fx::reset; } if (redraw) return ""; return (centered ? Mv::to(y, Term::width / 2 - width / 2) : Mv::to(y, x)) + banner; } TextEdit::TextEdit() {} TextEdit::TextEdit(string text, bool numeric) : numeric(numeric), text(std::move(text)) { pos = this->text.size(); upos = ulen(this->text); } bool TextEdit::command(const std::string_view key) { if (key == "left" and upos > 0) { upos--; pos = uresize(text, upos).size(); } else if (key == "right" and pos < text.size()) { upos++; pos = uresize(text, upos).size(); } else if (key == "home" and not text.empty() and pos > 0) { pos = upos = 0; } else if (key == "end" and not text.empty() and pos < text.size()) { pos = text.size(); upos = ulen(text); } else if (key == "backspace" and pos > 0) { if (pos == text.size()) { text = uresize(text, --upos); pos = text.size(); } else { const string first = uresize(text, --upos); pos = first.size(); text = first + luresize(text.substr(pos), ulen(text) - upos - 1); } } else if (key == "delete" and pos < text.size()) { const string first = uresize(text, upos + 1); text = uresize(first, ulen(first) - 1) + text.substr(first.size()); } else if (key == "space" and not numeric) { text.insert(pos++, 1, ' '); upos++; } else if (ulen(key) == 1 and text.size() < text.max_size() - 20) { if (numeric and not isint(key)) return false; if (key.size() == 1) { text.insert(pos++, 1, key.at(0)); upos++; } else { const auto first = fmt::format("{}{}", uresize(text, upos), key); text = first + text.substr(pos); upos++; pos = first.size(); } } else return false; return true; } string TextEdit::operator()(const size_t limit) { string out; size_t c_upos = upos; if (text.empty()) return Fx::ul + " " + Fx::uul; if (limit > 0 and ulen(text) + 1 > limit) { try { const size_t half = (size_t)round((double)limit / 2); string first; if (upos + half > ulen(text)) first = luresize(text.substr(0, pos), limit - (ulen(text) - upos)); else if (upos - half < 1) first = text.substr(0, pos); else first = luresize(text.substr(0, pos), half); out = first + uresize(text.substr(pos), limit - ulen(first)); c_upos = ulen(first); } catch (const std::exception& e) { Logger::error("In TextEdit::operator() : {}", e.what()); return ""; } } else out = text; if (c_upos == 0) return Fx::ul + uresize(out, 1) + Fx::uul + luresize(out, ulen(out) - 1); else if (c_upos == ulen(out)) return out + Fx::ul + " " + Fx::uul; else return uresize(out, c_upos) + Fx::ul + luresize(uresize(out, c_upos + 1), 1) + Fx::uul + luresize(out, ulen(out) - c_upos - 1); } void TextEdit::clear() { this->text.clear(); } string createBox( const int x, const int y, const int width, const int height, string line_color, bool fill, const std::string_view title, const std::string_view title2, const int num ) { string out; if (line_color.empty()) line_color = Theme::c("div_line"); auto tty_mode = Config::getB("tty_mode"); auto rounded = Config::getB("rounded_corners"); const string numbering = (num == 0) ? "" : Theme::c("hi_fg") + (tty_mode ? std::to_string(num) : Symbols::superscript.at(clamp(num, 0, 9))); const auto& right_up = (tty_mode or not rounded ? Symbols::right_up : Symbols::round_right_up); const auto& left_up = (tty_mode or not rounded ? Symbols::left_up : Symbols::round_left_up); const auto& right_down = (tty_mode or not rounded ? Symbols::right_down : Symbols::round_right_down); const auto& left_down = (tty_mode or not rounded ? Symbols::left_down : Symbols::round_left_down); out = Fx::reset + line_color; //? Draw horizontal lines for (const int& hpos : {y, y + height - 1}) { out += Mv::to(hpos, x) + Symbols::h_line * (width - 1); } //? Draw vertical lines and fill if enabled for (const int& hpos : iota(y + 1, y + height - 1)) { out += Mv::to(hpos, x) + Symbols::v_line + ((fill) ? string(width - 2, ' ') : Mv::r(width - 2)) + Symbols::v_line; } //? Draw corners out += Mv::to(y, x) + left_up + Mv::to(y, x + width - 1) + right_up + Mv::to(y + height - 1, x) +left_down + Mv::to(y + height - 1, x + width - 1) + right_down; //? Draw titles if defined if (not title.empty()) { out += fmt::format( "{}{}{}{}{}{}{}{}{}", Mv::to(y, x + 2), Symbols::title_left, Fx::b, numbering, Theme::c("title"), title, Fx::ub, line_color, Symbols::title_right ); } if (not title2.empty()) { out += fmt::format( "{}{}{}{}{}{}{}{}{}", Mv::to(y + height - 1, x + 2), Symbols::title_left_down, Fx::b, numbering, Theme::c("title"), title2, Fx::ub, line_color, Symbols::title_right_down ); } return out + Fx::reset + Mv::to(y + 1, x + 1); } bool update_clock(bool force) { const auto& clock_format = Config::getS("clock_format"); if (not Cpu::shown or clock_format.empty()) { if (clock_format.empty() and not Global::clock.empty()) Global::clock.clear(); return false; } static const std::unordered_map clock_custom_format = { {"/user", Tools::username()}, {"/host", Tools::hostname()}, {"/uptime", ""} }; static time_t c_time{}; static size_t clock_len{}; static string clock_str; if (auto n_time = time(nullptr); not force and n_time == c_time) return false; else { c_time = n_time; const auto new_clock = Tools::strf_time(clock_format); if (not force and new_clock == clock_str) return false; clock_str = new_clock; } auto& out = Global::clock; auto cpu_bottom = Config::getB("cpu_bottom"); const auto& x = Cpu::x; const auto y = (cpu_bottom ? Cpu::y + Cpu::height - 1 : Cpu::y); const auto& width = Cpu::width; const auto& title_left = (cpu_bottom ? Symbols::title_left_down : Symbols::title_left); const auto& title_right = (cpu_bottom ? Symbols::title_right_down : Symbols::title_right); for (const auto& [c_format, replacement] : clock_custom_format) { if (clock_str.contains(c_format)) { if (c_format == "/uptime") { string upstr = sec_to_dhms(system_uptime()); if (upstr.size() > 8) upstr.resize(upstr.size() - 3); clock_str = s_replace(clock_str, c_format, upstr); } else { clock_str = s_replace(clock_str, c_format, replacement); } } } clock_str = uresize(clock_str, std::max(10, width - 66 - (Term::width >= 100 and Config::getB("show_battery") and Cpu::has_battery ? 22 : 0))); out.clear(); if (clock_str.size() != clock_len) { if (not Global::resized and clock_len > 0) out = Mv::to(y, x+(width / 2)-(clock_len / 2)) + Fx::ub + Theme::c("cpu_box") + Symbols::h_line * clock_len; clock_len = clock_str.size(); } out += Mv::to(y, x+(width / 2)-(clock_len / 2)) + Fx::ub + Theme::c("cpu_box") + title_left + Theme::c("title") + Fx::b + clock_str + Theme::c("cpu_box") + Fx::ub + title_right; return true; } //* Meter class ------------------------------------------------------------------------------------------------------------> Meter::Meter() {} Meter::Meter(const int width, string color_gradient, bool invert) : width(width), color_gradient(std::move(color_gradient)), invert(invert) {} string Meter::operator()(int value) { if (width < 1) return ""; value = clamp(value, 0, 100); if (not cache.at(value).empty()) return cache.at(value); auto& out = cache.at(value); for (const int& i : iota(1, width + 1)) { int y = round((double)i * 100.0 / width); if (value >= y) out += Theme::g(color_gradient).at(invert ? 100 - y : y) + Symbols::meter; else { out += Theme::c("meter_bg") + Symbols::meter * (width + 1 - i); break; } } out += Fx::reset; return out; } //* Graph class ------------------------------------------------------------------------------------------------------------> void Graph::_create(const deque& data, int data_offset) { bool mult = (data.size() - data_offset > 1); const auto& graph_symbol = Symbols::graph_symbols.at(symbol + '_' + (invert ? "down" : "up")); array result; const float mod = (height == 1) ? 0.3 : 0.1; long long data_value = 0; if (mult and data_offset > 0) { last = data.at(data_offset - 1); if (max_value > 0) last = clamp((last + offset) * 100 / max_value, 0ll, 100ll); } //? Horizontal iteration over values in for (const int& i : iota(data_offset, (int)data.size())) { // if (tty_mode and mult and i % 2 != 0) continue; if (not tty_mode and mult) current = not current; if (i < 0) { data_value = 0; last = 0; } else { data_value = data.at(i); if (max_value > 0) data_value = clamp((data_value + offset) * 100 / max_value, 0ll, 100ll); } //? Vertical iteration over height of graph for (const int& horizon : iota(0, height)) { const int cur_high = (height > 1) ? round(100.0 * (height - horizon) / height) : 100; const int cur_low = (height > 1) ? round(100.0 * (height - (horizon + 1)) / height) : 0; //? Calculate previous + current value to fit two values in 1 braille character for (int ai = 0; const auto& value : {last, data_value}) { const int clamp_min = (no_zero and horizon == height - 1 and not (mult and i == data_offset and ai == 0)) ? 1 : 0; if (value >= cur_high) result[ai++] = 4; else if (value <= cur_low) result[ai++] = clamp_min; else { result[ai++] = clamp((int)round((float)(value - cur_low) * 4 / (cur_high - cur_low) + mod), clamp_min, 4); } } //? Generate graph symbol from 5x5 2D vector if (height == 1) { if (result.at(0) + result.at(1) == 0) graphs.at(current).at(horizon) += Mv::r(1); else { if (not color_gradient.empty()) graphs.at(current).at(horizon) += Theme::g(color_gradient).at(clamp(max(last, data_value), 0ll, 100ll)); graphs.at(current).at(horizon) += graph_symbol.at((result.at(0) * 5 + result.at(1))); } } else graphs.at(current).at(horizon) += graph_symbol.at((result.at(0) * 5 + result.at(1))); } if (mult and i >= 0) last = data_value; } last = data_value; out.clear(); if (height == 1) { //if (not color_gradient.empty()) // out += (last < 1 ? Theme::c("inactive_fg") : Theme::g(color_gradient).at(clamp(last, 0ll, 100ll))); out += graphs.at(current).at(0); } else { for (const int& i : iota(1, height + 1)) { if (i > 1) out += Mv::d(1) + Mv::l(width); if (not color_gradient.empty()) out += (invert) ? Theme::g(color_gradient).at(i * 100 / height) : Theme::g(color_gradient).at(100 - ((i - 1) * 100 / height)); out += (invert) ? graphs.at(current).at(height - i) : graphs.at(current).at(i-1); } } if (not color_gradient.empty()) out += Fx::reset; } Graph::Graph() {} Graph::Graph(int width, int height, const string& color_gradient, const deque& data, const string& symbol, bool invert, bool no_zero, long long max_value, long long offset) : width(width), height(height), color_gradient(color_gradient), invert(invert), no_zero(no_zero), offset(offset) { if (Config::getB("tty_mode") or symbol == "tty") this->symbol = "tty"; else if (symbol != "default") this->symbol = symbol; else this->symbol = Config::getS("graph_symbol"); if (this->symbol == "tty") tty_mode = true; if (max_value == 0 and offset > 0) max_value = 100; this->max_value = max_value; const int value_width = (tty_mode ? data.size() : ceil((double)data.size() / 2)); int data_offset = (value_width > width) ? data.size() - width * (tty_mode ? 1 : 2) : 0; if (not tty_mode and (data.size() - data_offset) % 2 != 0) { data_offset--; } //? Populate the two switching graph vectors and fill empty space if data size < width for (const int& i : iota(0, height * 2)) { if (tty_mode and i % 2 != current) continue; graphs[(i % 2 != 0)].push_back((value_width < width) ? ((height == 1) ? Mv::r(1) : " "s) * (width - value_width) : ""); } if (data.size() == 0) return; this->_create(data, data_offset); } string& Graph::operator()(const deque& data, bool data_same) { if (data_same) return out; //? Make room for new characters on graph if (not tty_mode) current = not current; for (const int& i : iota(0, height)) { if (height == 1 and graphs.at(current).at(i).at(1) == '[') { if (graphs.at(current).at(i).at(3) == 'C') graphs.at(current).at(i).erase(0, 4); else graphs.at(current).at(i).erase(0, graphs.at(current).at(i).find_first_of('m') + 4); } else if (graphs.at(current).at(i).at(0) == ' ') graphs.at(current).at(i).erase(0, 1); else graphs.at(current).at(i).erase(0, 3); } this->_create(data, (int)data.size() - 1); return out; } string& Graph::operator()() { return out; } //*-------------------------------------------------------------------------------------------------------------------------> } namespace Cpu { int width_p = 100, height_p = 32; int min_width = 60, min_height = 8; int x = 1, y = 1, width = 20, height; int b_columns, b_column_size; int b_x, b_y, b_width, b_height; float max_observed_pwr = 1.0f; int graph_up_height, graph_low_height; int graph_up_width, graph_low_width; int gpu_meter_width; bool shown = true, redraw = true, mid_line = false; string box; vector graphs_upper; vector graphs_lower; Draw::Meter cpu_meter; vector gpu_meters; vector core_graphs; vector temp_graphs; vector gpu_temp_graphs; vector gpu_mem_graphs; string draw( const cpu_info& cpu, #if defined(GPU_SUPPORT) const vector& gpus, #endif // GPU_SUPPORT bool force_redraw, bool data_same ) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; bool show_temps = (Config::getB("check_temp") and got_sensors); bool show_watts = (Config::getB("show_cpu_watts") and supports_watts); auto single_graph = Config::getB("cpu_single_graph"); bool hide_cores = show_temps and (cpu_temp_only or not Config::getB("show_coretemp")); const int extra_width = (hide_cores ? max(6, 6 * b_column_size) : (b_columns == 1 && !show_temps) ? 8 : 0); #if defined(GPU_SUPPORT) const auto& show_gpu_info = Config::getS("show_gpu_info"); const bool gpu_always = show_gpu_info == "On"; const bool gpu_auto = show_gpu_info == "Auto"; const bool show_gpu = (gpus.size() > 0 and (gpu_always or (gpu_auto and Gpu::shown < Gpu::count))); #endif // GPU_SUPPORT auto graph_up_field = Config::getS("cpu_graph_upper"); if (graph_up_field == "Auto" or not v_contains(Cpu::available_fields, graph_up_field)) graph_up_field = "total"; auto graph_lo_field = Config::getS("cpu_graph_lower"); if (graph_lo_field == "Auto" or not v_contains(Cpu::available_fields, graph_lo_field)) { #ifdef GPU_SUPPORT graph_lo_field = show_gpu ? "gpu-totals" : graph_up_field; #else graph_lo_field = graph_up_field; #endif } auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_cpu")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); auto& temp_scale = Config::getS("temp_scale"); auto cpu_bottom = Config::getB("cpu_bottom"); const auto safe_cpu_temp_max = cpu.temp_max <= 0 ? 90 : cpu.temp_max; const string& title_left = Theme::c("cpu_box") + (cpu_bottom ? Symbols::title_left_down : Symbols::title_left); const string& title_right = Theme::c("cpu_box") + (cpu_bottom ? Symbols::title_right_down : Symbols::title_right); static int bat_pos = 0, bat_len = 0; if (safeVal(cpu.cpu_percent, "total"s).empty() or safeVal(cpu.core_percent, 0).empty() or (show_temps and safeVal(cpu.temp, 0).empty())) return ""; string out; out.reserve(width * height); //* Redraw elements not needed to be updated every cycle if (redraw) { mid_line = (not single_graph and graph_up_field != graph_lo_field); graph_up_height = (single_graph ? height - 2 : ceil((double)(height - 2) / 2) - (mid_line and height % 2 != 0)); graph_low_height = height - 2 - graph_up_height - mid_line; const int button_y = cpu_bottom ? y + height - 1 : y; out += box; //? Buttons on title out += Mv::to(button_y, x + 10) + title_left + Theme::c("hi_fg") + Fx::b + 'm' + Theme::c("title") + "enu" + Fx::ub + title_right; Input::mouse_mappings["m"] = {button_y, x + 11, 1, 4}; out += Mv::to(button_y, x + 16) + title_left + Theme::c("hi_fg") + Fx::b + 'p' + Theme::c("title") + "reset " + (!Config::current_preset.has_value() ? "*" : to_string(Config::current_preset.value())) + Fx::ub + title_right; Input::mouse_mappings["p"] = {button_y, x + 17, 1, 8}; const string update = to_string(Config::getI("update_ms")) + "ms"; out += Mv::to(button_y, x + width - update.size() - 8) + title_left + Fx::b + Theme::c("hi_fg") + "- " + Theme::c("title") + update + Theme::c("hi_fg") + " +" + Fx::ub + title_right; Input::mouse_mappings["-"] = {button_y, x + width - (int)update.size() - 7, 1, 2}; Input::mouse_mappings["+"] = {button_y, x + width - 5, 1, 2}; // Draw container engine name if (Cpu::container_engine.has_value()) { fmt::format_to(std::back_inserter(out), "{}{}{}{}{}", Mv::to(button_y, x + 28), title_left, Theme::c("title"), Cpu::container_engine.value(), title_right); } //? Graphs & meters const int graph_default_width = x + width - b_width - 3; auto init_graphs = [&](vector& graphs, const int graph_height, int& graph_width, const string& graph_field, bool invert) { #ifdef GPU_SUPPORT if (graph_field.starts_with("gpu")) { if (graph_field.find("totals") != string::npos) { graphs.resize(gpus.size()); gpu_temp_graphs.resize(gpus.size()); gpu_mem_graphs.resize(gpus.size()); gpu_meters.resize(gpus.size()); const int gpu_draw_count = gpu_always ? Gpu::count : Gpu::count - Gpu::shown; // Fairly distribute graph_default_width across gpu_draw_count GPUs, leaving 1 col per separator. // Clamp to >=1 to avoid degenerate/negative widths reaching Draw::Graph::_create (#1118, #1017). const int gpu_drawable_width = graph_default_width - max(0, gpu_draw_count - 1); graph_width = gpu_draw_count <= 0 ? graph_default_width : max(1, gpu_drawable_width / gpu_draw_count); for (size_t i = 0; i < gpus.size(); i++) { if (gpu_auto and v_contains(Gpu::shown_panels, i)) continue; auto& gpu = gpus[i]; auto& graph = graphs[i]; //? GPU graphs if (gpu.supported_functions.gpu_utilization) { if (i + 1 < gpus.size()) { graph = Draw::Graph{graph_width, graph_height, "cpu", safeVal(gpu.gpu_percent, graph_field), graph_symbol, invert, true}; } else { graph = Draw::Graph{ max(1, graph_width + (gpu_draw_count > 0 ? gpu_drawable_width % gpu_draw_count : 0)), graph_height, "cpu", safeVal(gpu.gpu_percent, graph_field), graph_symbol, invert, true }; } } } } else { graphs.resize(1); graph_width = graph_default_width; graphs[0] = Draw::Graph{ graph_width, graph_height, "cpu", safeVal(Gpu::shared_gpu_percent, graph_field), graph_symbol, invert, true }; } } else { #endif graphs.resize(1); graph_width = graph_default_width; graphs[0] = Draw::Graph{ graph_width, graph_height, "cpu", safeVal(cpu.cpu_percent, graph_field), graph_symbol, invert, true }; #ifdef GPU_SUPPORT } #endif }; init_graphs(graphs_upper, graph_up_height, graph_up_width, graph_up_field, false); if (not single_graph) init_graphs(graphs_lower, graph_low_height, graph_low_width, graph_lo_field, Config::getB("cpu_invert_lower")); #ifdef GPU_SUPPORT if (show_gpu and b_columns > 1) { gpu_temp_graphs.resize(gpus.size()); gpu_mem_graphs.resize(gpus.size()); gpu_meters.resize(gpus.size()); // Shrink gpu graph width in small boxes to prevent line width extending past box border auto gpu_graph_width = b_width < 42 ? 4 : 5; for (size_t i = 0; i < gpus.size(); i++) { if (gpu_auto and v_contains(Gpu::shown_panels, i)) continue; auto& gpu = gpus[i]; //? GPU graphs/meters auto width_left = b_width - 10 - (gpus.size() > 9 ? 2 : gpus.size() > 1 ? 1 : 0); if (gpu.supported_functions.temp_info and show_temps) { gpu_temp_graphs[i] = Draw::Graph{ gpu_graph_width, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23 }; width_left -= 11; } if (gpu.supported_functions.mem_used and gpu.supported_functions.mem_total and b_columns > 1) { gpu_mem_graphs[i] = Draw::Graph{ gpu_graph_width, 1, "used", safeVal(gpu.gpu_percent, "gpu-vram-totals"s), graph_symbol }; width_left -= 5; } width_left -= (gpu.supported_functions.mem_used ? 5 : 0); width_left -= (gpu.supported_functions.mem_total ? 6 : 0); width_left -= (gpu.supported_functions.pwr_usage ? 6 : 0); if (gpu.supported_functions.gpu_utilization) { gpu_meters[i] = Draw::Meter{width_left, "cpu" }; } } } #endif int cpu_meter_width = b_width - (show_temps ? 23 - (b_column_size <= 1 and b_columns == 1 ? 6 : 0) : 11); if (show_watts) { cpu_meter_width -= 6; } cpu_meter = Draw::Meter{cpu_meter_width, "cpu"}; if (mid_line) { out += Mv::to(y + graph_up_height + 1, x) + Fx::ub + Theme::c("cpu_box") + Symbols::div_left + Theme::c("div_line") + Symbols::h_line * (width - b_width - 2) + Symbols::div_right + Mv::to(y + graph_up_height + 1, x + ((width - b_width) / 2) - ((graph_up_field.size() + graph_lo_field.size()) / 2) - 4) + Theme::c("main_fg") + graph_up_field + Mv::r(1) + "โ–ฒโ–ผ" + Mv::r(1) + graph_lo_field; } if (b_column_size > 0 or extra_width > 0) { core_graphs.clear(); for (const auto& core_data : cpu.core_percent) { core_graphs.emplace_back(5 * b_column_size + extra_width, 1, "cpu", core_data, graph_symbol); } } if (show_temps) { temp_graphs.clear(); temp_graphs.emplace_back(5, 1, "temp", safeVal(cpu.temp, 0), graph_symbol, false, false, safe_cpu_temp_max, -23); if (not hide_cores and b_column_size > 1) { for (const auto& i : iota((size_t)1, cpu.temp.size())) { temp_graphs.emplace_back(5, 1, "temp", safeVal(cpu.temp, i), graph_symbol, false, false, safe_cpu_temp_max, -23); } } } } //? Draw battery if enabled and present if (Config::getB("show_battery") and has_battery) { static int old_percent{}; // defaults to = 0 static long old_seconds{}; // defaults to = 0 static float old_watts{}; // defaults to = 0 static string old_status; static Draw::Meter bat_meter {10, "cpu", true}; static const std::unordered_map bat_symbols = { {"charging", "โ–ฒ"}, {"discharging", "โ–ผ"}, {"full", "โ– "}, {"unknown", "โ—‹"} }; const auto& [percent, watts, seconds, status] = current_bat; if (redraw or percent != old_percent or (watts != old_watts and Config::getB("show_battery_watts")) or seconds != old_seconds or status != old_status) { old_percent = percent; old_watts = watts; old_seconds = seconds; old_status = status; const string str_time = (seconds > 0 ? sec_to_dhms(seconds, false, true) : ""); const string str_percent = to_string(percent) + '%'; const string str_watts = (watts != -1 and Config::getB("show_battery_watts") ? fmt::format("{:.2f}", watts) + 'W' : ""); const auto& bat_symbol = bat_symbols.at((bat_symbols.contains(status) ? status : "unknown")); const int current_len = (Term::width >= 100 ? 11 : 0) + str_time.size() + str_percent.size() + str_watts.size() + to_string(Config::getI("update_ms")).size(); const int current_pos = Term::width - current_len - 17; if ((bat_pos != current_pos or bat_len != current_len) and bat_pos > 0 and not redraw) out += Mv::to(y, bat_pos) + Fx::ub + Theme::c("cpu_box") + Symbols::h_line * (bat_len + 4); bat_pos = current_pos; bat_len = current_len; out += Mv::to(y, bat_pos) + title_left + Theme::c("title") + Fx::b + "BAT" + bat_symbol + ' ' + str_percent + (Term::width >= 100 ? Fx::ub + ' ' + bat_meter(percent) + Fx::b : "") + (not str_time.empty() ? ' ' + Theme::c("title") + str_time : "") + (not str_watts.empty() ? " " + Theme::c("title") + Fx::b + str_watts : "") + Fx::ub + title_right; } } else if (bat_pos > 0) { out += Mv::to(y, bat_pos) + Fx::ub + Theme::c("cpu_box") + Symbols::h_line * (bat_len + 4); bat_pos = bat_len = 0; } try { //? Cpu/Gpu graphs out += Fx::ub + Mv::to(y + 1, x + 1); auto draw_graphs = [&](vector& graphs, const int graph_height, const int graph_width, const string& graph_field) { #ifdef GPU_SUPPORT if (graph_field.starts_with("gpu")) if (graph_field.ends_with("totals")) { int gpu_drawn = 0; for (size_t i = 0; i < gpus.size(); i++) { if (gpu_auto and v_contains(Gpu::shown_panels, i)) { continue; } try { const auto& gpu_percent = gpus[i].gpu_percent; out += graphs[i](safeVal(gpu_percent, graph_field), (data_same or redraw)); } catch (std::out_of_range& /* unused */) { continue; } if (Gpu::count - (gpu_auto ? Gpu::shown : 0) > 1) { auto i_str = to_string(i); out += Mv::l(max(0, graph_width-1)) + Mv::u(graph_height/2) + (graph_width > 5 ? "GPU" : "") + i_str + Mv::d(graph_height/2) + Mv::r(max(0, (int)(graph_width - 1 - (graph_width > 5)*3 - i_str.size()))); } if (++gpu_drawn < Gpu::count - (gpu_auto ? Gpu::shown : 0)) out += Theme::c("div_line") + (Symbols::v_line + Mv::l(1) + Mv::u(1))*graph_height + Mv::r(1) + Mv::d(1); } } else out += graphs[0](safeVal(Gpu::shared_gpu_percent, graph_field), (data_same or redraw)); else #else (void)graph_height; (void)graph_width; #endif out += graphs[0](safeVal(cpu.cpu_percent, graph_field), (data_same or redraw)); }; draw_graphs(graphs_upper, graph_up_height, graph_up_width, graph_up_field); if (not single_graph) { out += Mv::to(y + graph_up_height + 1 + mid_line, x + 1); draw_graphs(graphs_lower, graph_low_height, graph_low_width, graph_lo_field); } //? Uptime if (Config::getB("show_uptime")) { string upstr = sec_to_dhms(system_uptime()); if (upstr.size() > 8) { upstr.resize(upstr.size() - 3); upstr = trans(upstr); } out += Mv::to(y + (single_graph or not Config::getB("cpu_invert_lower") ? 1 : height - 2), x + 2) + Theme::c("graph_text") + "up" + Mv::r(1) + upstr; } #ifdef __linux__ const bool freq_range = Config::getS("freq_mode") == "range"; #else const bool freq_range = false; #endif //? Cpu clock and cpu meter if (Config::getB("show_cpu_freq") and not cpuHz.empty()) out += Mv::to(b_y, b_x + b_width - (freq_range ? 20 : 10)) + Fx::ub + Theme::c("div_line") + Symbols::h_line * ((freq_range ? 17 : 7) - cpuHz.size()) + Symbols::title_left + Fx::b + Theme::c("title") + cpuHz + Fx::ub + Theme::c("div_line") + Symbols::title_right; out += Mv::to(b_y + 1, b_x + 1) + Theme::c("main_fg") + Fx::b + "CPU " + cpu_meter(safeVal(cpu.cpu_percent, "total"s).back()) + Theme::g("cpu").at(clamp(safeVal(cpu.cpu_percent, "total"s).back(), 0ll, 100ll)) + rjust(to_string(safeVal(cpu.cpu_percent, "total"s).back()), 4) + Theme::c("main_fg") + '%'; if (show_temps) { const auto [temp, unit] = celsius_to(safeVal(cpu.temp, 0).back(), temp_scale); const auto temp_color = Theme::g("temp").at(clamp(safeVal(cpu.temp, 0).back() * 100 / safe_cpu_temp_max, 0ll, 100ll)); if ((b_column_size > 1 or b_columns > 1) and temp_graphs.size() >= 1ll) out += ' ' + Theme::c("inactive_fg") + graph_bg * 5 + Mv::l(5) + temp_color + temp_graphs.at(0)(safeVal(cpu.temp, 0), data_same or redraw); out += temp_color + rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; } if (show_watts) { const auto clamped_watts = clamp(cpu.usage_watts, 0.0f, 999.0f); string cwatts = fmt::format(" {:>4.{}f}", clamped_watts, clamped_watts < 9.995f ? 2 : clamped_watts < 99.95f ? 1 : 0); string cwatts_post = "W"; max_observed_pwr = max(max_observed_pwr, clamped_watts); out += Theme::g("cached").at(clamp(clamped_watts / max_observed_pwr * 100.0f, 0.0f, 100.0f)) + cwatts + Theme::c("main_fg") + cwatts_post; } out += Theme::c("div_line") + Symbols::v_line; } catch (const std::exception& e) { throw std::runtime_error("graphs, clock, meter : " + string{e.what()}); } int max_row = b_height - 3; // Subtracting one extra row for the load average (and power if enabled) int n_gpus_to_show = 0; #ifdef GPU_SUPPORT n_gpus_to_show = show_gpu ? (gpus.size() - (gpu_always ? 0 : Gpu::shown)) : 0; #endif max_row -= n_gpus_to_show; auto is_cpu_enabled = [&cpu](const std::int32_t num) -> bool { return !cpu.active_cpus.has_value() || std::ranges::find(cpu.active_cpus.value(), num) != cpu.active_cpus.value().end(); }; //? Core text and graphs int cx = 0, cy = 1, cc = 0, core_width = (b_column_size == 0 ? 2 : 3); if (Shared::coreCount >= 100) core_width++; for (const auto& n : iota(0, Shared::coreCount)) { auto enabled = is_cpu_enabled(n); out += Mv::to(b_y + cy + 1, b_x + cx + 1) + Theme::c(enabled ? "main_fg" : "inactive_fg") + (Shared::coreCount < 100 ? Fx::b + 'C' + Fx::ub : "") + ljust(to_string(n), core_width); if ((b_column_size > 0 or extra_width > 0) and cmp_less(n, core_graphs.size())) out += Theme::c("inactive_fg") + graph_bg * (5 * b_column_size + extra_width) + Mv::l(5 * b_column_size + extra_width) + core_graphs.at(n)(safeVal(cpu.core_percent, n), data_same or redraw); out += enabled ? Theme::g("cpu").at(clamp(safeVal(cpu.core_percent, n).back(), 0ll, 100ll)) : Theme::c("inactive_fg"); out += rjust(to_string(safeVal(cpu.core_percent, n).back()), (b_column_size < 2 ? 3 : 4)) + Theme::c(enabled ? "main_fg" : "inactive_fg") + '%'; if (show_temps and not hide_cores) { const auto core_temps = safeVal(cpu.temp, n + 1); if (!core_temps.empty()) { // FIXME: This should be checked during collection and just not be made available with // something like `std::nullopt`. const auto last_temp = core_temps.back(); const auto [temp, unit] = celsius_to(last_temp, temp_scale); const auto temp_color = enabled ? Theme::g("temp").at(clamp(last_temp * 100 / safe_cpu_temp_max, 0ll, 100ll)) : Theme::c("inactive_fg"); if (b_column_size > 1 and std::cmp_greater_equal(temp_graphs.size(), n)) { fmt::format_to( std::back_inserter(out), " {}{}{}{}", Theme::c("inactive_fg"), graph_bg * 5, Mv::l(5), temp_graphs.at(n + 1)(core_temps, data_same || redraw) ); } fmt::format_to( std::back_inserter(out), "{}{}{}{}", temp_color, rjust(std::to_string(temp), 4), Theme::c(enabled ? "main_fg" : "inactive_fg"), unit ); } } out += Theme::c("div_line") + Symbols::v_line; if ((++cy > ceil((double)Shared::coreCount / b_columns) or cy == max_row) and n != Shared::coreCount - 1) { if (++cc >= b_columns) break; cy = 1; cx = (b_width / b_columns) * cc; } } //? Load average if (cy < b_height - 1 and cc <= b_columns) { cy = b_height - 2 - n_gpus_to_show; string load_avg_pre = "Load avg:"; string load_avg; for (const auto& val : cpu.load_avg) { load_avg += fmt::format(" {:.2f}", val); } int len = load_avg_pre.size() + load_avg.size(); out += Mv::to(b_y + cy, b_x + 1) + string(max(b_width - len - 2, 0), ' ') + Theme::c("main_fg") + Fx::b + load_avg_pre + Fx::ub + load_avg; } #ifdef GPU_SUPPORT //? Gpu brief info if (show_gpu) { for (unsigned long i = 0; i < gpus.size(); ++i) { if (gpu_auto and v_contains(Gpu::shown_panels, i)) continue; out += Mv::to(b_y + ++cy, b_x + 1) + Theme::c("main_fg") + Fx::b + "GPU"; if (gpus.size() > 1) out += rjust(to_string(i), 1 + (gpus.size() > 9)); if (gpus[i].supported_functions.gpu_utilization) { out += ' '; if (b_columns > 1) { out += gpu_meters[i](safeVal(gpus[i].gpu_percent, "gpu-totals"s).back()) + Theme::g("cpu").at(clamp(safeVal(gpus[i].gpu_percent, "gpu-totals"s).back(), 0ll, 100ll)); } out += rjust(to_string(safeVal(gpus[i].gpu_percent, "gpu-totals"s).back()), 3) + Theme::c("main_fg") + '%'; if (b_columns == 1) out += ' '; } if (gpus[i].supported_functions.mem_used and gpus[i].supported_functions.mem_total and b_columns > 1) { out += ' ' + Theme::c("inactive_fg") + graph_bg * 5 + Mv::l(5) + Theme::g("used").at(safeVal(gpus[i].gpu_percent, "gpu-vram-totals"s).back()) + gpu_mem_graphs[i](safeVal(gpus[i].gpu_percent, "gpu-vram-totals"s), data_same or redraw); } if (gpus[i].supported_functions.mem_used) { out += Theme::c("main_fg") + rjust(floating_humanizer(gpus[i].mem_used, true), 5); } if (gpus[i].supported_functions.mem_total) { out += Theme::c("inactive_fg") + '/' + Theme::c("main_fg") + ljust(floating_humanizer(gpus[i].mem_total, true), 4); } if (show_temps and gpus[i].supported_functions.temp_info) { const auto [temp, unit] = celsius_to(gpus[i].temp.back(), temp_scale); out += ' '; if (b_columns > 1) out += Theme::c("inactive_fg") + graph_bg * 5 + Mv::l(5) + Theme::g("temp").at(clamp(gpus[i].temp.back() * 100 / gpus[i].temp_max, 0ll, 100ll)) + gpu_temp_graphs[i](gpus[i].temp, data_same or redraw); else out += Theme::g("temp").at(clamp(gpus[i].temp.back() * 100 / gpus[i].temp_max, 0ll, 100ll)); out += rjust(to_string(temp), 3) + Theme::c("main_fg") + unit; } if (gpus[i].supported_functions.pwr_usage) { out += ' ' + Theme::g("cached").at(clamp(safeVal(gpus[i].gpu_percent, "gpu-pwr-totals"s).back(), 0ll, 100ll)) + fmt::format("{:>4.{}f}", gpus[i].pwr_usage / 1000.0, gpus[i].pwr_usage < 10'000 ? 2 : gpus[i].pwr_usage < 100'000 ? 1 : 0) + Theme::c("main_fg") + 'W'; } if (cy > b_height - 1) break; } } #endif redraw = false; return out + Fx::reset; } } #ifdef GPU_SUPPORT namespace Gpu { int width_p = 100, height_p = 32; int min_width = 41, min_height = 8; int width = 41, total_height; vector x_vec = {}, y_vec = {}, b_height_vec = {}; int b_width; vector b_x_vec = {}, b_y_vec = {}; vector redraw = {}; int shown = 0; int count = 0; vector shown_panels = {}; int graph_up_height; vector graph_upper_vec = {}, graph_lower_vec = {}; vector temp_graph_vec = {}; vector mem_used_graph_vec = {}, mem_util_graph_vec = {}; vector gpu_meter_vec = {}; vector pwr_meter_vec = {}; vector enc_meter_vec = {}; vector box = {}; string draw(const gpu_info& gpu, unsigned long index, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; auto& b_x = b_x_vec[index]; auto& b_y = b_y_vec[index]; auto& x = x_vec[index]; auto& y = y_vec[index]; auto& graph_upper = graph_upper_vec[index]; auto& graph_lower = graph_lower_vec[index]; auto& temp_graph = temp_graph_vec[index]; auto& mem_used_graph = mem_used_graph_vec[index]; auto& mem_util_graph = mem_util_graph_vec[index]; auto& gpu_meter = gpu_meter_vec[index]; auto& pwr_meter = pwr_meter_vec[index]; auto& enc_meter = enc_meter_vec[index]; if (force_redraw) redraw[index] = true; bool show_temps = gpu.supported_functions.temp_info and (Config::getB("check_temp")); auto tty_mode = Config::getB("tty_mode"); auto& temp_scale = Config::getS("temp_scale"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_gpu")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); auto single_graph = !Config::getB("gpu_mirror_graph"); string out; int height = gpu_b_height_offsets[index] + 4; out.reserve(width * height); //* Redraw elements not needed to be updated every cycle if (redraw[index]) { out += box[index]; graph_up_height = single_graph ? b_height_vec[index] : (b_height_vec[index] + 1) / 2; int graph_low_height = single_graph ? 0 : b_height_vec[index] - graph_up_height; if (gpu.supported_functions.gpu_utilization) { graph_upper = Draw::Graph{x + width - b_width - 3, graph_up_height, "cpu", safeVal(gpu.gpu_percent, "gpu-totals"s), graph_symbol, false, true}; // TODO cpu -> gpu if (not single_graph) { graph_lower = Draw::Graph{ x + width - b_width - 3, graph_low_height, "cpu", safeVal(gpu.gpu_percent, "gpu-totals"s), graph_symbol, Config::getB("cpu_invert_lower"), true }; } gpu_meter = Draw::Meter{b_width - (show_temps ? 25 : 12), "cpu"}; } if (gpu.supported_functions.temp_info) temp_graph = Draw::Graph{6, 1, "temp", gpu.temp, graph_symbol, false, false, gpu.temp_max, -23}; if (gpu.supported_functions.pwr_usage) pwr_meter = Draw::Meter{b_width - (gpu.supported_functions.pwr_state and gpu.pwr_state != 32 ? 25 : 12), "cached"}; if (gpu.supported_functions.mem_utilization) mem_util_graph = Draw::Graph{b_width/2 - 1, 2, "free", gpu.mem_utilization_percent, graph_symbol, 0, 0, 100, 4}; // offset so the graph isn't empty at 0-5% utilization if (gpu.supported_functions.mem_used and gpu.supported_functions.mem_total) mem_used_graph = Draw::Graph{b_width/2 - 2, 2 + 2*(gpu.supported_functions.mem_utilization), "used", safeVal(gpu.gpu_percent, "gpu-vram-totals"s), graph_symbol}; if (gpu.supported_functions.encoder_utilization) enc_meter = Draw::Meter{b_width/2 - 10, "cpu"}; } //* General GPU info int rows_used = 1; //? Gpu graph, meter & clock speed if (gpu.supported_functions.gpu_utilization) { out += Fx::ub + Mv::to(y + rows_used, x + 1) + graph_upper(safeVal(gpu.gpu_percent, "gpu-totals"s), (data_same or redraw[index])); if (not single_graph) out += Mv::to(y + rows_used + graph_up_height, x + 1) + graph_lower(safeVal(gpu.gpu_percent, "gpu-totals"s), (data_same or redraw[index])); out += Mv::to(b_y + rows_used, b_x + 1) + Theme::c("main_fg") + Fx::b + "GPU " + gpu_meter(safeVal(gpu.gpu_percent, "gpu-totals"s).back()) + Theme::g("cpu").at(clamp(safeVal(gpu.gpu_percent, "gpu-totals"s).back(), 0ll, 100ll)) + rjust(to_string(safeVal(gpu.gpu_percent, "gpu-totals"s).back()), 5) + Theme::c("main_fg") + '%'; //? Temperature graph, I assume the device supports utilization if it supports temperature if (show_temps) { const auto [temp, unit] = celsius_to(gpu.temp.back(), temp_scale); out += ' ' + Theme::c("inactive_fg") + graph_bg * 6 + Mv::l(6) + Theme::g("temp").at(clamp(gpu.temp.back() * 100 / gpu.temp_max, 0ll, 100ll)) + temp_graph(gpu.temp, data_same or redraw[index]); out += rjust(to_string(temp), 4) + Theme::c("main_fg") + unit; } out += Theme::c("div_line") + Symbols::v_line; rows_used++; } if (gpu.supported_functions.gpu_clock) { string clock_speed_string = to_string(gpu.gpu_clock_speed); out += Mv::to(b_y, b_x + b_width - 12) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " MHz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; } //? Power usage meter, power state if (gpu.supported_functions.pwr_usage) { out += Mv::to(b_y + rows_used, b_x + 1) + Theme::c("main_fg") + Fx::b + "PWR " + pwr_meter(safeVal(gpu.gpu_percent, "gpu-pwr-totals"s).back()) + Theme::g("cached").at(clamp(safeVal(gpu.gpu_percent, "gpu-pwr-totals"s).back(), 0ll, 100ll)) + fmt::format("{:>5.{}f}", gpu.pwr_usage / 1000.0, gpu.pwr_usage < 10'000 ? 2 : gpu.pwr_usage < 100'000 ? 1 : 0) + Theme::c("main_fg") + 'W'; if (gpu.supported_functions.pwr_state and gpu.pwr_state != 32) // NVML_PSTATE_UNKNOWN; unsupported or non-nvidia card out += std::string(" P-state: ") + (gpu.pwr_state > 9 ? "" : " ") + 'P' + Theme::g("cached").at(clamp(gpu.pwr_state, 0ll, 100ll)) + to_string(gpu.pwr_state); rows_used++; } //? Encode and Decode meters bool drawnEncDec = gpu.supported_functions.encoder_utilization and gpu.supported_functions.decoder_utilization; if (drawnEncDec) { out += Mv::to(b_y + rows_used, b_x +1) + Theme::c("main_fg") + Fx::b + "ENC " + enc_meter(gpu.encoder_utilization) + Theme::g("cpu").at(clamp(gpu.encoder_utilization, 0ll, 100ll)) + rjust(to_string(gpu.encoder_utilization), 4) + Theme::c("main_fg") + '%' + Theme::c("div_line") + Symbols::v_line + Theme::c("main_fg") + Fx::b + "DEC " + enc_meter(gpu.decoder_utilization) + Theme::g("cpu").at(clamp(gpu.decoder_utilization, 0ll, 100ll)) + rjust(to_string(gpu.decoder_utilization), 4) + Theme::c("main_fg") + '%'; rows_used++; } if (gpu.supported_functions.mem_total or gpu.supported_functions.mem_used) { out += Mv::to(b_y + rows_used, b_x); if (gpu.supported_functions.mem_total and gpu.supported_functions.mem_used) { string used_memory_string = floating_humanizer(gpu.mem_used); auto offset = (gpu.supported_functions.mem_total or gpu.supported_functions.mem_used) * (1 + 2*(gpu.supported_functions.mem_total and gpu.supported_functions.mem_used) + 2*gpu.supported_functions.mem_utilization); //? Used graph, memory section header, total vram out += Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Fx::b + Theme::c("title") + "vram" + Theme::c("div_line") + Fx::ub + Symbols::title_right + Symbols::h_line*(b_width/2-8) + Symbols::div_up + Mv::d(offset)+Mv::l(1) + Symbols::div_down + Mv::l(1)+Mv::u(1) + (Symbols::v_line + Mv::l(1)+Mv::u(1))*(offset-1) + Symbols::div_up + Symbols::h_line + Theme::c("title") + "Used:" + Theme::c("div_line") + Symbols::h_line*(b_width/2+b_width%2-9-used_memory_string.size()) + Theme::c("title") + used_memory_string + Theme::c("div_line") + Symbols::h_line + Symbols::div_right + Mv::d(1) + Mv::l(b_width/2-1) + mem_used_graph(safeVal(gpu.gpu_percent, "gpu-vram-totals"s), (data_same or redraw[index])) + Mv::l(b_width-3) + Mv::u(1+2*gpu.supported_functions.mem_utilization) + Theme::c("main_fg") + Fx::b + "Total:" + rjust(floating_humanizer(gpu.mem_total), b_width/2-9) + Fx::ub + Mv::r(3) + rjust(to_string(safeVal(gpu.gpu_percent, "gpu-vram-totals"s).back()), 3) + '%'; //? Memory utilization if (gpu.supported_functions.mem_utilization) out += Mv::l(b_width/2+6) + Mv::d(1) + Theme::c("div_line") + Symbols::div_left+Symbols::h_line + Theme::c("title") + "Utilization:" + Theme::c("div_line") + Symbols::h_line*(b_width/2-14) + Symbols::div_right + Mv::l(b_width/2) + Mv::d(1) + mem_util_graph(gpu.mem_utilization_percent, (data_same or redraw[index])) + Mv::l(b_width/2-1) + Mv::u(1) + rjust(to_string(gpu.mem_utilization_percent.back()), 3) + '%'; //? Memory clock speed if (gpu.supported_functions.mem_clock) { string clock_speed_string = to_string(gpu.mem_clock_speed); out += Mv::to(b_y + rows_used, b_x + b_width/2 - 11) + Theme::c("div_line") + Symbols::h_line*(5-clock_speed_string.size()) + Symbols::title_left + Fx::b + Theme::c("title") + clock_speed_string + " MHz" + Fx::ub + Theme::c("div_line") + Symbols::title_right; } } else { out += Theme::c("main_fg") + Mv::r(1); if (gpu.supported_functions.mem_total) out += "VRAM total:" + rjust(floating_humanizer(gpu.mem_total), b_width/(1 + gpu.supported_functions.mem_clock)-14); else out += "VRAM usage:" + rjust(floating_humanizer(gpu.mem_used), b_width/(1 + gpu.supported_functions.mem_clock)-14); if (gpu.supported_functions.mem_clock) out += " VRAM clock:" + rjust(to_string(gpu.mem_clock_speed) + " MHz", b_width/2-13); } } //? Processes section header //out += Mv::to(b_y+8, b_x) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line + Symbols::title_left + Theme::c("main_fg") + Fx::b + "gpu-proc" + Fx::ub + Theme::c("div_line") // + Symbols::title_right + Symbols::h_line*(b_width/2-12) + Symbols::div_down + Symbols::h_line*(b_width/2-2) + Symbols::div_right; //? PCIe link throughput // Negative RX/TX means that they are manually disabled, not that they are unsupported if (gpu.supported_functions.pcie_txrx and not (gpu.pcie_rx < 0 or gpu.pcie_tx < 0)) { string tx_string = floating_humanizer(gpu.pcie_tx, 0, 1, 0, 1); string rx_string = floating_humanizer(gpu.pcie_rx, 0, 1, 0, 1); out += Mv::to(b_y + height - 3, b_x+2) + Theme::c("div_line") + Symbols::title_left_down + Theme::c("title") + Fx::b + "TX:" + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*(b_width/2-9-tx_string.size()) + Symbols::title_left_down + Theme::c("title") + Fx::b + tx_string + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + (gpu.supported_functions.mem_total and gpu.supported_functions.mem_used ? Symbols::div_down : Symbols::h_line) + Symbols::title_left_down + Theme::c("title") + Fx::b + "RX:" + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::h_line*(b_width/2+b_width%2-9-rx_string.size()) + Symbols::title_left_down + Theme::c("title") + Fx::b + rx_string + Fx::ub + Theme::c("div_line") + Symbols::title_right_down + Symbols::round_right_down; } redraw[index] = false; return out + Fx::reset; } } #endif namespace Mem { int width_p = 45, height_p = 40; int min_width = 36, min_height = 10; int x = 1, y, width = 20, height; int mem_width, disks_width, divider, item_height, mem_size, mem_meter, graph_height, disk_meter; int disks_io_h = 0; int disks_io_half = 0; bool shown = true, redraw = true; string box; std::unordered_map mem_meters; std::unordered_map mem_graphs; std::unordered_map disk_meters_used; std::unordered_map disk_meters_free; std::unordered_map io_graphs; string draw(const mem_info& mem, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; auto show_swap = Config::getB("show_swap"); auto swap_disk = Config::getB("swap_disk"); auto show_disks = Config::getB("show_disks"); auto show_io_stat = Config::getB("show_io_stat"); auto io_mode = Config::getB("io_mode"); auto io_graph_combined = Config::getB("io_graph_combined"); auto use_graphs = Config::getB("mem_graphs"); auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_mem")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); auto totalMem = Mem::get_totalMem(); string out; out.reserve(height * width); //* Redraw elements not needed to be updated every cycle if (redraw) { out += box; mem_meters.clear(); mem_graphs.clear(); disk_meters_free.clear(); disk_meters_used.clear(); io_graphs.clear(); //? Mem graphs and meters for (const auto& name : mem_names) { if (use_graphs) mem_graphs[name] = Draw::Graph{mem_meter, graph_height, name, safeVal(mem.percent, name), graph_symbol}; else mem_meters[name] = Draw::Meter{mem_meter, name}; } if (show_swap and has_swap) { for (const auto& name : swap_names) { if (use_graphs) mem_graphs[name] = Draw::Graph{mem_meter, graph_height, name.substr(5), safeVal(mem.percent, name), graph_symbol}; else mem_meters[name] = Draw::Meter{mem_meter, name.substr(5)}; } } //? Disk meters and io graphs if (show_disks) { if (show_io_stat or io_mode) { std::unordered_map custom_speeds; int half_height = 0; if (io_mode) { disks_io_h = max((int)floor((double)(height - 2 - (disk_ios * 2)) / max(1, disk_ios)), (io_graph_combined ? 1 : 2)); half_height = ceil((double)disks_io_h / 2); if (not Config::getS("io_graph_speeds").empty()) { auto split = ssplit(Config::getS("io_graph_speeds")); for (const auto& entry : split) { auto vals = ssplit(entry, ':'); if (vals.size() == 2 and mem.disks.contains(vals.at(0)) and isint(vals.at(1))) try { custom_speeds[vals.at(0)] = std::stoi(vals.at(1)); } catch (const std::out_of_range&) { continue; } } } } for (const auto& [name, disk] : mem.disks) { if (disk.io_read.empty()) continue; io_graphs[name + "_activity"] = Draw::Graph{disks_width - 6, 1, "available", disk.io_activity, graph_symbol}; if (io_mode) { //? Create one combined graph for IO read/write if enabled long long speed = (custom_speeds.contains(name) ? custom_speeds.at(name) : 100) << 20; if (io_graph_combined) { deque combined(disk.io_read.size(), 0); rng::transform(disk.io_read, disk.io_write, combined.begin(), std::plus()); io_graphs[name] = Draw::Graph{ disks_width, disks_io_h, "available", combined, graph_symbol, false, true, speed}; } else { io_graphs[name + "_read"] = Draw::Graph{ disks_width, half_height, "free", disk.io_read, graph_symbol, false, true, speed}; io_graphs[name + "_write"] = Draw::Graph{ disks_width, disks_io_h - half_height, "used", disk.io_write, graph_symbol, true, true, speed}; } } } } for (int i = 0; const auto& [name, ignored] : mem.disks) { if (i * 2 > height - 2) break; disk_meters_used[name] = Draw::Meter{disk_meter, "used"}; if (cmp_less_equal(mem.disks.size() * 3, height - 1)) disk_meters_free[name] = Draw::Meter{disk_meter, "free"}; } out += Mv::to(y, x + width - 6) + Fx::ub + Theme::c("mem_box") + Symbols::title_left + (io_mode ? Fx::b : "") + Theme::c("hi_fg") + 'i' + Theme::c("title") + 'o' + Fx::ub + Theme::c("mem_box") + Symbols::title_right; Input::mouse_mappings["i"] = {y, x + width - 5, 1, 2}; } } //? Mem and swap int cx = 1, cy = 1; string divider = (graph_height > 0 ? Mv::l(2) + Theme::c("mem_box") + Symbols::div_left + Theme::c("div_line") + Symbols::h_line * (mem_width - 1) + (show_disks ? "" : Theme::c("mem_box")) + Symbols::div_right + Mv::l(mem_width - 1) + Theme::c("main_fg") : ""); string up = (graph_height >= 2 ? Mv::l(mem_width - 2) + Mv::u(graph_height - 1) : ""); bool big_mem = mem_width > 21; out += Mv::to(y + 1, x + 2) + Theme::c("title") + Fx::b + "Total:" + rjust(floating_humanizer(totalMem), mem_width - 9) + Fx::ub + Theme::c("main_fg"); vector comb_names (mem_names.begin(), mem_names.end()); if (show_swap and has_swap and not swap_disk) comb_names.insert(comb_names.end(), swap_names.begin(), swap_names.end()); for (const auto& name : comb_names) { if (cy > height - 4) break; string title; if (name == "swap_used") { if (cy > height - 5) break; if (height - cy > 6) { if (graph_height > 0) out += Mv::to(y+1+cy, x+1+cx) + divider; cy += 1; } out += Mv::to(y+1+cy, x+1+cx) + Theme::c("title") + Fx::b + "Swap:" + rjust(floating_humanizer(safeVal(mem.stats, "swap_total"s)), mem_width - 8) + Theme::c("main_fg") + Fx::ub; cy += 1; title = "Used"; } else if (name == "swap_free") title = "Free"; if (title.empty()) title = capitalize(name); const string humanized = floating_humanizer(safeVal(mem.stats, name)); const int offset = max(0, divider.empty() ? 9 - (int)humanized.size() : 0); const string graphics = ( use_graphs and mem_graphs.contains(name) ? mem_graphs.at(name)(safeVal(mem.percent, name), redraw or data_same) : mem_meters.contains(name) ? mem_meters.at(name)(safeVal(mem.percent, name).back()) : ""); if (mem_size > 2) { out += Mv::to(y+1+cy, x+1+cx) + divider + title.substr(0, big_mem ? 10 : 5) + ":" + Mv::to(y+1+cy, x+cx + mem_width - 2 - humanized.size()) + (divider.empty() ? Mv::l(offset) + string(" ") * offset + humanized : trans(humanized)) + Mv::to(y+2+cy, x+cx + (graph_height >= 2 ? 0 : 1)) + graphics + up + rjust(to_string(safeVal(mem.percent, name).back()) + "%", 4); cy += (graph_height == 0 ? 2 : graph_height + 1); } else { out += Mv::to(y+1+cy, x+1+cx) + ljust(title, (mem_size > 1 ? 5 : 1)) + (graph_height >= 2 ? "" : " ") + graphics + Theme::c("title") + rjust(humanized, (mem_size > 1 ? 9 : 7)); cy += (graph_height == 0 ? 1 : graph_height); } } if (graph_height > 0 and cy < height - 2) out += Mv::to(y+1+cy, x+1+cx) + divider; //? Disks if (show_disks) { const auto& disks = mem.disks; cx = mem_width; cy = 0; bool big_disk = disks_width >= 25; divider = Mv::l(1) + Theme::c("div_line") + Symbols::div_left + Symbols::h_line * disks_width + Theme::c("mem_box") + Fx::ub + Symbols::div_right + Mv::l(disks_width); const string hu_div = Theme::c("div_line") + Symbols::h_line + Theme::c("main_fg"); if (io_mode) { for (const auto& mount : mem.disks_order) { if (not disks.contains(mount)) continue; if (cy > height - 3) break; const auto disk = safeVal(disks, mount); if (disk.io_read.empty()) continue; const string total = floating_humanizer(disk.total, not big_disk); out += Mv::to(y+1+cy, x+1+cx) + divider + Theme::c("title") + Fx::b + uresize(disk.name, disks_width - 8) + Mv::to(y+1+cy, x+cx + disks_width - total.size()) + trans(total) + Fx::ub; if (big_disk) { const string used_percent = to_string(disk.used_percent); out += Mv::to(y+1+cy, x+1+cx + round((double)disks_width / 2) - round((double)used_percent.size() / 2) - 1) + hu_div + used_percent + '%' + hu_div; } if (io_graphs.contains(mount + "_activity")) { out += Mv::to(y+2+cy++, x+1+cx) + (big_disk ? " IO% " : " IO " + Mv::l(2)) + Theme::c("inactive_fg") + graph_bg * (disks_width - 6) + Mv::l(disks_width - 6) + io_graphs.at(mount + "_activity")(disk.io_activity, redraw or data_same) + Theme::c("main_fg"); } if (++cy > height - 3) break; if (io_graph_combined) { if (not io_graphs.contains(mount)) continue; auto comb_val = disk.io_read.back() + disk.io_write.back(); const string humanized = (disk.io_write.back() > 0 ? "โ–ผ"s : ""s) + (disk.io_read.back() > 0 ? "โ–ฒ"s : ""s) + (comb_val > 0 ? Mv::r(1) + floating_humanizer(comb_val, true) : "RW"); if (disks_io_h == 1) out += Mv::to(y+1+cy, x+1+cx) + string(5, ' '); out += Mv::to(y+1+cy, x+1+cx) + io_graphs.at(mount)({comb_val}, redraw or data_same) + Mv::to(y+1+cy, x+1+cx) + Theme::c("main_fg") + humanized; cy += disks_io_h; } else { if (not io_graphs.contains(mount + "_read") or not io_graphs.contains(mount + "_write")) continue; const string human_read = (disk.io_read.back() > 0 ? "โ–ฒ" + floating_humanizer(disk.io_read.back(), true) : "R"); const string human_write = (disk.io_write.back() > 0 ? "โ–ผ" + floating_humanizer(disk.io_write.back(), true) : "W"); if (disks_io_h <= 3) out += Mv::to(y+1+cy, x+1+cx) + string(5, ' ') + Mv::to(y+cy + disks_io_h, x+1+cx) + string(5, ' '); out += Mv::to(y+1+cy, x+1+cx) + io_graphs.at(mount + "_read")(disk.io_read, redraw or data_same) + Mv::l(disks_width) + Mv::d(1) + io_graphs.at(mount + "_write")(disk.io_write, redraw or data_same) + Mv::to(y+1+cy, x+1+cx) + human_read + Mv::to(y+cy + disks_io_h, x+1+cx) + human_write; cy += disks_io_h; } } } else { for (const auto& mount : mem.disks_order) { if (not disks.contains(mount)) continue; if (cy > height - 3) break; const auto disk = safeVal(disks, mount); if (disk.name.empty() or not disk_meters_used.contains(mount)) continue; auto comb_val = (not disk.io_read.empty() ? disk.io_read.back() + disk.io_write.back() : 0ll); const string human_io = (comb_val > 0 ? (disk.io_write.back() > 0 and big_disk ? "โ–ผ"s : ""s) + (disk.io_read.back() > 0 and big_disk ? "โ–ฒ"s : ""s) + floating_humanizer(comb_val, true) : ""); const string human_total = floating_humanizer(disk.total, not big_disk); const string human_used = floating_humanizer(disk.used, not big_disk); const string human_free = floating_humanizer(disk.free, not big_disk); out += Mv::to(y+1+cy, x+1+cx) + divider + Theme::c("title") + Fx::b + uresize(disk.name, disks_width - 8) + Mv::to(y+1+cy, x+cx + disks_width - human_total.size()) + trans(human_total) + Fx::ub + Theme::c("main_fg"); if (big_disk and not human_io.empty()) out += Mv::to(y+1+cy, x+1+cx + round((double)disks_width / 2) - round((double)human_io.size() / 2) - 1) + hu_div + human_io + hu_div; if (++cy > height - 3) break; if (show_io_stat and io_graphs.contains(mount + "_activity")) { out += Mv::to(y+1+cy, x+1+cx) + (big_disk ? " IO% " : " IO " + Mv::l(2)) + Theme::c("inactive_fg") + graph_bg * (disks_width - 6) + Theme::g("available").at(clamp(disk.io_activity.back(), 50ll, 100ll)) + Mv::l(disks_width - 6) + io_graphs.at(mount + "_activity")(disk.io_activity, redraw or data_same) + Theme::c("main_fg"); if (not big_disk) out += Mv::to(y+1+cy, x+cx+1) + Theme::c("main_fg") + human_io; if (++cy > height - 3) break; } out += Mv::to(y+1+cy, x+1+cx) + (big_disk ? " Used:" + rjust(to_string(disk.used_percent) + '%', 4) : "U") + ' ' + disk_meters_used.at(mount)(disk.used_percent) + rjust(human_used, (big_disk ? 9 : 5)); if (++cy > height - 3) break; if (disk_meters_free.contains(mount) and cmp_less_equal(disks.size() * 3 + (show_io_stat ? disk_ios : 0), height - 1)) { out += Mv::to(y+1+cy, x+1+cx) + (big_disk ? " Free:" + rjust(to_string(disk.free_percent) + '%', 4) : "F") + ' ' + disk_meters_free.at(mount)(disk.free_percent) + rjust(human_free, (big_disk ? 9 : 5)); cy++; if (cmp_less_equal(disks.size() * 4 + (show_io_stat ? disk_ios : 0), height - 1)) cy++; } } } if (cy < height - 2) out += Mv::to(y+1+cy, x+1+cx) + divider; } redraw = false; return out + Fx::reset; } } namespace Net { int width_p = 45, height_p = 28; int min_width = 36, min_height = 6; int x = 1, y, width = 20, height; int b_x, b_y, b_width, b_height, d_graph_height, u_graph_height; bool shown = true, redraw = true; const int MAX_IFNAMSIZ = 15; string old_ip; std::unordered_map graphs; string box; string draw(const net_info& net, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; if (force_redraw) redraw = true; auto net_sync = Config::getB("net_sync"); auto net_auto = Config::getB("net_auto"); auto tty_mode = Config::getB("tty_mode"); auto swap_upload_download = Config::getB("swap_upload_download"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_net")); string ip_addr = (net.ipv4.empty() ? net.ipv6 : net.ipv4); if (old_ip != ip_addr) { old_ip = ip_addr; redraw = true; } string out; out.reserve(width * height); const string title_left = Theme::c("net_box") + Fx::ub + Symbols::title_left; const string title_right = Theme::c("net_box") + Fx::ub + Symbols::title_right; const int i_size = min((int)selected_iface.size(), MAX_IFNAMSIZ); const long long down_max = (net_auto ? safeVal(graph_max, "download"s) : ((long long)(Config::getI("net_download")) << 20) / 8); const long long up_max = (net_auto ? safeVal(graph_max, "upload"s) : ((long long)(Config::getI("net_upload")) << 20) / 8); //* Redraw elements not needed to be updated every cycle if (redraw) { out = box; //? Graphs graphs.clear(); if (safeVal(net.bandwidth, "download"s).empty() or safeVal(net.bandwidth, "upload"s).empty()) return out + Fx::reset; graphs["download"] = Draw::Graph{ width - b_width - 2, u_graph_height, "download", net.bandwidth.at("download"), graph_symbol, swap_upload_download, true, down_max}; graphs["upload"] = Draw::Graph{ width - b_width - 2, d_graph_height, "upload", net.bandwidth.at("upload"), graph_symbol, !swap_upload_download, true, up_max}; //? Interface selector and buttons out += Mv::to(y, x+width - i_size - 9) + title_left + Fx::b + Theme::c("hi_fg") + Symbols::left + "b " + Theme::c("title") + uresize(selected_iface, MAX_IFNAMSIZ) + Theme::c("hi_fg") + " n" + Symbols::right + title_right + Mv::to(y, x+width - i_size - 15) + title_left + Theme::c("hi_fg") + (safeVal(net.stat, "download"s).offset + safeVal(net.stat, "upload"s).offset > 0 ? Fx::b : "") + 'z' + Theme::c("title") + "ero" + title_right; Input::mouse_mappings["b"] = {y, x+width - i_size - 8, 1, 3}; Input::mouse_mappings["n"] = {y, x+width - 6, 1, 3}; Input::mouse_mappings["z"] = {y, x+width - i_size - 14, 1, 4}; if (width - i_size - 20 > 6) { out += Mv::to(y, x+width - i_size - 21) + title_left + Theme::c("hi_fg") + (net_auto ? Fx::b : "") + 'a' + Theme::c("title") + "uto" + title_right; Input::mouse_mappings["a"] = {y, x+width - i_size - 20, 1, 4}; } if (width - i_size - 20 > 13) { out += Mv::to(y, x+width - i_size - 27) + title_left + Theme::c("title") + (net_sync ? Fx::b : "") + 's' + Theme::c("hi_fg") + 'y' + Theme::c("title") + "nc" + title_right; Input::mouse_mappings["y"] = {y, x+width - i_size - 26, 1, 4}; } } //? IP or device address if (not ip_addr.empty() and cmp_greater(width - i_size - 36, ip_addr.size())) { out += Mv::to(y, x + 8) + title_left + Theme::c("title") + Fx::b + ip_addr + title_right; } //? Graphs and stats for (const string dir : {"download", "upload"}) { // | upload | download | // no swap | bottom | top | // swap | top | bottom | // XNOR operation (==) if ((not swap_upload_download and dir == "download") or (swap_upload_download and dir == "upload")) { out += Mv::to(y+1, x + 1); } else { out += Mv::to(y + u_graph_height + 1 + ((height * swap_upload_download) % 2), x + 1); } out += graphs.at(dir)(safeVal(net.bandwidth, dir), redraw or data_same or not net.connected) + Mv::to(y+1 + (((dir == "upload") == (!swap_upload_download)) * (height - 3)), x + 1) + Fx::ub + Theme::c("graph_text") + floating_humanizer((dir == "upload" ? up_max : down_max), true); const string speed = floating_humanizer(safeVal(net.stat, dir).speed, false, 0, false, true); const string speed_bits = (b_width >= 20 ? floating_humanizer(safeVal(net.stat, dir).speed, false, 0, true, true) : ""); const string top = floating_humanizer(safeVal(net.stat, dir).top, false, 0, true, true); const string total = floating_humanizer(safeVal(net.stat, dir).total); const string symbol = (dir == "upload" ? "โ–ฒ" : "โ–ผ"); if ((swap_upload_download and dir == "upload") or (not swap_upload_download and dir == "download")) { // Top graph out += Mv::to(b_y+1, b_x+1) + Fx::ub + Theme::c("main_fg") + symbol + ' ' + ljust(speed, 10) + (b_width >= 20 ? rjust('(' + speed_bits + ')', 13) : ""); if (b_height >= 8) out += Mv::to(b_y+2, b_x+1) + symbol + ' ' + "Top: " + rjust('(' + top, (b_width >= 20 ? 17 : 9)) + ')'; if (b_height >= 6) out += Mv::to(b_y+2 + (b_height >= 8), b_x+1) + symbol + ' ' + "Total: " + rjust(total, (b_width >= 20 ? 16 : 8)); } else { // Bottom graph out += Mv::to(b_y + b_height - (b_height / 2), b_x + 1) + Fx::ub + Theme::c("main_fg") + symbol + ' ' + ljust(speed, 10) + (b_width >= 20 ? rjust('(' + speed_bits + ')', 13) : ""); if (b_height >= 8) out += Mv::to(b_y + b_height - (b_height / 2) + 1, b_x + 1) + symbol + ' ' + "Top: " + rjust('(' + top, (b_width >= 20 ? 17 : 9)) + ')'; if (b_height >= 6) out += Mv::to(b_y + b_height - (b_height / 2) + 1 + (b_height >= 8), b_x + 1) + symbol + ' ' + "Total: " + rjust(total, (b_width >= 20 ? 16 : 8)); } } redraw = false; return out + Fx::reset; } } namespace Proc { int width_p = 55, height_p = 68; int min_width = 44, min_height = 16; int x, y, width = 20, height; int start, selected, select_max; bool shown = true, redraw = true; bool is_last_process_in_list = false; int selected_pid = 0, selected_depth = 0; int scroll_pos; string selected_name; std::unordered_map p_graphs; std::unordered_map p_wide_cmd; std::unordered_map p_counters; int counter = 0; Draw::TextEdit filter; Draw::Graph detailed_cpu_graph; Draw::Graph detailed_mem_graph; int user_size, thread_size, prog_size, cmd_size, tree_size; int dgraph_x, dgraph_width, d_width, d_x, d_y; bool previous_proc_banner_state = false; atomic resized (false); string box; int selection(const std::string_view cmd_key) { auto start = Config::getI("proc_start"); auto selected = Config::getI("proc_selected"); auto last_selected = Config::getI("proc_last_selected"); bool changed = false; int select_max = (Config::getB("show_detailed") ? (Config::getB("proc_banner_shown") ? Proc::select_max - 9 : Proc::select_max - 8) : (Config::getB("proc_banner_shown") ? Proc::select_max - 1 : Proc::select_max)); // Return the selection from the detailed view to the followed process before moving the selection // Disengage following mode when moving the selection unless paused if (Config::getB("follow_process")) { if (Config::getB("show_detailed") and selected == 0 and Config::getB("should_selection_return_to_followed") and Config::getI("detailed_pid") == Config::getI("followed_pid")) { selected = Config::getI("proc_followed"); Config::set("should_selection_return_to_followed", false); changed = true; } if (not Config::getB("pause_proc_list")) { Config::flip("follow_process"); Config::set("followed_pid", 0); Config::set("proc_followed", 0); select_max++; } redraw = true; } auto vim_keys = Config::getB("vim_keys"); int numpids = Proc::numpids; if ((cmd_key == "up" or (vim_keys and cmd_key == "k")) and selected > 0) { if (start > 0 and selected == 1) start--; else selected--; if (Config::getI("proc_last_selected") > 0) Config::set("proc_last_selected", 0); } else if (cmd_key == "mouse_scroll_up" and start > 0) { start = max(0, start - 3); } else if (cmd_key == "mouse_scroll_down" and start < numpids - select_max) { start = min(numpids - select_max, start + 3); } else if (cmd_key == "down" or (vim_keys and cmd_key == "j")) { if (start < numpids - select_max and selected == select_max) start++; else if (selected == 0 and last_selected > 0) { selected = last_selected; Config::set("proc_last_selected", 0); } else selected++; } else if (cmd_key == "page_up") { if (selected > 0 and start == 0) selected = 0; else start = max(0, start - select_max); } else if (cmd_key == "page_down") { if (selected > 0 and start >= numpids - select_max) selected = select_max; else start = clamp(start + select_max, 0, max(0, numpids - select_max)); } else if (cmd_key == "home" or (vim_keys and cmd_key == "g")) { start = 0; if (selected > 0) selected = 1; } else if (cmd_key == "end" or (vim_keys and cmd_key == "G")) { start = max(0, numpids - select_max); if (selected > 0) selected = select_max; } else if (cmd_key.starts_with("mousey")) { int mouse_y = std::atoi(cmd_key.substr(6).data()); start = clamp((int)round((double)mouse_y * (numpids - select_max - 2) / (select_max - 2)), 0, max(0, numpids - select_max)); } if (start != Config::getI("proc_start")) { Config::set("proc_start", start); changed = true; } if (selected != Config::getI("proc_selected")) { Config::set("proc_selected", selected); changed = true; } return (not changed ? -1 : selected); } string draw(const vector& plist, bool force_redraw, bool data_same) { if (Runner::stopping) return ""; auto proc_tree = Config::getB("proc_tree"); bool show_detailed = (Config::getB("show_detailed") and cmp_equal(Proc::detailed.last_pid, Config::getI("detailed_pid"))); bool proc_gradient = (Config::getB("proc_gradient") and not Config::getB("lowcolor") and Theme::gradients.contains("proc")); auto proc_colors = Config::getB("proc_colors"); auto tty_mode = Config::getB("tty_mode"); auto& graph_symbol = (tty_mode ? "tty" : Config::getS("graph_symbol_proc")); auto& graph_bg = Symbols::graph_symbols.at((graph_symbol == "default" ? Config::getS("graph_symbol") + "_up" : graph_symbol + "_up")).at(6); auto mem_bytes = Config::getB("proc_mem_bytes"); auto vim_keys = Config::getB("vim_keys"); auto show_graphs = Config::getB("proc_cpu_graphs"); const auto pause_proc_list = Config::getB("pause_proc_list"); auto follow_process = Config::getB("follow_process"); int followed_pid = Config::getI("followed_pid"); int followed = Config::getI("proc_followed"); bool should_selection_return_to_followed = Config::getB("should_selection_return_to_followed"); auto proc_banner_shown = pause_proc_list or follow_process; Config::set("proc_banner_shown", proc_banner_shown); start = Config::getI("proc_start"); selected = Config::getI("proc_selected"); const int y = show_detailed ? Proc::y + 8 : Proc::y; const int height = show_detailed ? Proc::height - 8 : Proc::height; int select_max = show_detailed ? (proc_banner_shown ? Proc::select_max - 9 : Proc::select_max - 8) : (proc_banner_shown ? Proc::select_max - 1 : Proc::select_max); auto totalMem = Mem::get_totalMem(); int numpids = Proc::numpids; if (force_redraw) redraw = true; string out; out.reserve(width * height); //? Move current selection/view to the selected process when a process should be followed //? Restore view and selection to the detailed view process when detailed view is closed const int restore_detailed_pid = Config::getI("restore_detailed_pid"); if ((follow_process and (not pause_proc_list or Config::getB("update_following"))) or restore_detailed_pid > 0) { Config::set("update_following", false); int loc = 1; bool can_follow = false; for (auto& p : plist) { if (p.filtered or (proc_tree and p.tree_index == plist.size())) continue; if (p.pid == (size_t)(restore_detailed_pid > 0 ? restore_detailed_pid : followed_pid)) { can_follow = true; break; } loc++; } if (can_follow) { const int list_middle = select_max % 2 == 0 ? select_max / 2 : select_max / 2 + 1; start = max(0, loc - list_middle); followed = loc < list_middle ? loc : start > numpids - select_max ? select_max - numpids + loc : list_middle; if (restore_detailed_pid == 0) { Config::set("proc_followed", followed); Config::set("should_selection_return_to_followed", should_selection_return_to_followed = true); } selected = (followed_pid != Config::getI("detailed_pid") or restore_detailed_pid > 0) ? followed : 0; } else if (restore_detailed_pid == 0) { Config::set("followed_pid", followed_pid = 0); Config::set("follow_process", follow_process = false); Config::set("proc_banner_shown", proc_banner_shown = pause_proc_list); Config::set("proc_followed", 0); if (not proc_banner_shown) select_max++; } if (restore_detailed_pid > 0) Config::set("restore_detailed_pid", 0); } //? Handle selection edge cases when list view is showing bottom of list //? for Pause and Following modes const bool proc_banner_changed = proc_banner_shown != previous_proc_banner_state; previous_proc_banner_state = proc_banner_shown; if (proc_banner_changed and not proc_banner_shown and start + select_max - 1 == numpids) selected++; else if (pause_proc_list and selected > select_max) start++; //? redraw if selection reaches or leaves the end of the list if (selected != Config::getI("proc_last_selected")) { if (selected >= select_max and start >= numpids - select_max) { redraw = true; is_last_process_in_list = true; } else if (is_last_process_in_list) { redraw = true; is_last_process_in_list = false; } } //* Redraw elements not needed to be updated every cycle if (redraw) { out = box; const string title_left = Theme::c("proc_box") + Symbols::title_left; const string title_right = Theme::c("proc_box") + Symbols::title_right; const string title_left_down = Theme::c("proc_box") + Symbols::title_left_down; const string title_right_down = Theme::c("proc_box") + Symbols::title_right_down; for (const auto& key : {"t", "K", "k", "s", "N", "F", "enter", "info_enter"}) if (Input::mouse_mappings.contains(key)) Input::mouse_mappings.erase(key); //? Adapt sizes of text fields user_size = (width < 75 ? 5 : 10); thread_size = (width < 75 ? - 1 : 4); prog_size = (width > 70 ? 16 : ( width > 55 ? 8 : width - user_size - thread_size - 33)); cmd_size = (width > 55 ? width - prog_size - user_size - thread_size - 33 : -1); tree_size = width - user_size - thread_size - 23; if (not show_graphs) { cmd_size += 5; tree_size += 5; } //? Detailed box if (show_detailed) { bool alive = detailed.status != "Dead"; dgraph_x = x; dgraph_width = max(width / 3, width - 121); d_width = width - dgraph_width - 1; d_x = x + dgraph_width + 1; d_y = Proc::y; //? Create cpu and mem graphs if process is alive if (alive or pause_proc_list) { detailed_cpu_graph = Draw::Graph{dgraph_width - 1, 7, "cpu", detailed.cpu_percent, graph_symbol, false, true}; detailed_mem_graph = Draw::Graph{d_width / 3, 1, "", detailed.mem_bytes, graph_symbol, false, false, detailed.first_mem}; } //? Draw structure of details box const string pid_str = to_string(detailed.entry.pid); out += Mv::to(y, x) + Theme::c("proc_box") + Symbols::div_left + Symbols::h_line + title_left + Theme::c("hi_fg") + Fx::b + (tty_mode ? "4" : Symbols::superscript.at(4)) + Theme::c("title") + "proc" + Fx::ub + title_right + Symbols::h_line * (width - 10) + Symbols::div_right + Mv::to(d_y, dgraph_x + 2) + title_left + Fx::b + Theme::c("title") + pid_str + Fx::ub + title_right + title_left + Fx::b + Theme::c("title") + uresize(detailed.entry.name, dgraph_width - pid_str.size() - 7, true) + Fx::ub + title_right; out += Mv::to(d_y, d_x - 1) + Theme::c("proc_box") + Symbols::div_up + Mv::to(y, d_x - 1) + Symbols::div_down + Theme::c("div_line"); for (const int& i : iota(1, 8)) out += Mv::to(d_y + i, d_x - 1) + Symbols::v_line; const string t_color = (not alive or selected > 0 ? Theme::c("inactive_fg") : Theme::c("title")); const string hi_color = (not alive or selected > 0 ? t_color : Theme::c("hi_fg")); int mouse_x = d_x + 2; out += Mv::to(d_y, d_x + 1); if (width > 55) { out += Fx::ub + title_left + hi_color + Fx::b + 't' + t_color + "erminate" + Fx::ub + title_right; if (alive and selected == 0) Input::mouse_mappings["t"] = {d_y, mouse_x, 1, 9}; mouse_x += 11; } out += title_left + hi_color + Fx::b + (vim_keys ? 'K' : 'k') + t_color + "ill" + Fx::ub + title_right + title_left + hi_color + Fx::b + 's' + t_color + "ignals" + Fx::ub + title_right + title_left + hi_color + Fx::b + 'N' + t_color + "ice" + Fx::ub + title_right; if (alive and selected == 0) { Input::mouse_mappings[vim_keys ? "K" : "k"] = {d_y, mouse_x, 1, 4}; mouse_x += 6; Input::mouse_mappings["s"] = {d_y, mouse_x, 1, 7}; mouse_x += 9; Input::mouse_mappings["N"] = {d_y, mouse_x, 1, 5}; mouse_x += 7; } if (width > 77) { fmt::format_to(std::back_inserter(out), "{}{}{}{}{}{}{}{}", title_left, follow_process ? Fx::b : "", hi_color, 'F', t_color, "ollow", Fx::ub, title_right); if (selected == 0) Input::mouse_mappings["F"] = {d_y, mouse_x, 1, 6}; } //? Labels const int item_fit = floor((double)(d_width - 2) / 10); const int item_width = floor((double)(d_width - 2) / min(item_fit, 8)); out += Mv::to(d_y + 1, d_x + 1) + Fx::b + Theme::c("title") + cjust("Status:", item_width) + cjust("Elapsed:", item_width); if (item_fit >= 3) out += cjust("IO/R:", item_width); if (item_fit >= 4) out += cjust("IO/W:", item_width); if (item_fit >= 5) out += cjust("Parent:", item_width); if (item_fit >= 6) out += cjust("User:", item_width); if (item_fit >= 7) out += cjust("Threads:", item_width); if (item_fit >= 8) out += cjust("Nice:", item_width); //? Command line for (int i = 0; const auto& l : {'C', 'M', 'D'}) out += Mv::to(d_y + 5 + i++, d_x + 1) + l; out += Theme::c("main_fg") + Fx::ub; const auto san_cmd = replace_ascii_control(detailed.entry.cmd); const int cmd_size = ulen(san_cmd, true); for (int num_lines = min(3, (int)ceil((double)cmd_size / (d_width - 5))), i = 0; i < num_lines; i++) { out += Mv::to(d_y + 5 + (num_lines == 1 ? 1 : i), d_x + 3) + cjust(luresize(san_cmd, cmd_size - (d_width - 5) * i, true), d_width - 5, true, true); } } //? Filter auto filtering = Config::getB("proc_filtering"); // ? filter(20) : Config::getS("proc_filter")) const auto filter_text = (filtering) ? filter(max(6, width - 66)) : uresize(Config::getS("proc_filter"), max(6, width - 66)); out += Mv::to(y, x+9) + title_left + (not filter_text.empty() ? Fx::b : "") + Theme::c("hi_fg") + 'f' + Theme::c("title") + (not filter_text.empty() ? ' ' + filter_text : "ilter") + (not filtering and not filter_text.empty() ? Theme::c("hi_fg") + " del" : "") + (filtering ? Theme::c("hi_fg") + ' ' + Symbols::enter : "") + Fx::ub + title_right; if (not filtering) { int f_len = (filter_text.empty() ? 6 : ulen(filter_text) + 2); Input::mouse_mappings["f"] = {y, x + 10, 1, f_len}; if (filter_text.empty() and Input::mouse_mappings.contains("delete")) Input::mouse_mappings.erase("delete"); else if (not filter_text.empty()) Input::mouse_mappings["delete"] = {y, x + 11 + f_len, 1, 3}; } //? pause, per-core, reverse, tree and sorting const auto& sorting = Config::getS("proc_sorting"); const int sort_len = sorting.size(); const int sort_pos = x + width - sort_len - 8; if (width > 60 + sort_len) { fmt::format_to(std::back_inserter(out), "{}{}{}{}{}{}{}{}{}{}{}", Mv::to(y, sort_pos - 32), title_left, pause_proc_list ? Fx::b : "", Theme::c("title"), "pa", Theme::c("hi_fg"), 'u', Theme::c("title"), "se", Fx::ub, title_right); Input::mouse_mappings["u"] = {y, sort_pos - 31, 1, 5}; } if (width > 55 + sort_len) { out += Mv::to(y, sort_pos - 25) + title_left + (Config::getB("proc_per_core") ? Fx::b : "") + Theme::c("title") + "per-" + Theme::c("hi_fg") + 'c' + Theme::c("title") + "ore" + Fx::ub + title_right; Input::mouse_mappings["c"] = {y, sort_pos - 24, 1, 8}; } if (width > 45 + sort_len) { out += Mv::to(y, sort_pos - 15) + title_left + (Config::getB("proc_reversed") ? Fx::b : "") + Theme::c("hi_fg") + 'r' + Theme::c("title") + "everse" + Fx::ub + title_right; Input::mouse_mappings["r"] = {y, sort_pos - 14, 1, 7}; } if (width > 35 + sort_len) { out += Mv::to(y, sort_pos - 6) + title_left + (Config::getB("proc_tree") ? Fx::b : "") + Theme::c("title") + "tre" + Theme::c("hi_fg") + 'e' + Fx::ub + title_right; Input::mouse_mappings["e"] = {y, sort_pos - 5, 1, 4}; } out += Mv::to(y, sort_pos) + title_left + Fx::b + Theme::c("hi_fg") + Symbols::left + " " + Theme::c("title") + sorting + " " + Theme::c("hi_fg") + Symbols::right + Fx::ub + title_right; Input::mouse_mappings["left"] = {y, sort_pos + 1, 1, 2}; Input::mouse_mappings["right"] = {y, sort_pos + sort_len + 3, 1, 2}; //? select, info, signal, and follow buttons const string down_button = (is_last_process_in_list ? Theme::c("inactive_fg") : Theme::c("hi_fg")) + Symbols::down; const bool is_up_button_highlighted = selected != 0 or (follow_process and followed_pid == Config::getI("detailed_pid") and should_selection_return_to_followed); const string up_button = (is_up_button_highlighted ? Theme::c("hi_fg") : Theme::c("inactive_fg")) + Symbols::up; const string t_color = (selected == 0 ? Theme::c("inactive_fg") : Theme::c("title")); const string hi_color = (selected == 0 ? Theme::c("inactive_fg") : Theme::c("hi_fg")); int mouse_x = x + 14; out += Mv::to(y + height - 1, x + 1) + title_left_down + Fx::b + hi_color + up_button + Theme::c("title") + " select " + down_button + Fx::ub + title_right_down + title_left_down + Fx::b + t_color + "info " + hi_color + Symbols::enter + Fx::ub + title_right_down; if (selected > 0) Input::mouse_mappings["info_enter"] = {y + height - 1, mouse_x, 1, 6}; mouse_x += 8; if (width > 60) { out += title_left_down + Fx::b + hi_color + 't' + t_color + "erminate" + Fx::ub + title_right_down; if (selected > 0) Input::mouse_mappings["t"] = {y + height - 1, mouse_x, 1, 9}; mouse_x += 11; } if (width > 55) { out += title_left_down + Fx::b + hi_color + (vim_keys ? 'K' : 'k') + t_color + "ill" + Fx::ub + title_right_down; if (selected > 0) Input::mouse_mappings[vim_keys ? "K" : "k"] = {y + height - 1, mouse_x, 1, 4}; mouse_x += 6; } out += title_left_down + Fx::b + hi_color + 's' + t_color + "ignals" + Fx::ub + title_right_down; if (selected > 0) Input::mouse_mappings["s"] = {y + height - 1, mouse_x, 1, 7}; mouse_x += 9; out += title_left_down + Fx::b + hi_color + 'N' + t_color + "ice" + Fx::ub + title_right_down; if (selected > 0) Input::mouse_mappings["N"] = {y + height -1, mouse_x, 1, 5}; mouse_x += 6; if (width > 72) { fmt::format_to(std::back_inserter(out), "{}{}{}{}{}{}{}{}", title_left_down, follow_process ? Fx::b : "", hi_color, 'F', t_color, "ollow", Fx::ub, title_right_down); if (selected > 0) Input::mouse_mappings["F"] = {y + height - 1, mouse_x, 1, 6}; } //? Labels for fields in list if (not proc_tree) out += Mv::to(y+1, x+1) + Theme::c("title") + Fx::b + rjust("Pid:", 8) + ' ' + ljust("Program:", prog_size) + ' ' + (cmd_size > 0 ? ljust("Command:", cmd_size) : "") + ' '; else out += Mv::to(y+1, x+1) + Theme::c("title") + Fx::b + ljust("Tree:", tree_size) + ' '; out += (thread_size > 0 ? Mv::l(4) + "Threads: " : "") + ljust("User:", user_size) + ' ' + rjust((mem_bytes ? "MemB" : "Mem%"), 5) + ' ' + rjust("Cpu%", (show_graphs ? 10 : 5)) + Fx::ub; } //* End of redraw block //? Draw details box if shown if (show_detailed) { bool alive = detailed.status != "Dead"; const int item_fit = floor((double)(d_width - 2) / 10); const int item_width = floor((double)(d_width - 2) / min(item_fit, 8)); //? Graph part of box fmt::format_to(std::back_inserter(out), "{move}{unbold}{graph}{move}{fg_color}{bold}{cpu_str}%", "move"_a = Mv::to(d_y + 1, dgraph_x + 1), "bold"_a = Fx::b, "unbold"_a = Fx::ub, "fg_color"_a = Theme::c("title"), "graph"_a = detailed_cpu_graph(detailed.cpu_percent, (redraw or data_same or not alive)), "cpu_str"_a = (alive or pause_proc_list) ? fmt::format("{:>4.{}f}", detailed.entry.cpu_p, detailed.entry.cpu_p < 9.995f ? 2 : detailed.entry.cpu_p < 99.95f ? 1 : 0) : ""); for (int i = 0; const auto& l : {'C', 'P', 'U'}) fmt::format_to(std::back_inserter(out), "{}{}", Mv::to(d_y + 3 + i++, dgraph_x + 1), l); //? Info part of box const string stat_color = (not alive ? Theme::c("inactive_fg") : (detailed.status == "Running" ? Theme::c("proc_misc") : Theme::c("main_fg"))); out += Mv::to(d_y + 2, d_x + 1) + stat_color + Fx::ub + cjust(detailed.status, item_width) + Theme::c("main_fg") + cjust(detailed.elapsed, item_width); if (item_fit >= 3) out += cjust(detailed.io_read, item_width); if (item_fit >= 4) out += cjust(detailed.io_write, item_width); if (item_fit >= 5) out += cjust(detailed.parent, item_width, true); if (item_fit >= 6) out += cjust(detailed.entry.user, item_width, true); if (item_fit >= 7) out += cjust(to_string(detailed.entry.threads), item_width); if (item_fit >= 8) out += cjust(to_string(detailed.entry.p_nice), item_width); const double mem_p = detailed.mem_bytes.back() * 100.0 / totalMem; string mem_str = fmt::format("{:.2f}", mem_p); mem_str.resize(4); if (mem_str.ends_with('.')) mem_str.pop_back(); out += Mv::to(d_y + 4, d_x + 1) + Theme::c("title") + Fx::b + rjust((item_fit > 4 ? "Memory: " : "M:") + rjust(mem_str, 4) + "% ", (d_width / 3) - 2) + Theme::c("inactive_fg") + Fx::ub + graph_bg * (d_width / 3) + Mv::l(d_width / 3) + Theme::c("proc_misc") + detailed_mem_graph(detailed.mem_bytes, (redraw or data_same or not alive)) + ' ' + Theme::c("title") + Fx::b + detailed.memory; } //? Check bounds of current selection and view if (start > 0 and numpids <= select_max) start = 0; if (start > numpids - select_max) start = max(0, numpids - select_max); if (selected > select_max) selected = select_max; if (selected > numpids) selected = numpids; //* Iteration over processes int lc = 0; for (int n=0; auto& p : plist) { if (p.filtered or (proc_tree and p.tree_index == plist.size()) or n++ < start) continue; bool is_selected = (lc + 1 == selected); bool is_followed = followed_pid == (int)p.pid; if (is_selected) { selected_pid = (int)p.pid; selected_name = p.name; selected_depth = p.depth; } //? Update graphs for processes with above 0.0% cpu usage, delete if below 0.1% 10x times bool has_graph = show_graphs ? p_counters.contains(p.pid) : false; if (show_graphs and ((p.cpu_p > 0 and not has_graph) or (not data_same and has_graph))) { if (not has_graph) { p_graphs[p.pid] = Draw::Graph{5, 1, "", {}, graph_symbol}; p_counters[p.pid] = 0; } else if (p.cpu_p < 0.1 and ++p_counters[p.pid] >= 10) { if (p_graphs.contains(p.pid)) p_graphs.erase(p.pid); p_counters.erase(p.pid); } else p_counters[p.pid] = 0; } out += Fx::reset; //? Set correct gradient colors if enabled string c_color, m_color, t_color, g_color, end; if (is_selected or is_followed) { c_color = m_color = t_color = g_color = Fx::b; end = Fx::ub; const string highlight = is_followed ? Theme::c("followed_bg") + Theme::c("followed_fg") : Theme::c("selected_bg") + Theme::c("selected_fg"); fmt::format_to(std::back_inserter(out), "{}{}", highlight, Fx::b); } else { int calc = (selected > lc) ? selected - lc : lc - selected; if (proc_colors) { end = Theme::c("main_fg") + Fx::ub; array colors; for (int i = 0; int v : {(int)round(p.cpu_p), (int)round(p.mem * 100 / totalMem), (int)p.threads / 3}) { if (proc_gradient) { int val = (min(v, 100) + 100) - calc * 100 / select_max; if (val < 100) colors[i++] = Theme::g("proc_color").at(max(0, val)); else colors[i++] = Theme::g("process").at(clamp(val - 100, 0, 100)); } else colors[i++] = Theme::g("process").at(clamp(v, 0, 100)); } c_color = colors.at(0); m_color = colors.at(1); t_color = colors.at(2); } else { c_color = m_color = t_color = Fx::b; end = Fx::ub; } if (proc_gradient) { g_color = Theme::g("proc").at(clamp(calc * 100 / select_max, 0, 100)); } } const auto san_cmd = replace_ascii_control(p.cmd); if (not p_wide_cmd.contains(p.pid)) p_wide_cmd[p.pid] = ulen(san_cmd) != ulen(san_cmd, true); //? Normal view line if (not proc_tree) { out += Mv::to(y+2+lc, x+1) + g_color + rjust(to_string(p.pid), 8) + ' ' + c_color + ljust(p.name, prog_size, true) + ' ' + end + (cmd_size > 0 ? g_color + ljust(san_cmd, cmd_size, true, p_wide_cmd[p.pid]) + Mv::to(y+2+lc, x+11+prog_size+cmd_size) + ' ' : ""); } //? Tree view line else { const string prefix_pid = p.prefix + to_string(p.pid); int width_left = tree_size; out += Mv::to(y+2+lc, x+1) + g_color + uresize(prefix_pid, width_left) + ' '; width_left -= ulen(prefix_pid); if (width_left > 0) { out += c_color + uresize(p.name, width_left - 1) + end + ' '; width_left -= (ulen(p.name) + 1); } if (width_left > 7) { const string_view cmd = width_left > 40 ? rtrim(san_cmd) : p.short_cmd; if (not cmd.empty() and cmd != p.name) { out += g_color + '(' + uresize(string{cmd}, width_left - 3, p_wide_cmd[p.pid]) + ") "; width_left -= (ulen(string{cmd}, true) + 3); } } out += string(max(0, width_left), ' ') + Mv::to(y+2+lc, x+2+tree_size); } //? Common end of line string cpu_str = fmt::format("{:.2f}", p.cpu_p); if (p.cpu_p < 10 or (p.cpu_p >= 100 and p.cpu_p < 1000)) cpu_str.resize(3); else if (p.cpu_p >= 10'000) { cpu_str = fmt::format("{:.2f}", p.cpu_p / 1000); cpu_str.resize(3); if (cpu_str.ends_with('.')) cpu_str.pop_back(); cpu_str += "k"; } string mem_str = (mem_bytes ? floating_humanizer(p.mem, true) : ""); if (not mem_bytes) { double mem_p = clamp((double)p.mem * 100 / totalMem, 0.0, 100.0); mem_str = mem_p < 0.01 ? "0" : fmt::format("{:.1f}", mem_p); if (mem_str.size() > 3) mem_str.resize(3); if (mem_str.ends_with('.')) mem_str.pop_back(); mem_str += '%'; } // Shorten process thread representation when larger than 5 digits: 10000 -> 10K ... const std::string proc_threads_string = [&] { if (p.threads > 9999) { return std::to_string(p.threads / 1000) + 'K'; } else { return std::to_string(p.threads); } }(); out += (thread_size > 0 ? t_color + rjust(proc_threads_string, thread_size) + ' ' + end : "" ) + g_color + ljust((cmp_greater(p.user.size(), user_size) ? p.user.substr(0, user_size - 1) + '+' : p.user), user_size) + ' ' + m_color + rjust(mem_str, 5) + end + ' ' + (is_selected or is_followed ? "" : Theme::c("inactive_fg")) + (show_graphs ? graph_bg * 5: "") + (p_graphs.contains(p.pid) ? Mv::l(5) + c_color + p_graphs.at(p.pid)({(p.cpu_p >= 0.1 and p.cpu_p < 5 ? 5ll : (long long)round(p.cpu_p))}, data_same) : "") + end + ' ' + c_color + rjust(cpu_str, 4) + " " + end; if (lc++ > height - 5) break; else if (lc > height - 5 and proc_banner_shown) break; } out += Fx::reset; while (lc++ < height - 3) out += Mv::to(y+lc+1, x+1) + string(width - 2, ' '); if (proc_banner_shown) { fmt::format_to(std::back_inserter(out), "{}{}{}{}{:^{}}{}", Mv::to(y + height - 2, x + 1), (pause_proc_list and follow_process) ? Theme::c("proc_banner_bg") : pause_proc_list ? Theme::c("proc_pause_bg") : Theme::c("proc_follow_bg"), Theme::c("proc_banner_fg"), Fx::b, (pause_proc_list and follow_process) ? "Paused list and Following process" : pause_proc_list ? "Process list paused" : "Following process", width - 2, Fx::reset); } //? Draw scrollbar if needed if (numpids > select_max) { scroll_pos = clamp((int)round((double)start * select_max / (numpids - select_max)), 0, height - 5); out += Mv::to(y + 1, x + width - 2) + Fx::b + Theme::c("main_fg") + Symbols::up + Mv::to(y + height - 2, x + width - 2) + Symbols::down; for (int i = y + 2; i < y + height - 2; i++) { out += Mv::to(i, x + width - 2) + ((i == y + 2 + scroll_pos) ? "โ–ˆ" : " "); } } //? Current selection and number of processes string location = to_string(start + (follow_process ? followed : selected)) + '/' + to_string(numpids); string loc_clear = Symbols::h_line * max((size_t)0, 9 - location.size()); out += Mv::to(y + height - 1, x+width - 3 - max(9, (int)location.size())) + Fx::ub + Theme::c("proc_box") + loc_clear + Symbols::title_left_down + Theme::c("title") + Fx::b + location + Fx::ub + Theme::c("proc_box") + Symbols::title_right_down; //? Clear out left over graphs from dead processes at a regular interval if (not data_same and ++counter >= 100) { counter = 0; std::erase_if(p_graphs, [&](const auto& pair) { return rng::find(plist, pair.first, &proc_info::pid) == plist.end(); }); std::erase_if(p_counters, [&](const auto& pair) { return rng::find(plist, pair.first, &proc_info::pid) == plist.end(); }); std::erase_if(p_wide_cmd, [&](const auto& pair) { return rng::find(plist, pair.first, &proc_info::pid) == plist.end(); }); } //? Draw hide button if detailed view is shown if (show_detailed) { const bool greyed_out = selected_pid != Config::getI("detailed_pid") && selected > 0; fmt::format_to(std::back_inserter(out), "{}{}{}{}{}{}{}{}{}{}{}", Mv::to(d_y, d_x + d_width - 10), Theme::c("proc_box"), Symbols::title_left, Fx::b, greyed_out ? Theme::c("inactive_fg") : Theme::c("title"), "hide ", greyed_out ? "" : Theme::c("hi_fg"), Symbols::enter, Fx::ub, Theme::c("proc_box"), Symbols::title_right); if (not greyed_out) Input::mouse_mappings["enter"] = {d_y, d_x + d_width - 9, 1, 6}; else Input::mouse_mappings.erase("enter"); } if (selected == 0 and selected_pid != 0) { selected_pid = 0; selected_name.clear(); } redraw = false; return out + Fx::reset; } } namespace Draw { void calcSizes() { atomic_wait(Runner::active); Config::unlock(); auto boxes = Config::getS("shown_boxes"); auto cpu_bottom = Config::getB("cpu_bottom"); auto mem_below_net = Config::getB("mem_below_net"); auto proc_left = Config::getB("proc_left"); Cpu::box.clear(); Mem::box.clear(); Net::box.clear(); Proc::box.clear(); Global::clock.clear(); Global::overlay.clear(); Runner::pause_output = false; Runner::redraw = true; if (not (Proc::resized or Global::resized)) { Proc::p_counters.clear(); Proc::p_graphs.clear(); } if (Menu::active) Menu::redraw = true; Input::mouse_mappings.clear(); Cpu::x = Mem::x = Net::x = Proc::x = 1; Cpu::y = Mem::y = Net::y = Proc::y = 1; Cpu::width = Mem::width = Net::width = Proc::width = 0; Cpu::height = Mem::height = Net::height = Proc::height = 0; Cpu::redraw = Mem::redraw = Net::redraw = Proc::redraw = true; Cpu::shown = boxes.contains("cpu"); #ifdef GPU_SUPPORT Gpu::box.clear(); Gpu::width = 0; Gpu::shown_panels.clear(); if (Gpu::count > 0) { std::istringstream iss(boxes, std::istringstream::in); string current; while (iss >> current) { if (current.starts_with("gpu")) Gpu::shown_panels.push_back(current.back()-'0'); } } Gpu::shown = Gpu::shown_panels.size(); // Calculate the minimum possible GPU height, store in total_height // The actual total_height value will of course be overwritten later Gpu::total_height = 0; for (int i = 0; i < Gpu::shown; i++) { using namespace Gpu; total_height += 4 + gpu_b_height_offsets[shown_panels[i]]; } #endif Mem::shown = boxes.contains("mem"); Net::shown = boxes.contains("net"); Proc::shown = boxes.contains("proc"); //* Calculate and draw cpu box outlines if (Cpu::shown) { using namespace Cpu; #ifdef GPU_SUPPORT // inline GPU information int gpus_extra_height = Config::getS("show_gpu_info") == "On" ? Gpu::count : Config::getS("show_gpu_info") == "Auto" ? Gpu::count - Gpu::shown : 0; #endif const bool show_temp = (Config::getB("check_temp") and got_sensors); width = round((double)Term::width * width_p / 100); #ifdef GPU_SUPPORT if (Gpu::shown != 0 and not (Mem::shown or Net::shown or Proc::shown)) { height = Term::height - Gpu::total_height - gpus_extra_height; } else { height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p/(Gpu::shown+1) + (Gpu::shown != 0)*5) / 100)); } if (height <= Term::height-gpus_extra_height) height += gpus_extra_height; #else height = max(8, (int)ceil((double)Term::height * (trim(boxes) == "cpu" ? 100 : height_p) / 100)); #endif x = 1; y = cpu_bottom ? Term::height - height + 1 : 1; #ifdef GPU_SUPPORT b_columns = max(2, (int)ceil((double)(Shared::coreCount + 1) / (height - gpus_extra_height - 5))); #else b_columns = max(1, (int)ceil((double)(Shared::coreCount + 1) / (height - 5))); #endif if (b_columns * (21 + 12 * show_temp) < width - (width / 3)) { b_column_size = 2; b_width = max(29, (21 + 12 * show_temp) * b_columns - (b_columns - 1)); } else if (b_columns * (15 + 6 * show_temp) < width - (width / 3)) { b_column_size = 1; b_width = (15 + 6 * show_temp) * b_columns - (b_columns - 1); } else if (b_columns * (8 + 6 * show_temp) < width - (width / 3)) { b_column_size = 0; } else { b_columns = (width - width / 3) / (8 + 6 * show_temp); b_column_size = 0; } if (b_column_size == 0) b_width = (8 + 6 * show_temp) * b_columns + 1; #ifdef GPU_SUPPORT //gpus_extra_height = max(0, gpus_extra_height - 1); b_height = min(height - 2, (int)ceil((double)Shared::coreCount / b_columns) + 4 + gpus_extra_height); #else b_height = min(height - 2, (int)ceil((double)Shared::coreCount / b_columns) + 4); #endif b_x = x + width - b_width - 1; b_y = y + ceil((double)(height - 2) / 2) - ceil((double)b_height / 2) + 1; box = createBox(x, y, width, height, Theme::c("cpu_box"), true, (cpu_bottom ? "" : "cpu"), (cpu_bottom ? "cpu" : ""), 1); auto& custom = Config::getS("custom_cpu_name"); static const bool hasCpuHz = not Cpu::get_cpuHz().empty(); #ifdef __linux__ static const bool freq_range = Config::getS("freq_mode") == "range"; #else static const bool freq_range = false; #endif const string cpu_title = uresize( (custom.empty() ? Cpu::cpuName : custom), b_width - (Config::getB("show_cpu_freq") and hasCpuHz ? (freq_range ? 24 : 14) : 5) ); box += createBox(b_x, b_y, b_width, b_height, "", false, cpu_title); } #ifdef GPU_SUPPORT //* Calculate and draw gpu box outlines if (Gpu::shown != 0) { using namespace Gpu; x_vec.resize(shown); y_vec.resize(shown); b_x_vec.resize(shown); b_y_vec.resize(shown); b_height_vec.resize(shown); box.resize(shown); graph_upper_vec.resize(shown); graph_lower_vec.resize(shown); temp_graph_vec.resize(shown); mem_used_graph_vec.resize(shown); mem_util_graph_vec.resize(shown); gpu_meter_vec.resize(shown); pwr_meter_vec.resize(shown); enc_meter_vec.resize(shown); redraw.resize(shown); total_height = 0; for (auto i = 0; i < shown; ++i) { redraw[i] = true; int height = 0; width = Term::width; if (Cpu::shown) if (not (Mem::shown or Net::shown or Proc::shown)) height = min_height; else height = Cpu::height; else if (not (Mem::shown or Net::shown or Proc::shown)) height = (Term::height - total_height) / (Gpu::shown - i) + (i == 0) * ((Term::height - total_height) % (Gpu::shown - i)); else height = max(min_height, (int)ceil((double)Term::height * height_p/Gpu::shown / 100)); b_height_vec[i] = gpu_b_height_offsets[shown_panels[i]] + 2; height += (height+Cpu::height == Term::height-1); height = max(height, b_height_vec[i] + 2); x_vec[i] = 1; y_vec[i] = 1 + total_height + (not Config::getB("cpu_bottom"))*Cpu::shown*Cpu::height; box[i] = createBox(x_vec[i], y_vec[i], width, height, Theme::c("cpu_box"), true, std::string("gpu") + (char)(shown_panels[i]+'0'), "", (shown_panels[i]+5)%10); // TODO gpu_box b_width = clamp(width/2, min_width, 65); total_height += height; //? Main statistics box b_x_vec[i] = x_vec[i] + width - b_width - 1; b_y_vec[i] = y_vec[i] + ceil((double)(height - 2 - b_height_vec[i]) / 2) + 1; string name = Config::getS(std::string("custom_gpu_name") + (char)(shown_panels[i]+'0')); if (name.empty()) name = gpu_names[shown_panels[i]]; box[i] += createBox(b_x_vec[i], b_y_vec[i], b_width, b_height_vec[i], "", false, name.substr(0, b_width-5)); b_height_vec[i] = height - 2; } } #endif //* Calculate and draw mem box outlines if (Mem::shown) { using namespace Mem; auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto mem_graphs = Config::getB("mem_graphs"); width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); #ifdef GPU_SUPPORT height = floor(static_cast(Term::height) * (100 - Net::height_p * Net::shown*4 / ((Gpu::shown != 0 and Cpu::shown) + 4)) / 100) - Cpu::height - Gpu::total_height; #else height = floor(static_cast(Term::height) * (100 - Cpu::height_p * Cpu::shown - Net::height_p * Net::shown) / 100); #endif x = (proc_left and Proc::shown) ? Term::width - width + 1: 1; if (mem_below_net and Net::shown) #ifdef GPU_SUPPORT y = Term::height - height + 1 - (cpu_bottom ? Cpu::height : 0); else y = (cpu_bottom ? 1 : Cpu::height + 1) + Gpu::total_height; #else y = Term::height - height + 1 - (cpu_bottom ? Cpu::height : 0); else y = cpu_bottom ? 1 : Cpu::height + 1; #endif if (show_disks) { mem_width = ceil((double)(width - 3) / 2); mem_width += mem_width % 2; disks_width = width - mem_width - 2; divider = x + mem_width; } else mem_width = width - 1; item_height = has_swap and not swap_disk ? 6 : 4; if (height - (has_swap and not swap_disk ? 3 : 2) > 2 * item_height) mem_size = 3; else if (mem_width > 25) mem_size = 2; else mem_size = 1; mem_meter = max(0, mem_width - (mem_size > 2 ? 7 : 17)); if (mem_size == 1) mem_meter += 6; if (mem_graphs) { graph_height = max(1, (int)round((double)((height - (has_swap and not swap_disk ? 2 : 1)) - (mem_size == 3 ? 2 : 1) * item_height) / item_height)); if (graph_height > 1) mem_meter += 6; } else graph_height = 0; if (show_disks) { disk_meter = max(-14, width - mem_width - 23); if (disks_width < 25) disk_meter += 14; } box = createBox(x, y, width, height, Theme::c("mem_box"), true, "mem", "", 2); box += Mv::to(y, (show_disks ? divider + 2 : x + width - 9)) + Theme::c("mem_box") + Symbols::title_left + (show_disks ? Fx::b : "") + Theme::c("hi_fg") + 'd' + Theme::c("title") + "isks" + Fx::ub + Theme::c("mem_box") + Symbols::title_right; Input::mouse_mappings["d"] = {y, (show_disks ? divider + 3 : x + width - 8), 1, 5}; if (show_disks) { box += Mv::to(y, divider) + Symbols::div_up + Mv::to(y + height - 1, divider) + Symbols::div_down + Theme::c("div_line"); for (auto i : iota(1, height - 1)) box += Mv::to(y + i, divider) + Symbols::v_line; } } //* Calculate and draw net box outlines if (Net::shown) { using namespace Net; width = round((double)Term::width * (Proc::shown ? width_p : 100) / 100); #ifdef GPU_SUPPORT height = Term::height - Cpu::height - Gpu::total_height - Mem::height; #else height = Term::height - Cpu::height - Mem::height; #endif x = (proc_left and Proc::shown) ? Term::width - width + 1 : 1; if (mem_below_net and Mem::shown) #ifdef GPU_SUPPORT y = (cpu_bottom ? 1 : Cpu::height + 1) + Gpu::total_height; #else y = cpu_bottom ? 1 : Cpu::height + 1; #endif else y = Term::height - height + 1 - (cpu_bottom ? Cpu::height : 0); b_width = (width > 45) ? 27 : 19; b_height = (height > 10) ? 9 : height - 2; b_x = x + width - b_width - 1; b_y = y + ((height - 2) / 2) - b_height / 2 + 1; d_graph_height = round((double)(height - 2) / 2); u_graph_height = height - 2 - d_graph_height; box = createBox(x, y, width, height, Theme::c("net_box"), true, "net", "", 3); auto swap_up_down = Config::getB("swap_upload_download"); if (swap_up_down) box += createBox(b_x, b_y, b_width, b_height, "", false, "upload", "download"); else box += createBox(b_x, b_y, b_width, b_height, "", false, "download", "upload"); } //* Calculate and draw proc box outlines if (Proc::shown) { using namespace Proc; width = Term::width - (Mem::shown ? Mem::width : (Net::shown ? Net::width : 0)); #ifdef GPU_SUPPORT height = Term::height - Cpu::height - Gpu::total_height; #else height = Term::height - Cpu::height; #endif x = proc_left ? 1 : Term::width - width + 1; #ifdef GPU_SUPPORT y = ((cpu_bottom and Cpu::shown) ? 1 : Cpu::height + 1) + Gpu::total_height; #else y = (cpu_bottom and Cpu::shown) ? 1 : Cpu::height + 1; #endif select_max = height - 3; box = createBox(x, y, width, height, Theme::c("proc_box"), true, "proc", "", 4); } } } aristocratos-btop-d43a485/src/btop_draw.hpp000066400000000000000000000076751517514752700210450ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include #include using std::array; using std::deque; using std::string; using std::vector; namespace Symbols { const string h_line = "โ”€"; const string v_line = "โ”‚"; const string dotted_v_line = "โ•Ž"; const string left_up = "โ”Œ"; const string right_up = "โ”"; const string left_down = "โ””"; const string right_down = "โ”˜"; const string round_left_up = "โ•ญ"; const string round_right_up = "โ•ฎ"; const string round_left_down = "โ•ฐ"; const string round_right_down = "โ•ฏ"; const string title_left_down = "โ”˜"; const string title_right_down = "โ””"; const string title_left = "โ”"; const string title_right = "โ”Œ"; const string div_right = "โ”ค"; const string div_left = "โ”œ"; const string div_up = "โ”ฌ"; const string div_down = "โ”ด"; const string up = "โ†‘"; const string down = "โ†“"; const string left = "โ†"; const string right = "โ†’"; const string enter = "โ†ต"; } namespace Draw { //* Generate if needed and return the btop++ banner string banner_gen(int y=0, int x=0, bool centered=false, bool redraw=false); //* An editable text field class TextEdit { size_t pos{}; size_t upos{}; bool numeric = false; public: string text; TextEdit(); explicit TextEdit(string text, bool numeric=false); bool command(const std::string_view key); string operator()(const size_t limit=0); void clear(); }; //* Create a box and return as a string string createBox( const int x, const int y, const int width, const int height, string line_color = "", bool fill = false, const std::string_view title = "", const std::string_view title2 = "", const int num = 0 ); bool update_clock(bool force = false); //* Class holding a percentage meter class Meter { int width; string color_gradient; bool invert; array cache; public: Meter(); Meter(const int width, string color_gradient, bool invert = false); //* Return a string representation of the meter with given value string operator()(int value); }; //* Class holding a percentage graph class Graph { int width, height; string color_gradient; string out, symbol = "default"; bool invert, no_zero; long long offset; long long last = 0, max_value = 0; bool current = true, tty_mode = false; std::unordered_map> graphs = { {true, {}}, {false, {}}}; //* Create two representations of the graph to switch between to represent two values for each braille character void _create(const deque& data, int data_offset); public: Graph(); Graph(int width, int height, const string& color_gradient, const deque& data, const string& symbol="default", bool invert=false, bool no_zero=false, long long max_value=0, long long offset=0); //* Add last value from back of and return string representation of graph string& operator()(const deque& data, bool data_same=false); //* Return string representation of graph string& operator()(); }; //* Calculate sizes of boxes, draw outlines and save to enabled boxes namespaces void calcSizes(); } namespace Proc { extern Draw::TextEdit filter; extern std::unordered_map p_graphs; extern std::unordered_map p_counters; } aristocratos-btop-d43a485/src/btop_input.cpp000066400000000000000000000510311517514752700212230ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include #include #include #include "btop_input.hpp" #include "btop_tools.hpp" #include "btop_config.hpp" #include "btop_shared.hpp" #include "btop_menu.hpp" #include "btop_draw.hpp" using namespace Tools; using namespace std::literals; // for operator""s namespace rng = std::ranges; namespace Input { //* Map for translating key codes to readable values const std::unordered_map Key_escapes = { {"\033", "escape"}, {"\x12", "ctrl_r"}, {"\n", "enter"}, {" ", "space"}, {"\x7f", "backspace"}, {"\x08", "backspace"}, {"[A", "up"}, {"OA", "up"}, {"[B", "down"}, {"OB", "down"}, {"[D", "left"}, {"OD", "left"}, {"[C", "right"}, {"OC", "right"}, {"[2~", "insert"}, {"[4h", "insert"}, {"[3~", "delete"}, {"[P", "delete"}, {"[H", "home"}, {"[1~", "home"}, {"[F", "end"}, {"[4~", "end"}, {"[5~", "page_up"}, {"[6~", "page_down"}, {"\t", "tab"}, {"[Z", "shift_tab"}, {"OP", "f1"}, {"OQ", "f2"}, {"OR", "f3"}, {"OS", "f4"}, {"[15~", "f5"}, {"[17~", "f6"}, {"[18~", "f7"}, {"[19~", "f8"}, {"[20~", "f9"}, {"[21~", "f10"}, {"[23~", "f11"}, {"[24~", "f12"} }; sigset_t signal_mask; std::atomic polling (false); array mouse_pos; std::unordered_map mouse_mappings; bool dragging_scroll; deque history(50, ""); string old_filter; string input; bool poll(const uint64_t timeout) { atomic_lock lck(polling); fd_set fds; FD_ZERO(&fds); FD_SET(STDIN_FILENO, &fds); struct timespec wait; struct timespec *waitptr = nullptr; if(timeout != std::numeric_limits::max()) { wait.tv_sec = timeout / 1000; wait.tv_nsec = (timeout % 1000) * 1000000; waitptr = &wait; } if(pselect(STDIN_FILENO + 1, &fds, nullptr, nullptr, waitptr, &signal_mask) > 0) { input.clear(); char buf[1024]; ssize_t count = 0; while((count = read(STDIN_FILENO, buf, sizeof(buf))) > 0) { input.append(std::string_view(buf, count)); } return true; } return false; } string get() { string key = input; if (not key.empty()) { //? Remove escape code prefix if present if (key.length() > 1 and key.at(0) == Fx::e.at(0)) { key.erase(0, 1); } //? Detect if input is a mouse event. if (key.starts_with("[<")) { std::string_view key_view = key; string mouse_event; if (key_view.starts_with("[<0;") and key_view.find('M') != std::string_view::npos) { mouse_event = "mouse_click"; key_view.remove_prefix(4); } else if (key_view.starts_with("[<32;")) { mouse_event = "mouse_drag"; key_view.remove_prefix(5); } else if (key_view.starts_with("[<0;") and key_view.ends_with('m')) { mouse_event = "mouse_release"; key_view.remove_prefix(4); } else if (key_view.starts_with("[<64;")) { mouse_event = "mouse_scroll_up"; key_view.remove_prefix(5); } else if (key_view.starts_with("[<65;")) { mouse_event = "mouse_scroll_down"; key_view.remove_prefix(5); } else key.clear(); if (Config::getB("proc_filtering")) { if (mouse_event == "mouse_click") return mouse_event; else return ""; } //? Get column and line position of mouse and check for any actions mapped to current position if (not key.empty()) { try { const auto delim = key_view.find(';'); mouse_pos[0] = stoi((string)key_view.substr(0, delim)); mouse_pos[1] = stoi((string)key_view.substr(delim + 1, key_view.find('M', delim))); } catch (const std::invalid_argument&) { mouse_event.clear(); } catch (const std::out_of_range&) { mouse_event.clear(); } key = mouse_event; if (key == "mouse_click" or key == "mouse_drag") { const auto& [col, line] = mouse_pos; for (const auto& [mapped_key, pos] : (Menu::active ? Menu::mouse_mappings : mouse_mappings)) { if (col >= pos.col and col < pos.col + pos.width and line >= pos.line and line < pos.line + pos.height) { key = mapped_key; break; } } } } } else if (auto it = Key_escapes.find(key); it != Key_escapes.end()) key = it->second; else if (ulen(key) > 1) key.clear(); if (not key.empty()) { history.push_back(key); history.pop_front(); } } return key; } string wait() { while(not poll(std::numeric_limits::max())) {} return get(); } void interrupt() { kill(getpid(), SIGUSR1); } void clear() { // do not need it, actually } void process(const std::string_view key) { if (key.empty()) return; try { auto filtering = Config::getB("proc_filtering"); auto vim_keys = Config::getB("vim_keys"); auto help_key = (vim_keys ? "H" : "h"); auto kill_key = (vim_keys ? "K" : "k"); //? Global input actions if (not filtering) { bool keep_going = false; if (key == "q") { clean_quit(0); } else if (is_in(key, "escape", "m")) { Menu::show(Menu::Menus::Main); return; } else if (is_in(key, "f1", "?", help_key)) { Menu::show(Menu::Menus::Help); return; } else if (is_in(key, "f2", "o")) { Menu::show(Menu::Menus::Options); return; } else if (key.size() == 1 and isint(key)) { auto intKey = std::atoi(key.data()); #ifdef GPU_SUPPORT static const array boxes = {"gpu5", "cpu", "mem", "net", "proc", "gpu0", "gpu1", "gpu2", "gpu3", "gpu4"}; if ((intKey == 0 and Gpu::count < 5) or (intKey >= 5 and intKey - 4 > Gpu::count)) return; #else static const array boxes = {"", "cpu", "mem", "net", "proc"}; if (intKey == 0 or intKey > 4) return; #endif atomic_wait(Runner::active); if (not Config::toggle_box(boxes.at(intKey))) { Menu::show(Menu::Menus::SizeError); return; } Config::current_preset.reset(); Draw::calcSizes(); Draw::update_clock(true); Runner::run("all", false, true); return; } else if (is_in(key, "p", "P") and Config::getS("disable_presets") != "All") { if (Config::getS("disable_presets") == "Default" and Config::preset_list.size() <= 1) return; const auto old_preset = Config::current_preset; const int first_preset = (Config::getS("disable_presets") == "Default") ? 1 : 0; if (Config::getS("disable_presets") == "Custom") Config::current_preset = 0; else if (Config::current_preset.has_value()) { if (key == "p") { if(++(*Config::current_preset) >= static_cast(Config::preset_list.size())) Config::current_preset = first_preset; } else if (--(*Config::current_preset) < first_preset) Config::current_preset = Config::preset_list.size() - 1; } else Config::current_preset = (key == "p") ? first_preset : Config::preset_list.size() - 1; if (Config::current_preset == old_preset) return; atomic_wait(Runner::active); if (not Config::apply_preset(Config::preset_list.at(Config::current_preset.value()))) { Menu::show(Menu::Menus::SizeError); Config::current_preset = old_preset; return; } Draw::calcSizes(); Draw::update_clock(true); Runner::run("all", false, true); return; } else if (is_in(key, "ctrl_r")) { kill(getpid(), SIGUSR2); return; } else if (key == "mouse_release") { dragging_scroll = false; } else keep_going = true; if (not keep_going) return; } //? Input actions for proc box if (Proc::shown) { bool keep_going = false; bool no_update = true; bool redraw = true; if (filtering) { if (key == "enter" or key == "down") { Config::set("proc_filter", Proc::filter.text); Config::set("proc_filtering", false); old_filter.clear(); if(key == "down"){ Config::unlock(); Config::lock(); process("down"); return; } } else if (key == "escape" or key == "mouse_click") { Config::set("proc_filter", old_filter); Config::set("proc_filtering", false); old_filter.clear(); } else if (Proc::filter.command(key)) { if (Config::getS("proc_filter") != Proc::filter.text) Config::set("proc_filter", Proc::filter.text); } else return; } else if (key == "left" or (vim_keys and key == "h")) { int cur_i = v_index(Proc::sort_vector, Config::getS("proc_sorting")); if (--cur_i < 0) cur_i = Proc::sort_vector.size() - 1; Config::set("proc_sorting", Proc::sort_vector.at(cur_i)); Config::set("update_following", true); if (Config::getB("proc_tree")) no_update = false; } else if (key == "right" or (vim_keys and key == "l")) { int cur_i = v_index(Proc::sort_vector, Config::getS("proc_sorting")); if (std::cmp_greater(++cur_i, Proc::sort_vector.size() - 1)) cur_i = 0; Config::set("proc_sorting", Proc::sort_vector.at(cur_i)); Config::set("update_following", true); if (Config::getB("proc_tree")) no_update = false; } else if (is_in(key, "f", "/")) { Config::flip("proc_filtering"); Proc::filter = Draw::TextEdit{Config::getS("proc_filter")}; old_filter = Proc::filter.text; } else if (key == "e") { Config::flip("proc_tree"); no_update = false; Config::set("update_following", true); } else if (key == "E" and Config::getB("proc_tree")) { atomic_wait(Runner::active); Proc::collapse_all = 1; no_update = false; } else if (is_in(key, "u")) { Config::flip("pause_proc_list"); } else if (is_in(key, "F")) { if (Config::getI("proc_selected") != 0 and Config::getI("followed_pid") != Config::getI("selected_pid")) { Config::set("follow_process", true); Config::set("followed_pid", Config::getI("selected_pid")); Config::set("update_following", true); } else if (Config::getB("show_detailed") and Config::getI("proc_selected") == 0 and Config::getI("followed_pid") != Config::getI("detailed_pid")) { Config::set("follow_process", true); Config::set("followed_pid", Config::getI("detailed_pid")); Config::set("update_following", true); } else if (Config::getB("follow_process")) { Config::flip("follow_process"); if (Config::getB("should_selection_return_to_followed")) Config::set("proc_selected", Config::getI("proc_followed")); else if (Config::getB("show_detailed") and Config::getI("followed_pid") == Config::getI("detailed_pid")) Config::set("restore_detailed_pid", Config::getI("detailed_pid")); Config::set("followed_pid", 0); Config::set("proc_followed", 0); } } else if (key == "r") { Config::flip("proc_reversed"); Config::set("update_following", true); } else if (key == "c") Config::flip("proc_per_core"); else if (key == "%") Config::flip("proc_mem_bytes"); else if (key == "delete" and not Config::getS("proc_filter").empty()) Config::set("proc_filter", ""s); else if (key.starts_with("mouse_")) { redraw = false; const auto& [col, line] = mouse_pos; const int y = (Config::getB("show_detailed") ? Proc::y + 8 : Proc::y); const int height = (Config::getB("show_detailed") ? Proc::height - 8 : Proc::height); const auto in_proc_box = col >= Proc::x + 1 and col < Proc::x + Proc::width and line >= y + 1 and line < y + height - 1; if (key == "mouse_click") { if (in_proc_box) { if (col < Proc::x + Proc::width - 2) { const auto& current_selection = Config::getI("proc_selected"); if (current_selection == line - y - 1) { redraw = true; if (Config::getB("proc_tree")) { const int x_pos = col - Proc::x; const int offset = Config::getI("selected_depth") * 3; if (x_pos > offset and x_pos < 4 + offset) { process("space"); return; } } process("enter"); return; } else if (Config::getB("proc_banner_shown") and line == y + height - 2) return; else if (current_selection == 0 or line - y - 1 == 0) redraw = true; if (Config::getB("follow_process") and not Config::getB("pause_proc_list")) { Config::flip("follow_process"); Config::set("followed_pid", 0); Config::set("proc_followed", 0); redraw = true; } Config::set("proc_selected", line - y - 1); } else if (line == y + 1) { if (Proc::selection("page_up") == -1) return; } else if (line == y + height - 2) { if (Proc::selection("page_down") == -1) return; } else if (line == y + 2 + Proc::scroll_pos) { dragging_scroll = true; } else if (Proc::selection("mousey" + to_string(line - y - 2)) == -1) return; } else if (Config::getI("proc_selected") > 0){ Config::set("proc_selected", 0); if (Config::getB("follow_process") and not Config::getB("pause_proc_list")) { Config::flip("follow_process"); Config::set("followed_pid", 0); Config::set("proc_followed", 0); } redraw = true; } } else if (key.starts_with("mouse_scroll_") and in_proc_box) { goto proc_mouse_scroll; } else if (key == "mouse_drag" and dragging_scroll) { Proc::selection("mousey" + to_string(line - y - 2)); } else keep_going = true; } else if (is_in(key, "enter", "info_enter")) { if (Config::getI("proc_selected") == 0 and not Config::getB("show_detailed")) { return; } else if (Config::getI("proc_selected") > 0 and Config::getI("detailed_pid") != Config::getI("selected_pid")) { Config::set("detailed_pid", Config::getI("selected_pid")); Config::set("proc_last_selected", Config::getI("proc_selected")); Config::set("proc_selected", 0); if (Config::getB("proc_follow_detailed")) { Config::set("follow_process", true); Config::set("followed_pid", Config::getI("selected_pid")); } Config::set("show_detailed", true); } else if (Config::getB("show_detailed")) { if (Config::getB("proc_follow_detailed")) { Config::set("restore_detailed_pid", Config::getI("detailed_pid")); if (Config::getB("follow_process") and Config::getI("followed_pid") == Config::getI("detailed_pid")) { Config::flip("follow_process"); Config::set("followed_pid", 0); Config::set("proc_followed", 0); } } else if (Config::getI("proc_last_selected") > 0) Config::set("proc_selected", Config::getI("proc_last_selected")); Config::set("proc_last_selected", 0); Config::set("detailed_pid", 0); Config::set("show_detailed", false); } Config::set("update_following", true); } else if (is_in(key, "+", "-", "space", "C") and Config::getB("proc_tree")) { const bool is_following_detailed = Config::getB("follow_process") and Config::getI("followed_pid") == Config::getI("detailed_pid"); if (Config::getI("proc_selected") > 0 or is_following_detailed) { atomic_wait(Runner::active); auto& pid = is_following_detailed and Config::getI("proc_selected") == 0 ? Config::getI("followed_pid") : Config::getI("selected_pid"); if (key == "+" or key == "space") Proc::expand = pid; if (key == "-" or key == "space") Proc::collapse = pid; if (key == "C") Proc::toggle_children = pid; no_update = false; } } else if (is_in(key, "t", kill_key) and (Config::getB("show_detailed") or Config::getI("selected_pid") > 0)) { atomic_wait(Runner::active); if (Config::getB("show_detailed") and Config::getI("proc_selected") == 0 and Proc::detailed.status == "Dead") return; Menu::show(Menu::Menus::SignalSend, (key == "t" ? SIGTERM : SIGKILL)); return; } else if (key == "s" and (Config::getB("show_detailed") or Config::getI("selected_pid") > 0)) { atomic_wait(Runner::active); if (Config::getB("show_detailed") and Config::getI("proc_selected") == 0 and Proc::detailed.status == "Dead") return; Menu::show(Menu::Menus::SignalChoose); return; } else if (key == "N" and (Config::getB("show_detailed") or Config::getI("selected_pid") > 0)) { atomic_wait(Runner::active); if (Config::getB("show_detailed") and Config::getI("proc_selected") == 0 and Proc::detailed.status == "Dead") return; Menu::show(Menu::Menus::Renice); return; } else if (is_in(key, "up", "down", "page_up", "page_down", "home", "end") or (vim_keys and is_in(key, "j", "k", "g", "G"))) { proc_mouse_scroll: redraw = false; auto old_selected = Config::getI("proc_selected"); auto new_selected = Proc::selection(key); if (new_selected == -1) return; else if (old_selected != new_selected and (old_selected == 0 or new_selected == 0)) redraw = true; } else keep_going = true; if (not keep_going) { Runner::run("proc", no_update, redraw); return; } } //? Input actions for cpu box if (Cpu::shown) { bool keep_going = false; bool no_update = true; bool redraw = true; static uint64_t last_press = 0; if (key == "+" and Config::getI("update_ms") <= 86399900) { int add = (Config::getI("update_ms") <= 86399000 and last_press >= time_ms() - 200 and rng::all_of(Input::history, [](const auto& str){ return str == "+"; }) ? 1000 : 100); Config::set("update_ms", Config::getI("update_ms") + add); last_press = time_ms(); redraw = true; } else if (key == "-" and Config::getI("update_ms") >= 200) { int sub = (Config::getI("update_ms") >= 2000 and last_press >= time_ms() - 200 and rng::all_of(Input::history, [](const auto& str){ return str == "-"; }) ? 1000 : 100); Config::set("update_ms", Config::getI("update_ms") - sub); last_press = time_ms(); redraw = true; } else keep_going = true; if (not keep_going) { Runner::run("cpu", no_update, redraw); return; } } //? Input actions for mem box if (Mem::shown) { bool keep_going = false; bool no_update = true; bool redraw = true; if (key == "i") { Config::flip("io_mode"); } else if (key == "d") { Config::flip("show_disks"); no_update = false; Draw::calcSizes(); } else keep_going = true; if (not keep_going) { Runner::run("mem", no_update, redraw); return; } } //? Input actions for net box if (Net::shown) { bool keep_going = false; bool no_update = true; bool redraw = true; if (is_in(key, "b", "n")) { atomic_wait(Runner::active); int c_index = v_index(Net::interfaces, Net::selected_iface); if (c_index != (int)Net::interfaces.size()) { if (key == "b") { if (--c_index < 0) c_index = Net::interfaces.size() - 1; } else if (key == "n") { if (++c_index == (int)Net::interfaces.size()) c_index = 0; } Net::selected_iface = Net::interfaces.at(c_index); Net::rescale = true; } } else if (key == "y") { Config::flip("net_sync"); Net::rescale = true; } else if (key == "a") { Config::flip("net_auto"); Net::rescale = true; } else if (key == "z") { atomic_wait(Runner::active); auto& ndev = Net::current_net.at(Net::selected_iface); if (ndev.stat.at("download").offset + ndev.stat.at("upload").offset > 0) { ndev.stat.at("download").offset = 0; ndev.stat.at("upload").offset = 0; } else { ndev.stat.at("download").offset = ndev.stat.at("download").last + ndev.stat.at("download").rollover; ndev.stat.at("upload").offset = ndev.stat.at("upload").last + ndev.stat.at("upload").rollover; } no_update = false; } else keep_going = true; if (not keep_going) { Runner::run("net", no_update, redraw); return; } } } catch (const std::exception& e) { throw std::runtime_error { fmt::format(R"(Input::process("{}"))", e.what()) }; } } } aristocratos-btop-d43a485/src/btop_input.hpp000066400000000000000000000036531517514752700212370ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include #include using std::array; using std::atomic; using std::deque; using std::string; /* The input functions rely on the following termios parameters being set: Non-canonical mode (c_lflags & ~(ICANON)) VMIN and VTIME (c_cc) set to 0 These will automatically be set when running Term::init() from btop_tools.cpp */ //* Functions and variables for handling keyboard and mouse input namespace Input { struct Mouse_loc { int line, col, height, width; }; //? line, col, height, width extern std::unordered_map mouse_mappings; //* Signal mask used during polling read extern sigset_t signal_mask; extern atomic polling; //* Mouse column and line position extern array mouse_pos; //* Last entered key extern deque history; //* Poll keyboard & mouse input for ms and return input availability as a bool bool poll(const uint64_t timeout=0); //* Get a key or mouse action from input string get(); //* Wait until input is available and return key string wait(); //* Interrupt poll/wait void interrupt(); //* Clears last entered key void clear(); //* Process actions for input void process(const std::string_view key); } aristocratos-btop-d43a485/src/btop_log.cpp000066400000000000000000000072121517514752700206470ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #include "btop_log.hpp" #include "btop_shared.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace fs = std::filesystem; namespace Logger { namespace { constexpr auto ONE_MEGABYTE = 1024 << 10; struct State { std::mutex lock {}; std::once_flag print_header; Level level = Level::ERROR; std::optional path {}; }; [[nodiscard]] auto get_state() -> State& { static State state; return state; } auto rotate_log_file(fs::path& path) { std::error_code errc {}; if (fs::exists(path, errc) && !errc && fs::file_size(path, errc) > ONE_MEGABYTE && !errc) { auto old_path = path; old_path += ".1"; if (fs::exists(old_path, errc) && !errc) { fs::remove(old_path, errc); } if (!errc) { fs::rename(path, old_path, errc); } } return !errc; } class DropPrivilegeGuard { private: uid_t saved_euid {}; public: DropPrivilegeGuard() { saved_euid = geteuid(); auto real_uid = getuid(); if (saved_euid != real_uid && seteuid(real_uid) != 0) { throw std::runtime_error( fmt::format("Failed to drop privileges to write log file: {}", strerror(errno)) ); } } ~DropPrivilegeGuard() noexcept { if (saved_euid != geteuid()) { // Silently drop error status. #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-result" seteuid(saved_euid); #pragma GCC diagnostic pop } } DropPrivilegeGuard(const DropPrivilegeGuard&) = delete; DropPrivilegeGuard& operator=(const DropPrivilegeGuard&) = delete; }; } // namespace void init(const fs::path& path) { auto& state = get_state(); std::lock_guard guard { state.lock }; state.path = std::make_optional(path); } void set_log_level(Level level) { auto& state = get_state(); std::lock_guard guard { state.lock }; state.level = level; } void set_log_level(const std::string_view level) { auto& state = get_state(); auto it = std::ranges::find(log_levels, level); if (it != log_levels.end()) { std::lock_guard guard { state.lock }; state.level = static_cast(std::distance(log_levels.begin(), it)); } } namespace detail { [[nodiscard]] auto is_enabled(Level level) -> bool { auto& state = get_state(); return state.level >= level && state.path.has_value(); } void log_write(Level level, const std::string_view msg) { auto& state = get_state(); auto guard = std::lock_guard { state.lock }; if (!is_enabled(level) || !state.path.has_value()) { return; } std::string buffer {}; std::call_once(state.print_header, [&buffer]() { fmt::format_to(std::back_inserter(buffer), "\n===> btop++ v{}\n", Global::Version); }); auto now = std::chrono::system_clock::now(); auto seconds = std::chrono::time_point_cast(now); fmt::format_to( std::back_inserter(buffer), "{:%F (%T)} | {}: {}\n", seconds, log_levels.at(std::to_underlying(level)), msg ); DropPrivilegeGuard privilege_guard {}; auto& path = state.path.value(); if (!rotate_log_file(path)) { return; } auto file = std::ofstream { path, std::ios::app }; if (!file.is_open()) { return; } file << buffer; } } // namespace detail } // namespace Logger aristocratos-btop-d43a485/src/btop_log.hpp000066400000000000000000000035141517514752700206550ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #pragma once #include #include #include #include #include #include #include #include namespace Logger { enum class Level : std::uint8_t { DISABLED = 0, ERROR = 1, WARNING = 2, INFO = 3, DEBUG = 4, }; const std::vector log_levels { "DISABLED", "ERROR", "WARNING", "INFO", "DEBUG" }; namespace detail { auto is_enabled(Level level) -> bool; void log_write(Level level, const std::string_view msg); } // namespace detail void init(const std::filesystem::path& path); void set_log_level(Level level); void set_log_level(const std::string_view level); template inline void error(fmt::format_string fmt, T&&... args) { // Check if log level is enabled before allocating string. if (detail::is_enabled(Level::ERROR)) { detail::log_write(Level::ERROR, fmt::format(fmt, std::forward(args)...)); } } template inline void warning(fmt::format_string fmt, T&&... args) { // Check if log level is enabled before allocating string. if (detail::is_enabled(Level::WARNING)) { detail::log_write(Level::WARNING, fmt::format(fmt, std::forward(args)...)); } } template inline void info(fmt::format_string fmt, T&&... args) { // Check if log level is enabled before allocating string. if (detail::is_enabled(Level::INFO)) { detail::log_write(Level::INFO, fmt::format(fmt, std::forward(args)...)); } } template inline void debug(fmt::format_string fmt, T&&... args) { // Check if log level is enabled before allocating string. if (detail::is_enabled(Level::DEBUG)) { detail::log_write(Level::DEBUG, fmt::format(fmt, std::forward(args)...)); } } } // namespace Logger aristocratos-btop-d43a485/src/btop_menu.cpp000066400000000000000000001667451517514752700210530ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include "btop_menu.hpp" #include "btop_config.hpp" #include "btop_draw.hpp" #include "btop_log.hpp" #include "btop_shared.hpp" #include "btop_theme.hpp" #include "btop_tools.hpp" #include #include #include #include #include #include #include #include #include using std::array; using std::ceil; using std::max; using std::min; using std::ref; using std::views::iota; using namespace Tools; namespace fs = std::filesystem; namespace Menu { atomic active (false); string bg; bool redraw{true}; int currentMenu = -1; msgBox messageBox; int signalToSend{}; int signalKillRet{}; const array P_Signals = { "0", #ifdef __linux__ #if defined(__hppa__) "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "SIGSTKFLT", "SIGFPE", "SIGKILL", "SIGBUS", "SIGSEGV", "SIGXCPU", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGUSR1", "SIGUSR2", "SIGCHLD", "SIGPWR", "SIGVTALRM", "SIGPROF", "SIGIO", "SIGWINCH", "SIGSTOP", "SIGTSTP", "SIGCONT", "SIGTTIN", "SIGTTOU", "SIGURG", "SIGXFSZ", "SIGSYS" #elif defined(__mips__) "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS", "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGUSR1", "SIGUSR2", "SIGCHLD", "SIGPWR", "SIGWINCH", "SIGURG", "SIGIO", "SIGSTOP", "SIGTSTP", "SIGCONT", "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU", "SIGXFSZ" #elif defined(__alpha__) "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS", "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGURG", "SIGSTOP", "SIGTSTP", "SIGCONT", "SIGCHLD", "SIGTTIN", "SIGTTOU", "SIGIO", "SIGXCPU", "SIGXFSZ", "SIGVTALRM", "SIGPROF", "SIGWINCH", "SIGPWR", "SIGUSR1", "SIGUSR2" #elif defined (__sparc__) "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS", "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGURG", "SIGSTOP", "SIGTSTP", "SIGCONT", "SIGCHLD", "SIGTTIN", "SIGTTOU", "SIGIO", "SIGXCPU", "SIGXFSZ", "SIGVTALRM", "SIGPROF", "SIGWINCH", "SIGLOST", "SIGUSR1", "SIGUSR2" #else "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "SIGBUS", "SIGFPE", "SIGKILL", "SIGUSR1", "SIGSEGV", "SIGUSR2", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGSTKFLT", "SIGCHLD", "SIGCONT", "SIGSTOP", "SIGTSTP", "SIGTTIN", "SIGTTOU", "SIGURG", "SIGXCPU", "SIGXFSZ", "SIGVTALRM", "SIGPROF", "SIGWINCH", "SIGIO", "SIGPWR", "SIGSYS" #endif #elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__APPLE__) "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS", "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM", "SIGURG", "SIGSTOP", "SIGTSTP", "SIGCONT", "SIGCHLD", "SIGTTIN", "SIGTTOU", "SIGIO", "SIGXCPU", "SIGXFSZ", "SIGVTALRM", "SIGPROF", "SIGWINCH", "SIGINFO", "SIGUSR1", "SIGUSR2" #else "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", "SIGABRT", "7", "SIGFPE", "SIGKILL", "10", "SIGSEGV", "12", "SIGPIPE", "SIGALRM", "SIGTERM", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31" #endif }; std::unordered_map mouse_mappings; const array, 3> menu_normal = { array{ "โ”Œโ”€โ”โ”Œโ”€โ”โ”Œโ”ฌโ”โ”ฌโ”Œโ”€โ”โ”Œโ”โ”Œโ”Œโ”€โ”", "โ”‚ โ”‚โ”œโ”€โ”˜ โ”‚ โ”‚โ”‚ โ”‚โ”‚โ”‚โ”‚โ””โ”€โ”", "โ””โ”€โ”˜โ”ด โ”ด โ”ดโ””โ”€โ”˜โ”˜โ””โ”˜โ””โ”€โ”˜" }, { "โ”ฌ โ”ฌโ”Œโ”€โ”โ”ฌ โ”Œโ”€โ”", "โ”œโ”€โ”คโ”œโ”ค โ”‚ โ”œโ”€โ”˜", "โ”ด โ”ดโ””โ”€โ”˜โ”ดโ”€โ”˜โ”ด " }, { "โ”Œโ”€โ” โ”ฌ โ”ฌ โ”ฌโ”Œโ”ฌโ”", "โ”‚โ”€โ”ผโ”โ”‚ โ”‚ โ”‚ โ”‚ ", "โ””โ”€โ”˜โ””โ””โ”€โ”˜ โ”ด โ”ด " } }; const array, 3> menu_selected = { array{ "โ•”โ•โ•—โ•”โ•โ•—โ•”โ•ฆโ•—โ•ฆโ•”โ•โ•—โ•”โ•—โ•”โ•”โ•โ•—", "โ•‘ โ•‘โ• โ•โ• โ•‘ โ•‘โ•‘ โ•‘โ•‘โ•‘โ•‘โ•šโ•โ•—", "โ•šโ•โ•โ•ฉ โ•ฉ โ•ฉโ•šโ•โ•โ•โ•šโ•โ•šโ•โ•" }, { "โ•ฆ โ•ฆโ•”โ•โ•—โ•ฆ โ•”โ•โ•—", "โ• โ•โ•ฃโ• โ•ฃ โ•‘ โ• โ•โ•", "โ•ฉ โ•ฉโ•šโ•โ•โ•ฉโ•โ•โ•ฉ " }, { "โ•”โ•โ•— โ•ฆ โ•ฆ โ•ฆโ•”โ•ฆโ•— ", "โ•‘โ•โ•ฌโ•—โ•‘ โ•‘ โ•‘ โ•‘ ", "โ•šโ•โ•โ•šโ•šโ•โ• โ•ฉ โ•ฉ " } }; const array menu_width = {19, 12, 12}; const vector> help_text = { {"Mouse 1", "Clicks buttons and selects in process list."}, {"Mouse scroll", "Scrolls any scrollable list/text under cursor."}, {"Esc, m", "Toggles main menu."}, {"p", "Cycle view presets forwards."}, {"shift + p", "Cycle view presets backwards."}, {"1", "Toggle CPU box."}, {"2", "Toggle MEM box."}, {"3", "Toggle NET box."}, {"4", "Toggle PROC box."}, {"5", "Toggle GPU box."}, {"d", "Toggle disks view in MEM box."}, {"F2, o", "Shows options."}, {"F1, ?, h", "Shows this window."}, {"ctrl + z", "Sleep program and put in background."}, {"ctrl + r", "Reloads config file from disk."}, {"q, ctrl + c", "Quits program."}, {"+, -", "Add/Subtract 100ms to/from update timer."}, {"Up, Down", "Select in process list."}, {"Enter", "Show detailed information for selected process."}, {"Spacebar", "Expand/collapse the selected process in tree view."}, {"C", "Expand/collapse the selected process' children."}, {"Pg Up, Pg Down", "Jump 1 page in process list."}, {"Home, End", "Jump to first or last page in process list."}, {"Left, Right", "Select previous/next sorting column."}, {"b, n", "Select previous/next network device."}, {"i", "Toggle disks io mode with big graphs."}, {"z", "Toggle totals reset for current network device"}, {"a", "Toggle auto scaling for the network graphs."}, {"y", "Toggle synced scaling mode for network graphs."}, {"f, /", "To enter a process filter. Start with ! for regex."}, {"F", "Follow selected process."}, {"u", "Pause process list."}, {"delete", "Clear any entered filter."}, {"c", "Toggle per-core cpu usage of processes."}, {"r", "Reverse sorting order in processes box."}, {"e", "Toggle processes tree view."}, {"E", "Collapse/expand all processes in tree view."}, {"%", "Toggles memory display mode in processes box."}, {"Selected +, -", "Expand/collapse the selected process in tree view."}, {"Selected t", "Terminate selected process with SIGTERM - 15."}, {"Selected k", "Kill selected process with SIGKILL - 9."}, {"Selected s", "Select or enter signal to send to process."}, {"Selected N", "Select new nice value for selected process."}, {"", " "}, {"", "For bug reporting and project updates, visit:"}, {"", "https://github.com/aristocratos/btop"}, }; const vector>> categories = { { {"color_theme", "Set color theme.", "", "Choose from all theme files in (usually)", "\"/usr/[local/]share/btop/themes\" and", "\"~/.config/btop/themes\".", "", "\"Default\" for builtin default theme.", "\"TTY\" for builtin 16-color theme.", "", "For theme updates see:", "https://github.com/aristocratos/btop"}, {"theme_background", "If the theme set background should be shown.", "", "Set to False if you want terminal background", "transparency."}, {"truecolor", "Sets if 24-bit truecolor should be used.", "", "Will convert 24-bit colors to 256 color", "(6x6x6 color cube) if False.", "", "Set to False if your terminal doesn't have", "truecolor support and can't convert to", "256-color."}, {"force_tty", "TTY mode.", "", "Set to true to force tty mode regardless", "if a real tty has been detected or not.", "", "Will force 16-color mode and TTY theme,", "set all graph symbols to \"tty\" and swap", "out other non tty friendly symbols."}, {"vim_keys", "Enable vim keys.", "Set to True to enable \"h,j,k,l\" keys for", "directional control in lists.", "", "Conflicting keys for", "h (help) and k (kill)", "is accessible while holding shift."}, {"disable_mouse", "Disable all mouse events."}, {"disable_presets", "Disable the presets.", "", "\"Off\" All presets are enabled.", "", "\"Default\" preset is disabled.", "", "\"Custom\" presets are disabled.", "", "\"All\" presets are disabled."}, {"presets", "Define presets for the layout of the boxes.", "", "Preset 0 is always all boxes shown with", "default settings.", "Max 9 presets.", "", "Format: \"box_name:P:G,box_name:P:G\"", "P=(0 or 1) for alternate positions.", "G=graph symbol to use for box.", "", "Use whitespace \" \" as separator between", "different presets.", "", "Example:", "\"mem:0:tty,proc:1:default cpu:0:braille\""}, {"shown_boxes", "Manually set which boxes to show.", "", "Available values are \"cpu mem net proc\".", #ifdef GPU_SUPPORT "Or \"gpu0\" through \"gpu5\" for GPU boxes.", #endif "Separate values with whitespace.", "", "Toggle between presets with key \"p\"."}, {"update_ms", "Update time in milliseconds.", "", "Recommended 2000 ms or above for better", "sample times for graphs.", "", "Min value: 100 ms", "Max value: 86400000 ms = 24 hours."}, {"rounded_corners", "Rounded corners on boxes.", "", "True or False", "", "Is always False if TTY mode is ON."}, {"terminal_sync", "Output synchronization.", "", "Use terminal synchronized output sequences", "to reduce flickering on supported terminals.", "", "True or False."}, {"graph_symbol", "Default symbols to use for graph creation.", "", "\"braille\", \"block\" or \"tty\".", "", "\"braille\" offers the highest resolution but", "might not be included in all fonts.", "", "\"block\" has half the resolution of braille", "but uses more common characters.", "", "\"tty\" uses only 3 different symbols but will", "work with most fonts.", "", "Note that \"tty\" only has half the horizontal", "resolution of the other two,", "so will show a shorter historical view."}, {"clock_format", "Draw a clock at top of screen.", "(Only visible if cpu box is enabled!)", "", "Formatting according to strftime, empty", "string to disable.", "", "Custom formatting options:", "\"/host\" = hostname", "\"/user\" = username", "\"/uptime\" = system uptime", "", "Examples of strftime formats:", "\"%X\" = locale HH:MM:SS", "\"%H\" = 24h hour, \"%I\" = 12h hour", "\"%M\" = minute, \"%S\" = second", "\"%d\" = day, \"%m\" = month, \"%y\" = year"}, {"base_10_sizes", "Use base 10 for bits and bytes sizes.", "", "Uses KB = 1000 instead of KiB = 1024,", "MB = 1000KB instead of MiB = 1024KiB,", "and so on.", "", "True or False."}, {"background_update", "Update main ui when menus are showing.", "", "True or False.", "", "Set this to false if the menus is flickering", "too much for a comfortable experience."}, {"show_battery", "Show battery stats.", "(Only visible if cpu box is enabled!)", "", "Show battery stats in the top right corner", "if a battery is present."}, {"selected_battery", "Select battery.", "", "Which battery to use if multiple are present.", "Can be both batteries and UPS.", "", "\"Auto\" for auto detection."}, {"show_battery_watts", "Show battery power.", "", "Show discharge power when discharging.", "Show charging power when charging."}, {"log_level", "Set loglevel for error.log", "", "\"ERROR\", \"WARNING\", \"INFO\" and \"DEBUG\".", "", "The level set includes all lower levels,", "i.e. \"DEBUG\" will show all logging info."}, {"save_config_on_exit", "Save config on exit.", "", "Automatically save current settings to", "config file on exit.", "", "When this is toggled from True to False", "a save is immediately triggered.", "This way a manual save can be done by", "toggling this setting on and off again."} }, { {"cpu_bottom", "Cpu box location.", "", "Show cpu box at bottom of screen instead", "of top."}, {"graph_symbol_cpu", "Graph symbol to use for graphs in cpu box.", "", "\"default\", \"braille\", \"block\" or \"tty\".", "", "\"default\" for the general default symbol.",}, {"cpu_graph_upper", "Cpu upper graph.", "", "Sets the CPU/GPU stat shown in upper half of", "the CPU graph.", "", "CPU:", "\"total\" = Total cpu usage. (Auto)", "\"user\" = User mode cpu usage.", "\"system\" = Kernel mode cpu usage.", "+ more depending on kernel.", #ifdef GPU_SUPPORT "", "GPU:", "\"gpu-totals\" = GPU usage split by device.", "\"gpu-vram-totals\" = VRAM usage split by GPU.", "\"gpu-pwr-totals\" = Power usage split by GPU.", "\"gpu-average\" = Avg usage of all GPUs.", "\"gpu-vram-total\" = VRAM usage of all GPUs.", "\"gpu-pwr-total\" = Power usage of all GPUs.", "Not all stats are supported on all devices." #endif }, {"cpu_graph_lower", "Cpu lower graph.", "", "Sets the CPU/GPU stat shown in lower half of", "the CPU graph.", "", "CPU:", "\"total\" = Total cpu usage.", "\"user\" = User mode cpu usage.", "\"system\" = Kernel mode cpu usage.", "+ more depending on kernel.", #ifdef GPU_SUPPORT "", "GPU:", "\"gpu-totals\" = GPU usage split/device. (Auto)", "\"gpu-vram-totals\" = VRAM usage split by GPU.", "\"gpu-pwr-totals\" = Power usage split by GPU.", "\"gpu-average\" = Avg usage of all GPUs.", "\"gpu-vram-total\" = VRAM usage of all GPUs.", "\"gpu-pwr-total\" = Power usage of all GPUs.", "Not all stats are supported on all devices." #endif }, {"cpu_invert_lower", "Toggles orientation of the lower CPU graph.", "", "True or False."}, {"cpu_single_graph", "Completely disable the lower CPU graph.", "", "Shows only upper CPU graph and resizes it", "to fit to box height.", "", "True or False."}, #ifdef GPU_SUPPORT {"show_gpu_info", "Show gpu info in cpu box.", "", "Toggles gpu stats in cpu box and the", "gpu graph (if \"cpu_graph_lower\" is set to", "\"Auto\").", "", "\"Auto\" to show when no gpu box is shown.", "\"On\" to always show.", "\"Off\" to never show."}, #endif {"check_temp", "Enable cpu temperature reporting.", "", "True or False."}, {"cpu_sensor", "Cpu temperature sensor.", "", "Select the sensor that corresponds to", "your cpu temperature.", "", "Set to \"Auto\" for auto detection."}, {"show_coretemp", "Show temperatures for cpu cores.", "", "Only works if check_temp is True and", "the system is reporting core temps."}, {"cpu_core_map", "Custom mapping between core and coretemp.", "", "Can be needed on certain cpus to get correct", "temperature for correct core.", "", "Use lm-sensors or similar to see which cores", "are reporting temperatures on your machine.", "", "Format: \"X:Y\"", "X=core with wrong temp.", "Y=core with correct temp.", "Use space as separator between multiple", "entries.", "", "Example: \"4:0 5:1 6:3\""}, {"temp_scale", "Which temperature scale to use.", "", "Celsius, default scale.", "", "Fahrenheit, the american one.", "", "Kelvin, 0 = absolute zero, 1 degree change", "equals 1 degree change in Celsius.", "", "Rankine, 0 = absolute zero, 1 degree change", "equals 1 degree change in Fahrenheit."}, {"show_cpu_freq", "Show CPU frequency.", "", "Can cause slowdowns on systems with many", "cores and certain kernel versions."}, #ifdef __linux__ {"freq_mode", "How the CPU frequency will be displayed.", "", "First, get the frequency from the first", "core.", "", "Range, show the lowest and the highest", "frequency.", "", "Lowest, the lowest frequency.", "", "Highest, the highest frequency.", "", "Average, sum and divide."}, #endif {"custom_cpu_name", "Custom cpu model name in cpu percentage box.", "", "Empty string to disable."}, {"show_uptime", "Shows the system uptime in the CPU box.", "", "Can also be shown in the clock by using", "\"/uptime\" in the formatting.", "", "True or False."}, {"show_cpu_watts", "Shows the CPU power consumption in watts.", "", "Requires running `make setcap` or", "`make setuid` or running with sudo.", "", "True or False."}, }, #ifdef GPU_SUPPORT { {"nvml_measure_pcie_speeds", "Measure PCIe throughput on NVIDIA cards.", "", "May impact performance on certain cards.", "", "True or False."}, {"rsmi_measure_pcie_speeds", "Measure PCIe throughput on AMD cards.", "", "May impact performance on certain cards.", "", "True or False."}, {"graph_symbol_gpu", "Graph symbol to use for graphs in gpu box.", "", "\"default\", \"braille\", \"block\" or \"tty\".", "", "\"default\" for the general default symbol.",}, {"gpu_mirror_graph", "Horizontally mirror the GPU graph.", "", "True or False."}, {"shown_gpus", "Manually set which gpu vendors to show.", "", "Available values are", "\"nvidia\", \"amd\", \"intel\",", "and \"apple\".", "Separate values with whitespace.", "", "A restart is required to apply changes."}, {"custom_gpu_name0", "Custom gpu0 model name in gpu stats box.", "", "Empty string to disable."}, {"custom_gpu_name1", "Custom gpu1 model name in gpu stats box.", "", "Empty string to disable."}, {"custom_gpu_name2", "Custom gpu2 model name in gpu stats box.", "", "Empty string to disable."}, {"custom_gpu_name3", "Custom gpu3 model name in gpu stats box.", "", "Empty string to disable."}, {"custom_gpu_name4", "Custom gpu4 model name in gpu stats box.", "", "Empty string to disable."}, {"custom_gpu_name5", "Custom gpu5 model name in gpu stats box.", "", "Empty string to disable."}, }, #endif { {"mem_below_net", "Mem box location.", "", "Show mem box below net box instead of above."}, {"graph_symbol_mem", "Graph symbol to use for graphs in mem box.", "", "\"default\", \"braille\", \"block\" or \"tty\".", "", "\"default\" for the general default symbol.",}, {"mem_graphs", "Show graphs for memory values.", "", "True or False."}, {"show_disks", "Split memory box to also show disks.", "", "True or False."}, {"show_io_stat", "Toggle IO activity graphs.", "", "Show small IO graphs that for disk activity", "(disk busy time) when not in IO mode.", "", "True or False."}, {"io_mode", "Toggles io mode for disks.", "", "Shows big graphs for disk read/write speeds", "instead of used/free percentage meters.", "", "True or False."}, {"io_graph_combined", "Toggle combined read and write graphs.", "", "Only has effect if \"io mode\" is True.", "", "True or False."}, {"io_graph_speeds", "Set top speeds for the io graphs.", "", "Manually set which speed in MiB/s that", "equals 100 percent in the io graphs.", "(100 MiB/s by default).", "", "Format: \"device:speed\" separate disks with", "whitespace \" \".", "", "Example: \"/dev/sda:100, /dev/sdb:20\"."}, {"show_swap", "If swap memory should be shown in memory box.", "", "True or False."}, {"swap_disk", "Show swap as a disk.", "", "Ignores show_swap value above.", "Inserts itself after first disk."}, {"only_physical", "Filter out non physical disks.", "", "Set this to False to include network disks,", "RAM disks and similar.", "", "True or False."}, {"use_fstab", "(Linux) Read disks list from /etc/fstab.", "", "This also disables only_physical.", "", "True or False."}, {"zfs_hide_datasets", "(Linux) Hide ZFS datasets in disks list.", "", "Setting this to True will hide all datasets,", "and only show ZFS pools.", "", "(IO stats will be calculated per-pool)", "", "True or False."}, {"disk_free_priv", "(Linux) Type of available disk space.", "", "Set to true to show how much disk space is", "available for privileged users.", "", "Set to false to show available for normal", "users."}, {"disks_filter", "Optional filter for shown disks.", "", "Should be full path of a mountpoint.", "Separate multiple values with", "whitespace \" \".", "", "Only disks matching the filter will be shown.", "Prepend \033[3mexclude=\033[23m to only show disks ", "not matching the filter.", "", "Examples:", "/boot /home/user", "exclude=/boot /home/user"}, {"zfs_arc_cached", "(Linux) Count ZFS ARC as cached memory.", "", "Add ZFS ARC used to cached memory and", "ZFS ARC available to available memory.", "These are otherwise reported by the Linux", "kernel as used memory.", "", "True or False."}, }, { {"graph_symbol_net", "Graph symbol to use for graphs in net box.", "", "\"default\", \"braille\", \"block\" or \"tty\".", "", "\"default\" for the general default symbol.",}, {"swap_upload_download", "Swap the positions of the upload and download", "graphs.", "", "This allows for a more \"intuitive\" view", "with download being down, on the bottom."}, {"net_download", "Fixed network graph download value.", "", "Value in Mebibits, default \"100\".", "", "Can be toggled with auto button."}, {"net_upload", "Fixed network graph upload value.", "", "Value in Mebibits, default \"100\".", "", "Can be toggled with auto button."}, {"net_auto", "Start in network graphs auto rescaling mode.", "", "Ignores any values set above at start and", "rescales down to 10Kibibytes at the lowest.", "", "True or False."}, {"net_sync", "Network scale sync.", "", "Syncs the scaling for download and upload to", "whichever currently has the highest scale.", "", "True or False."}, {"net_iface", "Network Interface.", "", "Manually set the starting Network Interface.", "", "Will otherwise automatically choose the NIC", "with the highest total download since boot."}, {"base_10_bitrate", "Base 10 bitrate", "", "True: Use SI prefixes for bitrates", " (1000Kbps = 1Mbps)", "False: Use binary prefixes for bitrates", " (1024Kibps = 1Mibps)", "Auto: Use the General -> Base 10 Sizes", " setting for bitrates", "", "True, False, or Auto",}, }, { {"proc_left", "Proc box location.", "", "Show proc box on left side of screen", "instead of right."}, {"graph_symbol_proc", "Graph symbol to use for graphs in proc box.", "", "\"default\", \"braille\", \"block\" or \"tty\".", "", "\"default\" for the general default symbol.",}, {"proc_sorting", "Processes sorting option.", "", "Possible values:", "\"pid\", \"program\", \"arguments\", \"threads\",", "\"user\", \"memory\", \"cpu lazy\" and", "\"cpu direct\".", "", "\"cpu lazy\" updates top process over time.", "\"cpu direct\" updates top process", "directly."}, {"proc_reversed", "Reverse processes sorting order.", "", "True or False."}, {"proc_tree", "Processes tree view.", "", "Set true to show processes grouped by", "parents with lines drawn between parent", "and child process."}, {"proc_aggregate", "Aggregate child's resources in parent.", "", "In tree-view, include all child resources", "with the parent even while expanded."}, {"proc_colors", "Enable colors in process view.", "", "True or False."}, {"proc_gradient", "Enable process view gradient fade.", "", "Fades from top or current selection.", "Max fade value is equal to current themes", "\"inactive_fg\" color value."}, {"proc_per_core", "Process usage per core.", "", "If process cpu usage should be of the core", "it's running on or usage of the total", "available cpu power.", "", "If true and process is multithreaded", "cpu usage can reach over 100%."}, {"proc_mem_bytes", "Show memory as bytes in process list.", " ", "Will show percentage of total memory", "if False."}, {"keep_dead_proc_usage", "Cpu and Mem usage for dead processes", "", "Set true if process should preserve the cpu", "and memory usage of when it died while", "paused."}, {"proc_cpu_graphs", "Show cpu graph for each process.", "", "True or False"}, {"proc_filter_kernel", "(Linux) Filter kernel processes from output.", "", "Set to 'True' to filter out internal", "processes started by the Linux kernel."}, {"proc_follow_detailed", "Follow selected process with detailed view", "", "If set to 'True' then when opening the", "detailed view, the process will be", "followed in the list. Pressing enter", "again will close the detailed view", "and stop following the process."}, } }; msgBox::msgBox() {} msgBox::msgBox(int width, int boxtype, const vector& content, const std::string_view title) : width(width), boxtype(boxtype) { auto tty_mode = Config::getB("tty_mode"); auto rounded = Config::getB("rounded_corners"); const auto& right_up = (tty_mode or not rounded ? Symbols::right_up : Symbols::round_right_up); const auto& left_up = (tty_mode or not rounded ? Symbols::left_up : Symbols::round_left_up); const auto& right_down = (tty_mode or not rounded ? Symbols::right_down : Symbols::round_right_down); const auto& left_down = (tty_mode or not rounded ? Symbols::left_down : Symbols::round_left_down); height = content.size() + 7; x = Term::width / 2 - width / 2; y = Term::height/2 - height/2; if (boxtype == 2) selected = 1; button_left = left_up + Symbols::h_line * 6 + Mv::l(7) + Mv::d(2) + left_down + Symbols::h_line * 6 + Mv::l(7) + Mv::u(1) + Symbols::v_line; button_right = Symbols::v_line + Mv::l(7) + Mv::u(1) + Symbols::h_line * 6 + right_up + Mv::l(7) + Mv::d(2) + Symbols::h_line * 6 + right_down + Mv::u(2); box_contents = Draw::createBox(x, y, width, height, Theme::c("hi_fg"), true, title) + Mv::d(1); for (const auto& line : content) { box_contents += Mv::save + Mv::r(max((size_t)0, (width / 2) - (Fx::uncolor(line).size() / 2) - 1)) + line + Mv::restore + Mv::d(1); } } string msgBox::operator()() { string out; int pos = width / 2 - (boxtype == 0 ? 6 : 14); const auto first_color = (selected == 0 ? Theme::c("hi_fg") : Theme::c("div_line")); out = Mv::d(1) + Mv::r(pos) + Fx::b + first_color + button_left + (selected == 0 ? Theme::c("title") : Theme::c("main_fg") + Fx::ub) + (boxtype == 0 ? " Ok " : " Yes ") + first_color + button_right; mouse_mappings["button1"] = Input::Mouse_loc{y + height - 4, x + pos + 1, 3, 12 + (boxtype > 0 ? 1 : 0)}; if (boxtype > 0) { const auto second_color = (selected == 1 ? Theme::c("hi_fg") : Theme::c("div_line")); out += Mv::r(2) + second_color + button_left + (selected == 1 ? Theme::c("title") : Theme::c("main_fg") + Fx::ub) + " No " + second_color + button_right; mouse_mappings["button2"] = Input::Mouse_loc{y + height - 4, x + pos + 15 + (boxtype > 0 ? 1 : 0), 3, 12}; } return box_contents + out + Fx::reset; } //? Process input int msgBox::input(const string& key) { if (key.empty()) return Invalid; if (is_in(key, "escape", "backspace", "q") or key == "button2") { return No_Esc; } else if (key == "button1" or (boxtype == 0 and str_to_upper(key) == "O")) { return Ok_Yes; } else if (is_in(key, "enter", "space")) { return selected + 1; } else if (boxtype == 0) { return Invalid; } else if (str_to_upper(key) == "Y") { return Ok_Yes; } else if (str_to_upper(key) == "N") { return No_Esc; } else if (is_in(key, "right", "tab")) { if (++selected > 1) selected = 0; return Select; } else if (is_in(key, "left", "shift_tab")) { if (--selected < 0) selected = 1; return Select; } return Invalid; } void msgBox::clear() { box_contents.clear(); box_contents.shrink_to_fit(); button_left.clear(); button_left.shrink_to_fit(); button_right.clear(); button_right.shrink_to_fit(); mouse_mappings.erase("button1"); mouse_mappings.erase("button2"); } enum menuReturnCodes { NoChange, Changed, Closed, Switch }; static int signalChoose(const string& key) { static std::optional s_pid; static int x{}; static int y{}; static int selected_signal = -1; if (!s_pid) { s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); } if (bg.empty()) selected_signal = -1; auto& out = Global::overlay; int retval = Changed; if (redraw) { x = Term::width/2 - 40; y = Term::height/2 - 9; bg = Draw::createBox(x + 2, y, 78, 19, Theme::c("hi_fg"), true, "signals"); bg += Mv::to(y+2, x+3) + Theme::c("title") + Fx::b + cjust("Send signal to PID " + to_string(s_pid.value()) + " (" + uresize((s_pid == Config::getI("detailed_pid") ? Proc::detailed.entry.name : Config::getS("selected_name")), 30) + ")", 76); } else if (is_in(key, "escape", "q")) { goto MenuClosing; } else if (key.starts_with("button_")) { if (int new_select = stoi(key.substr(7)); new_select == selected_signal) goto ChooseEntering; else selected_signal = new_select; } else if (is_in(key, "enter", "space") and selected_signal >= 0) { ChooseEntering: signalKillRet = 0; if (s_pid < 1) { signalKillRet = ESRCH; menuMask.set(SignalReturn); } else if (kill(s_pid.value(), selected_signal) != 0) { signalKillRet = errno; menuMask.set(SignalReturn); } goto MenuClosing; } else if (key.size() == 1 and isdigit(key.at(0)) and selected_signal < 10) { selected_signal = std::min(std::stoi((selected_signal < 1 ? key : to_string(selected_signal) + key)), 64); } else if (key == "backspace" and selected_signal != -1) { selected_signal = (selected_signal < 10 ? -1 : selected_signal / 10); } else if (is_in(key, "up", "k") and selected_signal != 16) { if (selected_signal == 1) selected_signal = 31; else if (selected_signal < 6) selected_signal += 25; else { bool offset = (selected_signal > 16); selected_signal -= 5; if (selected_signal <= 16 and offset) selected_signal--; } } else if (is_in(key, "down", "j")) { if (selected_signal == 31) selected_signal = 1; else if (selected_signal < 1 or selected_signal == 16) selected_signal = 1; else if (selected_signal > 26) selected_signal -= 25; else { bool offset = (selected_signal < 16); selected_signal += 5; if (selected_signal >= 16 and offset) selected_signal++; if (selected_signal > 31) selected_signal = 31; } } else if (is_in(key, "left", "h") and selected_signal > 0 and selected_signal != 16) { if (--selected_signal < 1) selected_signal = 31; else if (selected_signal == 16) selected_signal--; } else if (is_in(key, "right", "l") and selected_signal <= 31 and selected_signal != 16) { if (++selected_signal > 31) selected_signal = 1; else if (selected_signal == 16) selected_signal++; } else { retval = NoChange; } if (retval == Changed) { int cy = y+4, cx = x+4; out = bg + Mv::to(cy++, x+3) + Theme::c("main_fg") + Fx::ub + rjust("Enter signal number: ", 48) + Theme::c("hi_fg") + (selected_signal >= 0 ? to_string(selected_signal) : "") + Theme::c("main_fg") + Fx::bl + "โ–ˆ" + Fx::ubl; auto sig_str = to_string(selected_signal); for (int count = 0, i = 0; const auto& sig : P_Signals) { if (count == 0 or count == 16) { count++; continue; } if (i++ % 5 == 0) { ++cy; cx = x+4; } out += Mv::to(cy, cx); if (count == selected_signal) out += Theme::c("selected_bg") + Theme::c("selected_fg") + Fx::b + ljust(to_string(count), 3) + ljust('(' + sig + ')', 12) + Fx::reset; else out += Theme::c("hi_fg") + ljust(to_string(count), 3) + Theme::c("main_fg") + ljust('(' + sig + ')', 12); if (redraw) mouse_mappings["button_" + to_string(count)] = {cy, cx, 1, 15}; count++; cx += 15; } cy++; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust( "โ†‘ โ†“ โ† โ†’", 33, true) + Theme::c("main_fg") + Fx::ub + " | To choose signal."; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust("0-9", 33) + Theme::c("main_fg") + Fx::ub + " | Enter manually."; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust("ENTER", 33) + Theme::c("main_fg") + Fx::ub + " | To send signal."; mouse_mappings["enter"] = {cy, x, 1, 73}; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust("ESC or \"q\"", 33) + Theme::c("main_fg") + Fx::ub + " | To abort."; mouse_mappings["escape"] = {cy, x, 1, 73}; out += Fx::reset; } return (redraw ? Changed : retval); MenuClosing: s_pid.reset(); return Closed; } static int sizeError(const string& key) { if (redraw) { vector cont_vec { Fx::b + Theme::g("used")[100] + "Error:" + Theme::c("main_fg") + Fx::ub, "Terminal size too small to" + Fx::reset, "display menu or box!" + Fx::reset }; messageBox = Menu::msgBox{45, 0, cont_vec, "error"}; Global::overlay = messageBox(); } auto ret = messageBox.input(key); if (ret == msgBox::Ok_Yes or ret == msgBox::No_Esc) { messageBox.clear(); return Closed; } else if (redraw) { return Changed; } return NoChange; } static int signalSend(const string& key) { static std::optional s_pid; if (!s_pid) { s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); } if (redraw) { atomic_wait(Runner::active); auto& p_name = (s_pid == Config::getI("detailed_pid") ? Proc::detailed.entry.name : Config::getS("selected_name")); vector cont_vec = { Fx::b + Theme::c("main_fg") + "Send signal: " + Fx::ub + Theme::c("hi_fg") + to_string(signalToSend) + (signalToSend > 0 and signalToSend <= 32 ? Theme::c("main_fg") + " (" + P_Signals.at(signalToSend) + ')' : ""), Fx::b + Theme::c("main_fg") + "To PID: " + Fx::ub + Theme::c("hi_fg") + to_string(s_pid.value()) + Theme::c("main_fg") + " (" + uresize(p_name, 16) + ')' + Fx::reset, }; messageBox = Menu::msgBox{50, 1, cont_vec, (signalToSend > 1 and signalToSend <= 32 and signalToSend != 17 ? P_Signals.at(signalToSend) : "signal")}; Global::overlay = messageBox(); } auto ret = messageBox.input(key); if (ret == msgBox::Ok_Yes) { signalKillRet = 0; if (kill(s_pid.value(), signalToSend) != 0) { signalKillRet = errno; menuMask.set(SignalReturn); } messageBox.clear(); goto MenuClosing; } else if (ret == msgBox::No_Esc) { messageBox.clear(); goto MenuClosing; } else if (ret == msgBox::Select) { Global::overlay = messageBox(); return Changed; } else if (redraw) { return Changed; } return NoChange; MenuClosing: s_pid.reset(); return Closed; } static int signalReturn(const string& key) { if (redraw) { vector cont_vec; cont_vec.push_back(Fx::b + Theme::g("used")[100] + "Failure:" + Theme::c("main_fg") + Fx::ub); if (signalKillRet == EINVAL) { cont_vec.push_back("Unsupported signal!" + Fx::reset); } else if (signalKillRet == EPERM) { cont_vec.push_back("Insufficient permissions to send signal!" + Fx::reset); } else if (signalKillRet == ESRCH) { cont_vec.push_back("Process not found!" + Fx::reset); } else { cont_vec.push_back("Unknown error! (errno: " + to_string(signalKillRet) + ')' + Fx::reset); } messageBox = Menu::msgBox{50, 0, cont_vec, "error"}; Global::overlay = messageBox(); } auto ret = messageBox.input(key); if (ret == msgBox::Ok_Yes or ret == msgBox::No_Esc) { messageBox.clear(); return Closed; } else if (redraw) { return Changed; } return NoChange; } static int mainMenu(const string& key) { enum MenuItems { Options, Help, Quit }; static int y{}; static int selected{}; static vector colors_selected; static vector colors_normal; auto tty_mode = Config::getB("tty_mode"); if (bg.empty()) selected = 0; int retval = Changed; if (redraw) { y = Term::height/2 - 10; bg = Draw::banner_gen(y, 0, true); if (not tty_mode) { colors_selected = { Theme::hex_to_color(Global::Banner_src.at(0).at(0)), Theme::hex_to_color(Global::Banner_src.at(2).at(0)), Theme::hex_to_color(Global::Banner_src.at(4).at(0)) }; colors_normal = { Theme::hex_to_color("#CC"), Theme::hex_to_color("#AA"), Theme::hex_to_color("#80") }; } } else if (is_in(key, "escape", "q", "m", "mouse_click")) { return Closed; } else if (key.starts_with("button_")) { if (int new_select = key.back() - '0'; new_select == selected) goto MainEntering; else selected = new_select; } else if (is_in(key, "enter", "space")) { MainEntering: switch (selected) { case Options: menuMask.set(Menus::Options); currentMenu = Menus::Options; return Switch; case Help: menuMask.set(Menus::Help); currentMenu = Menus::Help; return Switch; case Quit: clean_quit(0); } } else if (is_in(key, "down", "tab", "mouse_scroll_down", "j")) { if (++selected > 2) selected = 0; } else if (is_in(key, "up", "shift_tab", "mouse_scroll_up", "k")) { if (--selected < 0) selected = 2; } else { retval = NoChange; } if (retval == Changed) { auto& out = Global::overlay; out = bg + Fx::reset + Fx::b; auto cy = y + 7; for (const auto& i : iota(0, 3)) { if (tty_mode) out += (i == selected ? Theme::c("hi_fg") : Theme::c("main_fg")); const auto& menu = (not tty_mode and i == selected ? menu_selected[i] : menu_normal[i]); const auto& colors = (i == selected ? colors_selected : colors_normal); if (redraw) mouse_mappings["button_" + to_string(i)] = {cy, Term::width/2 - menu_width[i]/2, 3, menu_width[i]}; for (int ic = 0; const auto& line : menu) { out += Mv::to(cy++, Term::width/2 - menu_width[i]/2) + (tty_mode ? "" : colors[ic++]) + line; } } out += Fx::reset; } return (redraw ? Changed : retval); } static int optionsMenu(const string& key) { enum Predispositions { isBool, isInt, isString, is2D, isBrowsable, isEditable}; static int y{}; static int x{}; static int height{}; static int page{}; static int pages{}; static int selected{}; static int select_max{}; static int item_height{}; static int selected_cat{}; static int max_items{}; static int last_sel{}; static bool editing{}; static Draw::TextEdit editor; static string warnings; static bitset<8> selPred; static const std::unordered_map>> optionsList = { {"color_theme", std::cref(Theme::themes)}, {"log_level", std::cref(Logger::log_levels)}, {"temp_scale", std::cref(Config::temp_scales)}, #ifdef __linux__ {"freq_mode", std::cref(Config::freq_modes)}, #endif {"proc_sorting", std::cref(Proc::sort_vector)}, {"graph_symbol", std::cref(Config::valid_graph_symbols)}, {"graph_symbol_cpu", std::cref(Config::valid_graph_symbols_def)}, {"graph_symbol_mem", std::cref(Config::valid_graph_symbols_def)}, {"graph_symbol_net", std::cref(Config::valid_graph_symbols_def)}, {"graph_symbol_proc", std::cref(Config::valid_graph_symbols_def)}, {"cpu_graph_upper", std::cref(Cpu::available_fields)}, {"cpu_graph_lower", std::cref(Cpu::available_fields)}, {"cpu_sensor", std::cref(Cpu::available_sensors)}, {"selected_battery", std::cref(Config::available_batteries)}, {"base_10_bitrate", std::cref(Config::base_10_bitrate_values)}, {"disable_presets", std::cref(Config::disable_preset_options)}, #ifdef GPU_SUPPORT {"show_gpu_info", std::cref(Config::show_gpu_values)}, {"graph_symbol_gpu", std::cref(Config::valid_graph_symbols_def)}, #endif }; auto tty_mode = Config::getB("tty_mode"); auto vim_keys = Config::getB("vim_keys"); if (max_items == 0) { for (const auto& cat : categories) { if ((int)cat.size() > max_items) max_items = cat.size(); } } if (bg.empty()) { page = selected = selected_cat = last_sel = 0; redraw = true; Theme::updateThemes(); } int retval = Changed; bool recollect{}; bool screen_redraw{}; bool theme_refresh{}; //? Draw background if needed else process input if (redraw) { mouse_mappings.clear(); selPred.reset(); y = max(1, Term::height/2 - 3 - max_items); x = Term::width/2 - 39; height = min(Term::height - 7, max_items * 2 + 4); if (height % 2 != 0) height--; bg = Draw::banner_gen(y, 0, true) + Draw::createBox(x, y + 6, 78, height, Theme::c("hi_fg"), true, fmt::format("{}tab{}", Theme::c("hi_fg"), Theme::c("main_fg")) + Symbols::right) + Mv::to(y+8, x) + Theme::c("hi_fg") + Symbols::div_left + Theme::c("div_line") + Symbols::h_line * 29 + Symbols::div_up + Symbols::h_line * (78 - 32) + Theme::c("hi_fg") + Symbols::div_right + Mv::to(y+6+height - 1, x+30) + Symbols::div_down + Theme::c("div_line"); for (const auto& i : iota(0, height - 4)) { bg += Mv::to(y+9 + i, x + 30) + Symbols::v_line; } } else if (not warnings.empty() and not key.empty()) { auto ret = messageBox.input(key); if (ret == msgBox::msgReturn::Ok_Yes or ret == msgBox::msgReturn::No_Esc) { warnings.clear(); messageBox.clear(); } } else if (editing and not key.empty()) { if (is_in(key, "escape", "mouse_click")) { editor.clear(); editing = false; } else if (key == "enter") { const auto& option = categories[selected_cat][item_height * page + selected][0]; if (selPred.test(isString) and Config::stringValid(option, editor.text)) { Config::set(option, editor.text); if (option == "custom_cpu_name" or option.starts_with("custom_gpu_name")) screen_redraw = true; else if (is_in(option, "shown_boxes", "presets")) { screen_redraw = true; Config::current_preset.reset(); } else if (option == "clock_format") { Draw::update_clock(true); screen_redraw = true; } else if (option == "cpu_core_map") { atomic_wait(Runner::active); Cpu::core_mapping = Cpu::get_core_mapping(); } } else if (selPred.test(isInt) and Config::intValid(option, editor.text)) { Config::set(option, stoi(editor.text)); } else warnings = Config::validError; editor.clear(); editing = false; } else if (not editor.command(key)) retval = NoChange; } else if (key == "mouse_click") { const auto [mouse_x, mouse_y] = Input::mouse_pos; if (mouse_x < x or mouse_x > x + 80 or mouse_y < y + 6 or mouse_y > y + 6 + height) { return Closed; } else if (mouse_x < x + 30 and mouse_y > y + 8) { auto m_select = ceil((double)(mouse_y - y - 8) / 2) - 1; if (selected != m_select) selected = m_select; else if (selPred.test(isEditable)) goto mouseEnter; else retval = NoChange; } } else if (is_in(key, "enter", "e", "E") and selPred.test(isEditable)) { mouseEnter: const auto& option = categories[selected_cat][item_height * page + selected][0]; editor = Draw::TextEdit{Config::getAsString(option), selPred.test(isInt)}; editing = true; mouse_mappings.clear(); } else if (is_in(key, "escape", "q", "o", "backspace")) { return Closed; } else if (is_in(key, "down", "mouse_scroll_down") or (vim_keys and key == "j")) { if (++selected > select_max or selected >= item_height) { if (page < pages - 1) page++; else if (pages > 1) page = 0; selected = 0; } } else if (is_in(key, "up", "mouse_scroll_up") or (vim_keys and key == "k")) { if (--selected < 0) { if (page > 0) page--; else if (pages > 1) page = pages - 1; selected = item_height - 1; } } else if (pages > 1 and key == "page_down") { if (++page >= pages) page = 0; selected = 0; last_sel = -1; } else if (pages > 1 and key == "page_up") { if (--page < 0) page = pages - 1; selected = 0; last_sel = -1; } else if (key == "tab") { if (++selected_cat >= (int)categories.size()) selected_cat = 0; page = selected = 0; } else if (key == "shift_tab") { if (--selected_cat < 0) selected_cat = (int)categories.size() - 1; page = selected = 0; } #ifdef GPU_SUPPORT else if (is_in(key, "1", "2", "3", "4", "5", "6") or key.starts_with("select_cat_")) { #else else if (is_in(key, "1", "2", "3", "4", "5") or key.starts_with("select_cat_")) { #endif selected_cat = key.back() - '0' - 1; page = selected = 0; } else if (is_in(key, "left", "right") or (vim_keys and is_in(key, "h", "l"))) { const auto& option = categories[selected_cat][item_height * page + selected][0]; if (selPred.test(isInt)) { const int mod = (option == "update_ms" ? 100 : 1); long value = Config::getI(option); if (key == "right" or (vim_keys and key == "l")) value += mod; else value -= mod; if (Config::intValid(option, to_string(value))) Config::set(option, static_cast(value)); else { warnings = Config::validError; } } else if (selPred.test(isBool)) { Config::flip(option); screen_redraw = true; // Special handling for options that need additional action. if (option == "truecolor") { theme_refresh = true; Config::flip("lowcolor"); } #if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__NetBSD__) else if (option == "force_tty" and not Term::current_tty.starts_with("/dev/tty")) { #else else if (option == "force_tty") { #endif theme_refresh = true; Config::set("tty_mode", Config::getB("force_tty")); } else if (is_in(option, "rounded_corners", "theme_background")) theme_refresh = true; else if (option == "background_update") { Runner::pause_output = false; } else if (option == "base_10_sizes") { recollect = true; } else if (option == "save_config_on_exit" and not Config::getB("save_config_on_exit")) { const bool old_write_new = Config::write_new; Config::write_new = true; Config::write(); Config::write_new = old_write_new; } else if (option == "disable_mouse") { const auto is_mouse_enabled = !Config::getB("disable_mouse"); std::cout << (is_mouse_enabled ? Term::mouse_on : Term::mouse_off) << std::flush; } } else if (selPred.test(isBrowsable)) { auto& optList = optionsList.at(option).get(); int i = v_index(optList, Config::getS(option)); if ((key == "right" or (vim_keys and key == "l")) and ++i >= (int)optList.size()) i = 0; else if ((key == "left" or (vim_keys and key == "h")) and --i < 0) i = optList.size() - 1; Config::set(option, optList.at(i)); if (option == "color_theme") theme_refresh = true; else if (option == "log_level") { Logger::set_log_level(optList.at(i)); Logger::info("Logger set to {}", optList.at(i)); } else if (option == "base_10_bitrate") { recollect = true; } else if (is_in(option, "proc_sorting", "cpu_sensor", "show_gpu_info") or option.starts_with("graph_symbol") or option.starts_with("cpu_graph_")) screen_redraw = true; else if (option == "disable_presets" and optList.at(i) != "Off") Config::current_preset.reset(); } else retval = NoChange; } else { retval = NoChange; } //? Draw the menu if (retval == Changed) { Config::unlock(); auto& out = Global::overlay; out = bg; item_height = min((int)categories[selected_cat].size(), (int)floor((double)(height - 4) / 2)); pages = ceil((double)categories[selected_cat].size() / item_height); if (page > pages - 1) page = pages - 1; select_max = min(item_height - 1, (int)categories[selected_cat].size() - 1 - item_height * page); if (selected > select_max) { selected = select_max; } //? Get variable properties for currently selected option selPred.reset(); last_sel = (selected_cat << 8) + selected; const auto& selOption = categories[selected_cat][item_height * page + selected][0]; if (Config::ints.contains(selOption)) selPred.set(isInt); else if (Config::bools.contains(selOption)) selPred.set(isBool); else selPred.set(isString); if (not selPred.test(isString)) selPred.set(is2D); else if (optionsList.contains(selOption)) { selPred.set(isBrowsable); } if (not selPred.test(isBrowsable) and (selPred.test(isString) or selPred.test(isInt))) selPred.set(isEditable); //? Category buttons out += Mv::to(y+7, x+4); #ifdef GPU_SUPPORT for (int i = 0; const auto& m : {"general", "cpu", "gpu", "mem", "net", "proc"}) { #else for (int i = 0; const auto& m : {"general", "cpu", "mem", "net", "proc"}) { #endif out += Fx::b + (i == selected_cat ? Theme::c("hi_fg") + '[' + Theme::c("title") + m + Theme::c("hi_fg") + ']' : Theme::c("hi_fg") + to_string(i + 1) + Theme::c("title") + m + ' ') #ifdef GPU_SUPPORT + Mv::r(7); #else + Mv::r(10); #endif #if !defined(GPU_SUPPORT) constexpr static auto option_menu_tab_width = 15; #else constexpr static auto option_menu_tab_width = 12; #endif if (const auto button_name = fmt::format("select_cat_{}", i + 1); not editing and not mouse_mappings.contains(button_name)) { mouse_mappings[button_name] = { .line = y + 6, .col = x + 2 + (option_menu_tab_width * i), .height = 3, .width = option_menu_tab_width, }; } i++; } if (pages > 1) { out += Mv::to(y+6 + height - 1, x+2) + Theme::c("hi_fg") + Symbols::title_left_down + Fx::b + Symbols::up + Theme::c("title") + " page " + to_string(page+1) + '/' + to_string(pages) + ' ' + Theme::c("hi_fg") + Symbols::down + Fx::ub + Symbols::title_right_down; } //? Option name and value auto cy = y+9; for (int c = 0, i = max(0, item_height * page); c++ < item_height and i < (int)categories[selected_cat].size(); i++) { const auto& option = categories[selected_cat][i][0]; const auto& value = (option == "color_theme" ? fs::path(Config::getS("color_theme")).stem().string() : Config::getAsString(option)); out += Mv::to(cy++, x + 1) + (c-1 == selected ? Theme::c("selected_bg") + Theme::c("selected_fg") : Theme::c("title")) + Fx::b + cjust(capitalize(s_replace(option, "_", " ")) + (c-1 == selected and selPred.test(isBrowsable) ? ' ' + to_string(v_index(optionsList.at(option).get(), (option == "color_theme" ? Config::getS("color_theme") : value)) + 1) + '/' + to_string(optionsList.at(option).get().size()) : ""), 29); out += Mv::to(cy++, x + 1) + (c-1 == selected ? "" : Theme::c("main_fg")) + Fx::ub + " " + (c-1 == selected and editing ? cjust(editor(24), 34, true) : cjust(value, 25, true)) + " "; if (c-1 == selected) { if (not editing and (selPred.test(is2D) or selPred.test(isBrowsable))) { out += Fx::b + Mv::to(cy-1, x+2) + Symbols::left + Mv::to(cy-1, x+28) + Symbols::right; mouse_mappings["left"] = {cy-2, x, 2, 5}; mouse_mappings["right"] = {cy-2, x+25, 2, 5}; } if (selPred.test(isEditable)) { out += Fx::b + Mv::to(cy-1, x+28 - (not editing and selPred.test(isInt) ? 2 : 0)) + (tty_mode ? "E" : Symbols::enter); } //? Description of selected option out += Fx::reset + Theme::c("title") + Fx::b; for (int cyy = y+7; const auto& desc : categories[selected_cat][i]) { if (cyy++ == y+7) continue; else if (cyy == y+10) out += Theme::c("main_fg") + Fx::ub; else if (cyy > y + height + 4) break; out += Mv::to(cyy, x+32) + desc; } } } if (not warnings.empty()) { messageBox = msgBox{min(78, (int)ulen(warnings) + 10), msgBox::BoxTypes::OK, {uresize(warnings, 74)}, "warning"}; out += messageBox(); } out += Fx::reset; } if (theme_refresh) { Theme::setTheme(); Draw::banner_gen(0, 0, false, true); screen_redraw = true; redraw = true; optionsMenu(""); } if (screen_redraw) { auto overlay_bkp = std::move(Global::overlay); auto clock_bkp = std::move(Global::clock); Draw::calcSizes(); Global::overlay = std::move(overlay_bkp); Global::clock = std::move(clock_bkp); recollect = true; } if (recollect) { Runner::run("all", false, true); retval = NoChange; } return (redraw ? Changed : retval); } static int helpMenu(const string& key) { static int y{}; static int x{}; static int height{}; static int page{}; static int pages{}; if (bg.empty()) page = 0; int retval = Changed; if (redraw) { y = max(1, Term::height/2 - 4 - (int)(help_text.size() / 2)); x = Term::width/2 - 39; height = min(Term::height - 6, (int)help_text.size() + 3); pages = ceil((double)help_text.size() / (height - 3)); page = 0; bg = Draw::banner_gen(y, 0, true); bg += Draw::createBox(x, y + 6, 78, height, Theme::c("hi_fg"), true, "help"); } else if (is_in(key, "escape", "q", "h", "backspace", "space", "enter", "mouse_click")) { return Closed; } else if (pages > 1 and is_in(key, "down", "j", "page_down", "tab", "mouse_scroll_down")) { if (++page >= pages) page = 0; } else if (pages > 1 and is_in(key, "up", "k", "page_up", "shift_tab", "mouse_scroll_up")) { if (--page < 0) page = pages - 1; } else { retval = NoChange; } if (retval == Changed) { auto& out = Global::overlay; out = bg; if (pages > 1) { out += Mv::to(y+height+6, x + 2) + Theme::c("hi_fg") + Symbols::title_left_down + Fx::b + Symbols::up + Theme::c("title") + " page " + to_string(page+1) + '/' + to_string(pages) + ' ' + Theme::c("hi_fg") + Symbols::down + Fx::ub + Symbols::title_right_down; } auto cy = y+7; out += Mv::to(cy++, x + 1) + Theme::c("title") + Fx::b + cjust("Key:", 20) + "Description:"; for (int c = 0, i = max(0, (height - 3) * page); c++ < height - 3 and i < (int)help_text.size(); i++) { out += Mv::to(cy++, x + 1) + Theme::c("hi_fg") + Fx::b + cjust(help_text[i][0], 20) + Theme::c("main_fg") + Fx::ub + help_text[i][1]; } out += Fx::reset; } return (redraw ? Changed : retval); } static int reniceMenu(const string& key) { static std::optional s_pid; static int x{}; static int y{}; static int selected_nice = 0; static string nice_edit; if (!s_pid) { s_pid = (Config::getB("show_detailed") and Config::getI("selected_pid") == 0 ? Config::getI("detailed_pid") : Config::getI("selected_pid")); } if (bg.empty()) { selected_nice = 0; nice_edit.clear(); } auto& out = Global::overlay; int retval = Changed; if (redraw) { x = Term::width/2 - 25; y = Term::height/2 - 6; bg = Draw::createBox(x + 2, y, 50, 13, Theme::c("hi_fg"), true, "renice"); bg += Mv::to(y+2, x+3) + Theme::c("title") + Fx::b + cjust("Renice PID " + to_string(s_pid.value()) + " (" + uresize((s_pid == Config::getI("detailed_pid") ? Proc::detailed.entry.name : Config::getS("selected_name")), 15) + ")", 48); } else if (is_in(key, "escape", "q")) { goto MenuClosing; } else if (is_in(key, "enter", "space")) { if (s_pid > 0) { if (not nice_edit.empty()) { try { selected_nice = stoi(nice_edit); } catch (...) { selected_nice = 0; } } if (not Proc::set_priority(s_pid.value(), selected_nice)) { // TODO: show error message } } goto MenuClosing; } else if (key.size() == 1 and (isdigit(key.at(0)) or (key.at(0) == '-' and nice_edit.empty()))) { nice_edit += key; } else if (key == "backspace" and not nice_edit.empty()) { nice_edit.pop_back(); } else if (is_in(key, "up", "k")) { if (++selected_nice > 19) selected_nice = -20; nice_edit.clear(); } else if (is_in(key, "down", "j")) { if (--selected_nice < -20) selected_nice = 19; nice_edit.clear(); } else if (is_in(key, "left", "h")) { if ((selected_nice -= 5) < -20) selected_nice += 40; nice_edit.clear(); } else if (is_in(key, "right", "l")) { if ((selected_nice += 5) > 19) selected_nice -= 40; nice_edit.clear(); } else { retval = NoChange; } if (retval == Changed) { int cy = y+4; if (not nice_edit.empty()) { try { selected_nice = stoi(nice_edit); } catch (...) { selected_nice = 0; } } out = bg + Mv::to(cy++, x+3) + Theme::c("main_fg") + Fx::ub + rjust("Enter nice value: ", 30) + Theme::c("hi_fg") + (nice_edit.empty() ? to_string(selected_nice) : nice_edit) + Theme::c("main_fg") + Fx::bl + "โ–ˆ" + Fx::ubl; cy++; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust( "โ†‘ โ†“", 20, true) + Theme::c("main_fg") + Fx::ub + " | To change value."; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust( "โ† โ†’", 20, true) + Theme::c("main_fg") + Fx::ub + " | To change value by 5."; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust("0-9", 20) + Theme::c("main_fg") + Fx::ub + " | Enter manually."; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust("ENTER", 20) + Theme::c("main_fg") + Fx::ub + " | To set nice value."; out += Mv::to(++cy, x+3) + Fx::b + Theme::c("hi_fg") + rjust("ESC or 'q'", 20) + Theme::c("main_fg") + Fx::ub + " | To abort."; out += Fx::reset; } return (redraw ? Changed : retval); MenuClosing: s_pid.reset(); return Closed; } //* Add menus here and update enum Menus in header const auto menuFunc = vector{ ref(sizeError), ref(signalChoose), ref(signalSend), ref(signalReturn), ref(optionsMenu), ref(helpMenu), ref(reniceMenu), ref(mainMenu), }; bitset<8> menuMask; void process(const std::string_view key) { if (menuMask.none()) { Menu::active = false; Global::overlay.clear(); Global::overlay.shrink_to_fit(); Runner::pause_output = false; bg.clear(); bg.shrink_to_fit(); currentMenu = -1; Runner::run("all", true, true); mouse_mappings.clear(); return; } if (currentMenu < 0 or not menuMask.test(currentMenu)) { Menu::active = true; redraw = true; if (((menuMask.test(Main) or menuMask.test(Options) or menuMask.test(Help) or menuMask.test(SignalChoose)) and (Term::width < 80 or Term::height < 24)) or (Term::width < 50 or Term::height < 20)) { menuMask.reset(); menuMask.set(SizeError); } for (const auto& i : iota(0, (int)menuMask.size())) { if (menuMask.test(i)) currentMenu = i; } } auto retCode = menuFunc.at(currentMenu)(key.data()); if (retCode == Closed) { menuMask.reset(currentMenu); mouse_mappings.clear(); bg.clear(); Runner::pause_output = false; process(); } else if (redraw) { redraw = false; Runner::run("all", true, true); } else if (retCode == Changed) Runner::run("overlay"); else if (retCode == Switch) { Runner::pause_output = false; bg.clear(); redraw = true; mouse_mappings.clear(); process(); } } void show(int menu, int signal) { menuMask.set(menu); signalToSend = signal; process(); } } aristocratos-btop-d43a485/src/btop_menu.hpp000066400000000000000000000045421517514752700210420ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include #include "btop_input.hpp" using std::atomic; using std::bitset; using std::string; using std::vector; namespace Menu { extern atomic active; extern string output; extern int signalToSend; extern bool redraw; //? line, col, height, width extern std::unordered_map mouse_mappings; //* Creates a message box centered on screen //? Height of box is determined by size of content vector //? Boxtypes: 0 = OK button | 1 = YES and NO with YES selected | 2 = Same as 1 but with NO selected //? Strings in content vector is not checked for box width overflow class msgBox { string box_contents, button_left, button_right; int height{}; int width{}; int boxtype{}; int selected{}; int x{}; int y{}; public: enum BoxTypes { OK, YES_NO, NO_YES }; enum msgReturn { Invalid, Ok_Yes, No_Esc, Select }; msgBox(); msgBox(int width, int boxtype, const vector& content, std::string_view title); //? Draw and return box as a string string operator()(); //? Process input and returns value from enum Ret int input(const string& key); //? Clears content vector and private strings void clear(); int getX() const { return x; } int getY() const { return y; } }; extern bitset<8> menuMask; //* Enum for functions in vector menuFuncs enum Menus { SizeError, SignalChoose, SignalSend, SignalReturn, Options, Help, Renice, Main }; //* Handles redirection of input for menu functions and handles return codes void process(const std::string_view key = ""); //* Show a menu from enum Menu::Menus void show(int menu, int signal=-1); } aristocratos-btop-d43a485/src/btop_shared.cpp000066400000000000000000000270071517514752700213400ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include "btop_config.hpp" #include "btop_shared.hpp" #include "btop_tools.hpp" namespace fs = std::filesystem; namespace rng = std::ranges; using namespace Tools; namespace Cpu { std::optional container_engine; string trim_name(string name) { auto name_vec = ssplit(name); if ((name.contains("Xeon") or v_contains(name_vec, "Duo"s)) and v_contains(name_vec, "CPU"s)) { auto cpu_pos = v_index(name_vec, "CPU"s); if (cpu_pos < name_vec.size() - 1 and not name_vec.at(cpu_pos + 1).ends_with(')')) name = name_vec.at(cpu_pos + 1); else name.clear(); } else if (v_contains(name_vec, "Ryzen"s)) { auto ryz_pos = v_index(name_vec, "Ryzen"s); name = "Ryzen"; int tokens = 0; for (auto i = ryz_pos + 1; i < name_vec.size() && tokens < 2; i++) { const std::string& p = name_vec.at(i); if (p != "AI" && p != "PRO" && p != "H" && p != "HX") tokens++; name += " " + p; } } else if (name.contains("Intel") and v_contains(name_vec, "CPU"s)) { auto cpu_pos = v_index(name_vec, "CPU"s); if (cpu_pos < name_vec.size() - 1 and not name_vec.at(cpu_pos + 1).ends_with(')') and name_vec.at(cpu_pos + 1) != "@") name = name_vec.at(cpu_pos + 1); else name.clear(); } else name.clear(); if (name.empty() and not name_vec.empty()) { for (const auto &n : name_vec) { if (n == "@") break; name += n + ' '; } name.pop_back(); for (const auto& replace : {"Processor", "CPU", "(R)", "(TM)", "Intel", "AMD", "Apple", "Core"}) { name = s_replace(name, replace, ""); name = s_replace(name, " ", " "); } name = trim(name); } return name; } } #ifdef GPU_SUPPORT namespace Gpu { vector gpu_names; vector gpu_b_height_offsets; std::unordered_map> shared_gpu_percent = { {"gpu-average", {}}, {"gpu-vram-total", {}}, {"gpu-pwr-total", {}}, }; long long gpu_pwr_total_max = 0; } #endif namespace Proc { bool set_priority(pid_t pid, int priority) { if (setpriority(PRIO_PROCESS, pid, priority) == 0) { return true; } return false; } void proc_sorter(vector& proc_vec, const string& sorting, bool reverse, bool tree) { if (reverse) { switch (v_index(sort_vector, sorting)) { case 0: rng::stable_sort(proc_vec, rng::less{}, &proc_info::pid); break; case 1: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::name); break; case 2: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::cmd); break; case 3: rng::stable_sort(proc_vec, rng::less{}, &proc_info::threads); break; case 4: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::user); break; case 5: rng::stable_sort(proc_vec, rng::less{}, &proc_info::mem); break; case 6: rng::stable_sort(proc_vec, rng::less{}, &proc_info::cpu_p); break; case 7: rng::stable_sort(proc_vec, rng::less{}, &proc_info::cpu_c); break; } } else { switch (v_index(sort_vector, sorting)) { case 0: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::pid); break; case 1: rng::stable_sort(proc_vec, rng::less{}, &proc_info::name); break; case 2: rng::stable_sort(proc_vec, rng::less{}, &proc_info::cmd); break; case 3: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::threads); break; case 4: rng::stable_sort(proc_vec, rng::less{}, &proc_info::user); break; case 5: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::mem); break; case 6: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::cpu_p); break; case 7: rng::stable_sort(proc_vec, rng::greater{}, &proc_info::cpu_c); break; } } //* When sorting with "cpu lazy" push processes over threshold cpu usage to the front regardless of cumulative usage if (not tree and not reverse and sorting == "cpu lazy") { double max = 10.0, target = 30.0; for (size_t i = 0, x = 0, offset = 0; i < proc_vec.size(); i++) { if (i <= 5 and proc_vec.at(i).cpu_p > max) max = proc_vec.at(i).cpu_p; else if (i == 6) target = (max > 30.0) ? max : 10.0; if (i == offset and proc_vec.at(i).cpu_p > 30.0) offset++; else if (proc_vec.at(i).cpu_p > target) { rotate(proc_vec.begin() + offset, proc_vec.begin() + i, proc_vec.begin() + i + 1); if (++x > 10) break; } } } } void tree_sort(vector& proc_vec, const string& sorting, bool reverse, bool paused, int& c_index, const int index_max, bool collapsed) { if (proc_vec.size() > 1 and not paused) { if (reverse) { switch (v_index(sort_vector, sorting)) { case 3: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().threads < b.entry.get().threads; }); break; case 5: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().mem < b.entry.get().mem; }); break; case 6: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().cpu_p < b.entry.get().cpu_p; }); break; case 7: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().cpu_c < b.entry.get().cpu_c; }); break; } } else { switch (v_index(sort_vector, sorting)) { case 3: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().threads > b.entry.get().threads; }); break; case 5: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().mem > b.entry.get().mem; }); break; case 6: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().cpu_p > b.entry.get().cpu_p; }); break; case 7: rng::stable_sort(proc_vec, [](const auto& a, const auto& b) { return a.entry.get().cpu_c > b.entry.get().cpu_c; }); break; } } } for (auto& r : proc_vec) { r.entry.get().tree_index = (collapsed or r.entry.get().filtered ? index_max : c_index++); if (not r.children.empty()) { tree_sort(r.children, sorting, reverse, paused, c_index, (collapsed or r.entry.get().collapsed or r.entry.get().tree_index == (size_t)index_max)); } } } auto matches_filter(const proc_info& proc, const std::string& filter) -> bool { if (filter.starts_with("!")) { if (filter.size() == 1) { return true; } // An incomplete regex throws, see issue https://github.com/aristocratos/btop/issues/1133 try { std::regex regex { filter.substr(1), std::regex::extended }; return std::regex_search(std::to_string(proc.pid), regex) || std::regex_search(proc.name, regex) || std::regex_match(proc.cmd, regex) || std::regex_search(proc.user, regex); } catch (std::regex_error& /* unused */) { return false; } } return std::to_string(proc.pid).contains(filter) || s_contains_ic(proc.name, filter) || s_contains_ic(proc.cmd, filter) || s_contains_ic(proc.user, filter); } void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, int cur_depth, bool collapsed, const string& filter, bool found, bool no_update, bool should_filter) { bool filtering = false; //? If filtering, include children of matching processes if (not found and (should_filter or not filter.empty())) { if (!matches_filter(cur_proc, filter)) { filtering = true; cur_proc.filtered = true; filter_found++; } else { found = true; cur_depth = 0; } } else if (cur_proc.filtered) cur_proc.filtered = false; cur_proc.depth = cur_depth; //? Set tree index position for process if not filtered out or currently in a collapsed sub-tree out_procs.push_back({ cur_proc, {} }); if (not collapsed and not filtering) { cur_proc.tree_index = out_procs.size() - 1; //? Try to find name of the binary file and append to program name if not the same if (cur_proc.short_cmd.empty() and not cur_proc.cmd.empty()) { std::string_view cmd_view = cur_proc.cmd; cmd_view = cmd_view.substr((size_t)0, std::min(cmd_view.find(' '), cmd_view.size())); cmd_view = cmd_view.substr(std::min(cmd_view.find_last_of('/') + 1, cmd_view.size())); cur_proc.short_cmd = string{cmd_view}; } } else { cur_proc.tree_index = in_procs.size(); } //? Recursive iteration over all children for (auto& p : rng::equal_range(in_procs, cur_proc.pid, rng::less{}, &proc_info::ppid)) { if (collapsed and not filtering) { cur_proc.filtered = true; } _tree_gen(p, in_procs, out_procs.back().children, cur_depth + 1, (collapsed or cur_proc.collapsed), filter, found, no_update, should_filter); if (not no_update and not filtering and (collapsed or cur_proc.collapsed)) { //auto& parent = cur_proc; if (p.state != 'X') { cur_proc.cpu_p += p.cpu_p; cur_proc.cpu_c += p.cpu_c; cur_proc.mem += p.mem; cur_proc.threads += p.threads; } filter_found++; p.filtered = true; } else if (Config::getB("proc_aggregate") and p.state != 'X') { cur_proc.cpu_p += p.cpu_p; cur_proc.cpu_c += p.cpu_c; cur_proc.mem += p.mem; cur_proc.threads += p.threads; } } } void _collect_prefixes(tree_proc &t, const bool is_last, const string &header) { const bool is_filtered = t.entry.get().filtered; if (is_filtered) t.entry.get().depth = 0; if (!t.children.empty()) t.entry.get().prefix = header + (t.entry.get().collapsed ? "[+]โ”€": "[-]โ”€"); else t.entry.get().prefix = header + (is_last ? " โ””โ”€": " โ”œโ”€"); for (auto child = t.children.begin(); child != t.children.end(); ++child) { _collect_prefixes(*child, child == (t.children.end() - 1), is_filtered ? "": header + (is_last ? " ": " โ”‚ ")); } } void toggle_tree_collapse(std::vector& current_procs) { //? Build sets of all pids and parent pids to identify root processes std::unordered_set pid_set, parent_pids; for (const auto& p : current_procs) { pid_set.insert(p.pid); parent_pids.insert(static_cast(p.ppid)); } //? If any non-root parent is expanded, collapse; otherwise expand const bool do_collapse = rng::any_of(current_procs, [&parent_pids, &pid_set](const proc_info& p) { return parent_pids.contains(p.pid) and pid_set.contains(static_cast(p.ppid)) and not p.collapsed; }); //? Root processes (parent not in tracked list) are never touched for (auto& p : current_procs) { if (not pid_set.contains(static_cast(p.ppid))) continue; p.collapsed = do_collapse; } } } auto detect_container() -> std::optional { std::error_code err; if (fs::exists(fs::path("/run/.containerenv"), err)) { return std::make_optional(std::string { "podman" }); } if (fs::exists(fs::path("/.dockerenv"), err)) { return std::make_optional(std::string { "docker" }); } auto systemd_container = fs::path("/run/systemd/container"); if (fs::exists(systemd_container, err)) { auto stream = std::ifstream { systemd_container }; auto buf = std::string {}; stream >> buf; return std::make_optional(buf); } return std::nullopt; } aristocratos-btop-d43a485/src/btop_shared.hpp000066400000000000000000000315231517514752700213430ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include // From `man 3 getifaddrs`: must be included before // clang-format off #include #include // clang-format on #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) # include #endif using std::array; using std::atomic; using std::deque; using std::string; using std::tuple; using std::vector; using namespace std::literals; // for operator""s void term_resize(bool force=false); void banner_gen(); extern void clean_quit(int sig); namespace Global { extern const vector> Banner_src; extern const string Version; extern atomic quitting; extern string exit_error_msg; extern atomic thread_exception; extern string banner; extern atomic resized; extern string overlay; extern string clock; extern uid_t real_uid, set_uid; extern atomic init_conf; } namespace Runner { extern atomic active; extern atomic reading; extern atomic stopping; extern atomic redraw; extern atomic coreNum_reset; extern bool pause_output; extern string debug_bg; void run(const string& box = "", bool no_update = false, bool force_redraw = false); void stop(); } namespace Tools { //* Platform specific function for system_uptime (seconds since last restart) double system_uptime(); } namespace Shared { //* Initialize platform specific needed variables and check for errors void init(); extern long coreCount, page_size, clk_tck; #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) struct KvmDeleter { void operator()(kvm_t* handle) { kvm_close(handle); } }; using KvmPtr = std::unique_ptr; #endif } #if defined(GPU_SUPPORT) namespace Gpu { extern vector box; extern int width, total_height, min_width, min_height; extern vector x_vec, y_vec; extern vector redraw; extern int shown; extern int count; extern vector shown_panels; extern vector gpu_names; extern vector gpu_b_height_offsets; extern long long gpu_pwr_total_max; extern std::unordered_map> shared_gpu_percent; // averages, power/vram total const array mem_names { "used"s, "free"s }; //* Container for process information // TODO /*struct proc_info { unsigned int pid; unsigned long long mem; };*/ //* Container for supported Gpu::*::collect() functions struct gpu_info_supported { bool gpu_utilization = true, mem_utilization = true, gpu_clock = true, mem_clock = true, pwr_usage = true, pwr_state = true, temp_info = true, mem_total = true, mem_used = true, pcie_txrx = true, encoder_utilization = true, decoder_utilization = true; }; //* Per-device container for GPU info struct gpu_info { std::unordered_map> gpu_percent = { {"gpu-totals", {}}, {"gpu-vram-totals", {}}, {"gpu-pwr-totals", {}}, }; unsigned int gpu_clock_speed; // MHz long long pwr_usage; // mW long long pwr_max_usage = 255000; long long pwr_state; deque temp = {0}; long long temp_max = 110; long long mem_total = 0; long long mem_used = 0; deque mem_utilization_percent = {0}; // TODO: properly handle GPUs that can't report some stats long long mem_clock_speed = 0; // MHz long long pcie_tx = 0; // KB/s long long pcie_rx = 0; long long encoder_utilization = 0; long long decoder_utilization = 0; gpu_info_supported supported_functions; // vector graphics_processes = {}; // TODO // vector compute_processes = {}; }; namespace Nvml { extern bool shutdown(); } namespace Rsmi { extern bool shutdown(); } #ifdef __APPLE__ namespace AppleSilicon { extern bool shutdown(); } #endif //* Collect gpu stats and temperatures auto collect(bool no_update = false) -> vector&; //* Draw contents of gpu box using as source string draw(const gpu_info& gpu, unsigned long index, bool force_redraw, bool data_same); } #endif // GPU_SUPPORT namespace Cpu { extern string box; extern int x, y, width, height, min_width, min_height; extern bool shown, redraw, got_sensors, cpu_temp_only, has_battery, supports_watts; extern string cpuName, cpuHz; extern vector available_fields; extern vector available_sensors; extern tuple current_bat; extern std::optional container_engine; struct cpu_info { std::unordered_map> cpu_percent = { {"total", {}}, {"user", {}}, {"nice", {}}, {"system", {}}, {"idle", {}}, {"iowait", {}}, {"irq", {}}, {"softirq", {}}, {"steal", {}}, {"guest", {}}, {"guest_nice", {}} }; vector> core_percent; vector> temp; long long temp_max = 0; array load_avg; float usage_watts = 0; std::optional> active_cpus; }; //* Collect cpu stats and temperatures auto collect(bool no_update = false) -> cpu_info&; //* Draw contents of cpu box using as source string draw( const cpu_info& cpu, #if defined(GPU_SUPPORT) const vector& gpu, #endif bool force_redraw = false, bool data_same = false ); //* Parse /proc/cpu info for mapping of core ids auto get_core_mapping() -> std::unordered_map; extern std::unordered_map core_mapping; auto get_cpuHz() -> string; //* Get battery info from /sys auto get_battery() -> tuple; string trim_name(string); } namespace Mem { extern string box; extern int x, y, width, height, min_width, min_height; extern bool has_swap, shown, redraw; const array mem_names { "used"s, "available"s, "cached"s, "free"s }; const array swap_names { "swap_used"s, "swap_free"s }; extern int disk_ios; struct disk_info { std::filesystem::path dev; string name; string fstype{}; // defaults to "" std::filesystem::path stat{}; // defaults to "" int64_t total{}; int64_t used{}; int64_t free{}; int used_percent{}; int free_percent{}; array old_io = {0, 0, 0}; deque io_read = {}; deque io_write = {}; deque io_activity = {}; }; struct mem_info { std::unordered_map stats = {{"used", 0}, {"available", 0}, {"cached", 0}, {"free", 0}, {"swap_total", 0}, {"swap_used", 0}, {"swap_free", 0}}; std::unordered_map> percent = {{"used", {}}, {"available", {}}, {"cached", {}}, {"free", {}}, {"swap_total", {}}, {"swap_used", {}}, {"swap_free", {}}}; std::unordered_map disks; vector disks_order; }; //?* Get total system memory uint64_t get_totalMem(); //* Collect mem & disks stats auto collect(bool no_update = false) -> mem_info&; //* Draw contents of mem box using as source string draw(const mem_info& mem, bool force_redraw = false, bool data_same = false); } namespace Net { extern string box; extern int x, y, width, height, min_width, min_height; extern bool shown, redraw; extern string selected_iface; extern vector interfaces; extern bool rescale; extern std::unordered_map graph_max; struct net_stat { uint64_t speed{}; uint64_t top{}; uint64_t total{}; uint64_t last{}; uint64_t offset{}; uint64_t rollover{}; }; struct net_info { std::unordered_map> bandwidth = { {"download", {}}, {"upload", {}} }; std::unordered_map stat = { {"download", {}}, {"upload", {}} }; string ipv4{}; // defaults to "" string ipv6{}; // defaults to "" bool connected{}; }; class IfAddrsPtr { struct ifaddrs* ifaddr; int status; public: IfAddrsPtr() { status = getifaddrs(&ifaddr); } ~IfAddrsPtr() noexcept { freeifaddrs(ifaddr); } IfAddrsPtr(const IfAddrsPtr &) = delete; IfAddrsPtr& operator=(IfAddrsPtr& other) = delete; IfAddrsPtr(IfAddrsPtr &&) = delete; IfAddrsPtr& operator=(IfAddrsPtr&& other) = delete; [[nodiscard]] constexpr auto operator()() -> struct ifaddrs* { return ifaddr; } [[nodiscard]] constexpr auto get() -> struct ifaddrs* { return ifaddr; } [[nodiscard]] constexpr auto get_status() const noexcept -> int { return status; }; }; extern std::unordered_map current_net; //* Collect net upload/download stats auto collect(bool no_update=false) -> net_info&; //* Draw contents of net box using as source string draw(const net_info& net, bool force_redraw = false, bool data_same = false); } namespace Proc { extern atomic numpids; extern string box; extern int x, y, width, height, min_width, min_height; extern bool shown, redraw; extern int select_max; extern atomic detailed_pid; extern int selected_pid, start, selected, collapse, expand, filter_found, selected_depth, toggle_children, collapse_all; extern int scroll_pos; extern string selected_name; extern atomic resized; //? Contains the valid sorting options for processes const vector sort_vector = { "pid", "name", "command", "threads", "user", "memory", "cpu direct", "cpu lazy", }; //? Translation from process state char to explanative string const std::unordered_map proc_states = { {'R', "Running"}, {'S', "Sleeping"}, {'D', "Waiting"}, {'Z', "Zombie"}, {'T', "Stopped"}, {'t', "Tracing"}, {'X', "Dead"}, {'x', "Dead"}, {'K', "Wakekill"}, {'W', "Unknown"}, {'P', "Parked"} }; //* Container for process information struct proc_info { size_t pid{}; string name{}; // defaults to "" string cmd{}; // defaults to "" string short_cmd{}; // defaults to "" size_t threads{}; int name_offset{}; string user{}; // defaults to "" uint64_t mem{}; double cpu_p{}; // defaults to = 0.0 double cpu_c{}; // defaults to = 0.0 char state = '0'; int64_t p_nice{}; uint64_t ppid{}; uint64_t cpu_s{}; uint64_t cpu_t{}; uint64_t death_time{}; string prefix{}; // defaults to "" size_t depth{}; size_t tree_index{}; bool collapsed{}; bool filtered{}; }; //* Container for process info box struct detail_container { size_t last_pid{}; bool skip_smaps{}; proc_info entry; string elapsed, parent, status, io_read, io_write, memory; long long first_mem = -1; deque cpu_percent; deque mem_bytes; }; //? Contains all info for proc detailed box extern detail_container detailed; //* Collect and sort process information from /proc auto collect(bool no_update = false) -> vector&; //* Update current selection and view, returns -1 if no change otherwise the current selection int selection(const std::string_view cmd_key); //* Draw contents of proc box using as data source string draw(const vector& plist, bool force_redraw = false, bool data_same = false); struct tree_proc { std::reference_wrapper entry; vector children; }; //* Change priority (nice) of pid, returns true on success otherwise false bool set_priority(pid_t pid, int priority); //* Sort vector of proc_info's void proc_sorter(vector& proc_vec, const string& sorting, bool reverse, bool tree = false); //* Recursive sort of process tree void tree_sort(vector& proc_vec, const string& sorting, bool reverse, bool paused, int& c_index, const int index_max, bool collapsed = false); auto matches_filter(const proc_info& proc, const std::string& filter) -> bool; //* Generate process tree list void _tree_gen(proc_info& cur_proc, vector& in_procs, vector& out_procs, int cur_depth, bool collapsed, const string& filter, bool found = false, bool no_update = false, bool should_filter = false); //* Build prefixes for tree view void _collect_prefixes(tree_proc& t, bool is_last, const string &header = ""); //* Toggle collapse/expand of all tree entries void toggle_tree_collapse(std::vector& current_procs); } /// Detect container engine. auto detect_container() -> std::optional; aristocratos-btop-d43a485/src/btop_theme.cpp000066400000000000000000000346421517514752700211770ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include "btop_config.hpp" #include "btop_log.hpp" #include "btop_theme.hpp" #include "btop_tools.hpp" using std::round; using std::stoi; using std::to_string; using std::vector; using std::views::iota; using namespace Tools; namespace fs = std::filesystem; string Term::fg, Term::bg; string Fx::reset = reset_base; namespace Theme { fs::path theme_dir; fs::path user_theme_dir; fs::path custom_theme_dir; vector themes; std::unordered_map colors; std::unordered_map> rgbs; std::unordered_map> gradients; const std::unordered_map Default_theme = { { "main_bg", "#00" }, { "main_fg", "#cc" }, { "title", "#ee" }, { "hi_fg", "#b54040" }, { "selected_bg", "#6a2f2f" }, { "selected_fg", "#ee" }, { "inactive_fg", "#40" }, { "graph_text", "#60" }, { "meter_bg", "#40" }, { "proc_misc", "#0de756" }, { "cpu_box", "#556d59" }, { "mem_box", "#6c6c4b" }, { "net_box", "#5c588d" }, { "proc_box", "#805252" }, { "div_line", "#30" }, { "temp_start", "#4897d4" }, { "temp_mid", "#5474e8" }, { "temp_end", "#ff40b6" }, { "cpu_start", "#77ca9b" }, { "cpu_mid", "#cbc06c" }, { "cpu_end", "#dc4c4c" }, { "free_start", "#384f21" }, { "free_mid", "#b5e685" }, { "free_end", "#dcff85" }, { "cached_start", "#163350" }, { "cached_mid", "#74e6fc" }, { "cached_end", "#26c5ff" }, { "available_start", "#4e3f0e" }, { "available_mid", "#ffd77a" }, { "available_end", "#ffb814" }, { "used_start", "#592b26" }, { "used_mid", "#d9626d" }, { "used_end", "#ff4769" }, { "download_start", "#291f75" }, { "download_mid", "#4f43a3" }, { "download_end", "#b0a9de" }, { "upload_start", "#620665" }, { "upload_mid", "#7d4180" }, { "upload_end", "#dcafde" }, { "process_start", "#80d0a3" }, { "process_mid", "#dcd179" }, { "process_end", "#d45454" }, { "proc_pause_bg", "#b54040" }, { "proc_follow_bg", "#4040b5"}, { "proc_banner_bg", "#7b407b"}, { "proc_banner_fg", "#ee"}, { "followed_bg", "#4040b5"}, { "followed_fg", "#ee"}, }; const std::unordered_map TTY_theme = { { "main_bg", "\x1b[0;40m" }, { "main_fg", "\x1b[37m" }, { "title", "\x1b[97m" }, { "hi_fg", "\x1b[91m" }, { "selected_bg", "\x1b[41m" }, { "selected_fg", "\x1b[97m" }, { "inactive_fg", "\x1b[90m" }, { "graph_text", "\x1b[90m" }, { "meter_bg", "\x1b[90m" }, { "proc_misc", "\x1b[92m" }, { "cpu_box", "\x1b[32m" }, { "mem_box", "\x1b[33m" }, { "net_box", "\x1b[35m" }, { "proc_box", "\x1b[31m" }, { "div_line", "\x1b[90m" }, { "temp_start", "\x1b[94m" }, { "temp_mid", "\x1b[96m" }, { "temp_end", "\x1b[95m" }, { "cpu_start", "\x1b[92m" }, { "cpu_mid", "\x1b[93m" }, { "cpu_end", "\x1b[91m" }, { "free_start", "\x1b[32m" }, { "free_mid", "" }, { "free_end", "\x1b[92m" }, { "cached_start", "\x1b[36m" }, { "cached_mid", "" }, { "cached_end", "\x1b[96m" }, { "available_start", "\x1b[33m" }, { "available_mid", "" }, { "available_end", "\x1b[93m" }, { "used_start", "\x1b[31m" }, { "used_mid", "" }, { "used_end", "\x1b[91m" }, { "download_start", "\x1b[34m" }, { "download_mid", "" }, { "download_end", "\x1b[94m" }, { "upload_start", "\x1b[35m" }, { "upload_mid", "" }, { "upload_end", "\x1b[95m" }, { "process_start", "\x1b[32m" }, { "process_mid", "\x1b[33m" }, { "process_end", "\x1b[31m" }, { "proc_pause_bg", "\x1b[41m" }, { "proc_follow_bg", "\x1b[44m" }, { "proc_banner_bg", "\x1b[45m" }, { "proc_banner_fg", "\x1b[97m" }, { "followed_bg", "\x1b[44m" }, { "followed_fg", "\x1b[97m" }, }; namespace { //* Convert 24-bit colors to 256 colors int truecolor_to_256(const int& r, const int& g, const int& b) { //? Use upper 232-255 greyscale values if the downscaled red, green and blue are the same value if (const int red = round((double)r / 11); red == round((double)g / 11) and red == round((double)b / 11)) { return 232 + red; } //? Else use 6x6x6 color cube to calculate approximate colors else { return round((double)r / 51) * 36 + round((double)g / 51) * 6 + round((double)b / 51) + 16; } } } string hex_to_color(string hexa, bool t_to_256, const string& depth) { if (hexa.size() > 1) { hexa.erase(0, 1); for (auto& c : hexa) { if (not isxdigit(c)) { Logger::error("Invalid hex value: {}", hexa); return ""; } } string pre = Fx::e + (depth == "fg" ? "38" : "48") + ";" + (t_to_256 ? "5;" : "2;"); if (hexa.size() == 2) { int h_int = stoi(hexa, nullptr, 16); if (t_to_256) { return pre + to_string(truecolor_to_256(h_int, h_int, h_int)) + "m"; } else { string h_str = to_string(h_int); return pre + h_str + ";" + h_str + ";" + h_str + "m"; } } else if (hexa.size() == 6) { if (t_to_256) { return pre + to_string(truecolor_to_256( stoi(hexa.substr(0, 2), nullptr, 16), stoi(hexa.substr(2, 2), nullptr, 16), stoi(hexa.substr(4, 2), nullptr, 16))) + "m"; } else { return pre + to_string(stoi(hexa.substr(0, 2), nullptr, 16)) + ";" + to_string(stoi(hexa.substr(2, 2), nullptr, 16)) + ";" + to_string(stoi(hexa.substr(4, 2), nullptr, 16)) + "m"; } } else Logger::error("Invalid size of hex value: {}", hexa); } else Logger::error("Hex value missing: {}", hexa); return ""; } string dec_to_color(int r, int g, int b, bool t_to_256, const string& depth) { string pre = Fx::e + (depth == "fg" ? "38" : "48") + ";" + (t_to_256 ? "5;" : "2;"); r = std::clamp(r, 0, 255); g = std::clamp(g, 0, 255); b = std::clamp(b, 0, 255); if (t_to_256) return pre + to_string(truecolor_to_256(r, g, b)) + "m"; else return pre + to_string(r) + ";" + to_string(g) + ";" + to_string(b) + "m"; } namespace { //* Convert hex color to a array of decimals array hex_to_dec(string hexa) { if (hexa.size() > 1) { hexa.erase(0, 1); for (auto& c : hexa) { if (not isxdigit(c)) return array{-1, -1, -1}; } if (hexa.size() == 2) { int h_int = stoi(hexa, nullptr, 16); return array{h_int, h_int, h_int}; } else if (hexa.size() == 6) { return array{ stoi(hexa.substr(0, 2), nullptr, 16), stoi(hexa.substr(2, 2), nullptr, 16), stoi(hexa.substr(4, 2), nullptr, 16) }; } } return {-1 ,-1 ,-1}; } //* Generate colors and rgb decimal vectors for the theme void generateColors(const std::unordered_map& source) { vector t_rgb; string depth; bool t_to_256 = Config::getB("lowcolor"); colors.clear(); rgbs.clear(); for (const auto& [name, color] : Default_theme) { if (name == "main_bg" and not Config::getB("theme_background")) { colors[name] = "\x1b[49m"; rgbs[name] = {-1, -1, -1}; continue; } depth = (name.ends_with("bg") and name != "meter_bg") ? "bg" : "fg"; if (source.contains(name)) { if (name == "main_bg" and source.at(name).empty()) { colors[name] = "\x1b[49m"; rgbs[name] = {-1, -1, -1}; continue; } else if (source.at(name).empty() and (name.ends_with("_mid") or name.ends_with("_end"))) { colors[name] = ""; rgbs[name] = {-1, -1, -1}; continue; } else if (source.at(name).starts_with('#')) { colors[name] = hex_to_color(source.at(name), t_to_256, depth); rgbs[name] = hex_to_dec(source.at(name)); } else if (not source.at(name).empty()) { t_rgb = ssplit(source.at(name)); if (t_rgb.size() != 3) { Logger::error("Invalid RGB decimal value: \"{}\"", source.at(name)); } else { colors[name] = dec_to_color(stoi(t_rgb[0]), stoi(t_rgb[1]), stoi(t_rgb[2]), t_to_256, depth); rgbs[name] = array{stoi(t_rgb[0]), stoi(t_rgb[1]), stoi(t_rgb[2])}; } } } if (not colors.contains(name) and not is_in(name, "meter_bg", "process_start", "process_mid", "process_end", "graph_text")) { Logger::debug("Missing color value for \"{}\". Using value from default.", name); colors[name] = hex_to_color(color, t_to_256, depth); rgbs[name] = hex_to_dec(color); } } //? Set fallback values for optional colors not defined in theme file if (not colors.contains("meter_bg")) { colors["meter_bg"] = colors.at("inactive_fg"); rgbs["meter_bg"] = rgbs.at("inactive_fg"); } if (not colors.contains("process_start")) { colors["process_start"] = colors.at("cpu_start"); colors["process_mid"] = colors.at("cpu_mid"); colors["process_end"] = colors.at("cpu_end"); rgbs["process_start"] = rgbs.at("cpu_start"); rgbs["process_mid"] = rgbs.at("cpu_mid"); rgbs["process_end"] = rgbs.at("cpu_end"); } if (not colors.contains("graph_text")) { colors["graph_text"] = colors.at("inactive_fg"); rgbs["graph_text"] = rgbs.at("inactive_fg"); } } //* Generate color gradients from two or three colors, 101 values indexed 0-100 void generateGradients() { gradients.clear(); bool t_to_256 = Config::getB("lowcolor"); //? Insert values for processes greyscale gradient and processes color gradient rgbs.insert({ { "proc_start", rgbs["main_fg"] }, { "proc_mid", {-1, -1, -1} }, { "proc_end", rgbs["inactive_fg"] }, { "proc_color_start", rgbs["inactive_fg"] }, { "proc_color_mid", {-1, -1, -1} }, { "proc_color_end", rgbs["process_start"] }, }); for (const auto& [name, source_arr] : rgbs) { if (not name.ends_with("_start")) continue; const string color_name { rtrim(name, "_start") }; //? input_colors[start,mid,end][red,green,blue] const array, 3> input_colors = { source_arr, rgbs[color_name + "_mid"], rgbs[color_name + "_end"] }; //? output_colors[red,green,blue][0-100] array, 101> output_colors; output_colors[0][0] = -1; //? Only start iteration if gradient has an end color defined if (input_colors[2][0] >= 0) { //? Split iteration in two passes of 50 + 51 instead of one pass of 101 if gradient has start, mid and end values defined int current_range = (input_colors[1][0] >= 0) ? 50 : 100; for (int rgb : iota(0, 3)) { int start = 0, offset = 0; int end = (current_range == 50) ? 1 : 2; for (int i : iota(0, 101)) { output_colors[i][rgb] = input_colors[start][rgb] + (i - offset) * (input_colors[end][rgb] - input_colors[start][rgb]) / current_range; //? Switch source arrays from start->mid to mid->end at 50 passes if mid is defined if (i == current_range) { ++start; ++end; offset = 50; } } } } //? Generate color escape codes for the generated rgb decimals array color_gradient; if (output_colors[0][0] != -1) { for (int y = 0; const auto& [red, green, blue] : output_colors) color_gradient[y++] = dec_to_color(red, green, blue, t_to_256); } else { //? If only start was defined fill array with start color color_gradient.fill(colors[name]); } gradients[color_name] = std::move(color_gradient); } } //* Set colors and generate gradients for the TTY theme void generateTTYColors() { rgbs.clear(); gradients.clear(); colors = TTY_theme; if (not Config::getB("theme_background")) colors["main_bg"] = "\x1b[49m"; for (const auto& c : colors) { if (not c.first.ends_with("_start")) continue; const string base_name { rtrim(c.first, "_start") }; string section = "_start"; int split = colors.at(base_name + "_mid").empty() ? 50 : 33; for (int i : iota(0, 101)) { gradients[base_name][i] = colors.at(base_name + section); if (i == split) { section = (split == 33) ? "_mid" : "_end"; split *= 2; } } } } //* Load a .theme file from disk auto loadFile(const string& filename) { const fs::path filepath = filename; if (not fs::exists(filepath)) return Default_theme; std::ifstream themefile(filepath); if (themefile.good()) { std::unordered_map theme_out; Logger::debug("Loading theme file: {}", filename); while (not themefile.bad()) { if (themefile.peek() == '#') { themefile.ignore(SSmax, '\n'); continue; } themefile.ignore(SSmax, '['); if (themefile.eof()) break; string name, value; getline(themefile, name, ']'); if (not Default_theme.contains(name)) { themefile.ignore(SSmax, '\n'); continue; } themefile.ignore(SSmax, '='); themefile >> std::ws; if (themefile.eof()) break; if (themefile.peek() == '"') { themefile.ignore(1); getline(themefile, value, '"'); themefile.ignore(SSmax, '\n'); } else getline(themefile, value, '\n'); theme_out[name] = value; } return theme_out; } return Default_theme; } } void updateThemes() { themes.clear(); themes.push_back("Default"); themes.push_back("TTY"); //? Priority: custom_theme_dir -> user_theme_dir -> theme_dir for (const auto& path : { custom_theme_dir, user_theme_dir, theme_dir } ) { if (path.empty()) continue; for (auto& file : fs::directory_iterator(path)) { if (file.path().extension() == ".theme" and access(file.path().c_str(), R_OK) != -1 and not v_contains(themes, file.path().c_str())) { themes.push_back(file.path().c_str()); } } } } void setTheme() { const auto& theme = Config::getS("color_theme"); fs::path theme_path; for (const fs::path p : themes) { if (p == theme or p.stem() == theme or p.filename() == theme) { theme_path = p; break; } } if (theme == "TTY" or Config::getB("tty_mode")) generateTTYColors(); else { generateColors((theme == "Default" or theme_path.empty() ? Default_theme : loadFile(theme_path))); generateGradients(); } Term::fg = colors.at("main_fg"); Term::bg = colors.at("main_bg"); Fx::reset = Fx::reset_base + Term::fg + Term::bg; } } aristocratos-btop-d43a485/src/btop_theme.hpp000066400000000000000000000050131517514752700211720ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include using std::array; using std::string; using std::vector; namespace Theme { extern std::filesystem::path theme_dir; extern std::filesystem::path user_theme_dir; extern std::filesystem::path custom_theme_dir; //* Contains "Default" and "TTY" at indices 0 and 1, otherwise full paths to theme files extern vector themes; //* Generate escape sequence for 24-bit or 256 color and return as a string //* Args hexa: ["#000000"-"#ffffff"] for color, ["#00"-"#ff"] for greyscale //* t_to_256: [true|false] convert 24bit value to 256 color value //* depth: ["fg"|"bg"] for either a foreground color or a background color string hex_to_color(string hexa, bool t_to_256=false, const string& depth="fg"); //* Generate escape sequence for 24-bit or 256 color and return as a string //* Args r: [0-255], g: [0-255], b: [0-255] //* t_to_256: [true|false] convert 24bit value to 256 color value //* depth: ["fg"|"bg"] for either a foreground color or a background color string dec_to_color(int r, int g, int b, bool t_to_256=false, const string& depth="fg"); //* Update list of paths for available themes void updateThemes(); //* Set current theme from current "color_theme" value in config void setTheme(); extern std::unordered_map colors; extern std::unordered_map> rgbs; extern std::unordered_map> gradients; //* Return escape code for color inline const string& c(const string& name) { return colors.at(name); } //* Return array of escape codes for color gradient inline const array& g(const string& name) { return gradients.at(name); } //* Return array of red, green and blue in decimal for color inline const std::array& dec(const string& name) { return rgbs.at(name); } } aristocratos-btop-d43a485/src/btop_tools.cpp000066400000000000000000000431751517514752700212360ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "widechar_width.hpp" #include "btop_log.hpp" #include "btop_shared.hpp" #include "btop_tools.hpp" #include "btop_config.hpp" using std::cout; using std::floor; using std::flush; using std::max; using std::string_view; using std::to_string; using namespace std::literals; // to use operator""s namespace fs = std::filesystem; //? ------------------------------------------------- NAMESPACES ------------------------------------------------------ //* Collection of escape codes and functions for terminal manipulation namespace Term { atomic initialized{}; atomic width{}; atomic height{}; string current_tty; namespace { struct termios initial_settings; //* Toggle terminal input echo bool echo(bool on=true) { struct termios settings; if (tcgetattr(STDIN_FILENO, &settings)) return false; if (on) settings.c_lflag |= ECHO; else settings.c_lflag &= ~(ECHO); return 0 == tcsetattr(STDIN_FILENO, TCSANOW, &settings); } //* Toggle need for return key when reading input bool linebuffered(bool on=true) { struct termios settings; if (tcgetattr(STDIN_FILENO, &settings)) return false; if (on) settings.c_lflag |= ICANON; else { settings.c_lflag &= ~(ICANON); settings.c_cc[VMIN] = 0; settings.c_cc[VTIME] = 0; } if (tcsetattr(STDIN_FILENO, TCSANOW, &settings)) return false; if (on) setlinebuf(stdin); else setbuf(stdin, nullptr); return true; } } bool refresh(bool only_check) { // Query dimensions of '/dev/tty' of the 'STDOUT_FILENO' isn't available. // This variable is set in those cases to avoid calls to ioctl constinit static bool uses_dev_tty = false; struct winsize wsize {}; if (uses_dev_tty || ioctl(STDOUT_FILENO, TIOCGWINSZ, &wsize) < 0 || (wsize.ws_col == 0 && wsize.ws_row == 0)) { Logger::error(R"(Couldn't determine terminal size of "STDOUT_FILENO"!)"); auto dev_tty = open("/dev/tty", O_RDONLY | O_CLOEXEC); if (dev_tty != -1) { ioctl(dev_tty, TIOCGWINSZ, &wsize); close(dev_tty); } else { Logger::error(R"(Couldn't determine terminal size of "/dev/tty"!)"); return false; } uses_dev_tty = true; } if (width != wsize.ws_col or height != wsize.ws_row) { if (not only_check) { width = wsize.ws_col; height = wsize.ws_row; } return true; } return false; } auto get_min_size(const string& boxes) -> array { bool cpu = boxes.find("cpu") != string::npos; bool mem = boxes.find("mem") != string::npos; bool net = boxes.find("net") != string::npos; bool proc = boxes.find("proc") != string::npos; #ifdef GPU_SUPPORT int gpu = 0; if (Gpu::count > 0) for (char i = '0'; i <= '5'; i++) gpu += (boxes.contains("gpu"s + i) ? 1 : 0); #endif int width = 0; if (mem) width = Mem::min_width; else if (net) width = Mem::min_width; width += (proc ? Proc::min_width : 0); if (cpu and width < Cpu::min_width) width = Cpu::min_width; #ifdef GPU_SUPPORT if (gpu != 0 and width < Gpu::min_width) width = Gpu::min_width; #endif int height = (cpu ? Cpu::min_height : 0); if (proc) height += Proc::min_height; else height += (mem ? Mem::min_height : 0) + (net ? Net::min_height : 0); #ifdef GPU_SUPPORT for (int i = 0; i < gpu; i++) height += Gpu::gpu_b_height_offsets[i] + 4; #endif return { width, height }; } bool init() { if (not initialized) { initialized = (bool)isatty(STDIN_FILENO); if (initialized) { tcgetattr(STDIN_FILENO, &initial_settings); current_tty = (ttyname(STDIN_FILENO) != nullptr ? static_cast(ttyname(STDIN_FILENO)) : "unknown"); //? Disable stream sync - this does not seem to work on OpenBSD #ifndef __OpenBSD__ cout.sync_with_stdio(false); #endif //? Disable stream ties cout.tie(nullptr); echo(false); linebuffered(false); refresh(); const auto is_mouse_enabled = !Config::getB("disable_mouse"); cout << alt_screen << hide_cursor << (is_mouse_enabled ? mouse_on : mouse_off) << flush; Global::resized = false; } } return initialized; } void restore() { if (initialized) { tcsetattr(STDIN_FILENO, TCSANOW, &initial_settings); cout << mouse_off << clear << Fx::reset << normal_screen << show_cursor << flush; initialized = false; } } } //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- // ! Disabled due to issue when compiling with musl, reverted back to using regex // namespace Fx { // string uncolor(const string& s) { // string out = s; // for (size_t offset = 0, start_pos = 0, end_pos = 0;;) { // start_pos = (offset == 0) ? out.find('\x1b') : offset; // if (start_pos == string::npos) // break; // offset = start_pos + 1; // end_pos = out.find('m', offset); // if (end_pos == string::npos) // break; // else if (auto next_pos = out.find('\x1b', offset); not isdigit(out[end_pos - 1]) or end_pos > next_pos) { // offset = next_pos; // continue; // } // out.erase(start_pos, (end_pos - start_pos)+1); // offset = 0; // } // out.shrink_to_fit(); // return out; // } // } namespace Tools { string replace_ascii_control(string str, const char replacement) { if (str.empty()) return str; const char* str_data = &str.data()[0]; size_t w_len = 1 + std::mbstowcs(nullptr, str_data, 0); if (w_len <= 1) { std::ranges::for_each(str, [&replacement](char& c) { if (c < 0x20) c = replacement; }); return str; } vector w_str(w_len); std::mbstowcs(&w_str[0], str_data, w_len); for (size_t i = 0; i < w_str.size() - 1; i++) { if (widechar_wcwidth(w_str[i]) > 1) continue; if (w_str[i] < 0x20) w_str[i] = replacement; } size_t bytes = std::wcstombs(nullptr, w_str.data(), 0); if (bytes == static_cast(-1)) return str; str.resize(bytes); std::wcstombs(&str[0], &w_str[0], bytes); return str; } size_t wide_ulen(const std::string_view str) { if (str.empty()) return 0; unsigned int chars = 0; const char* str_data = &str.data()[0]; size_t w_len = 1 + std::mbstowcs(nullptr, str_data, 0); if (w_len <= 1) return ulen(str); vector w_str(w_len); std::mbstowcs(&w_str[0], str_data, w_len); for (auto c : w_str) { chars += widechar_wcwidth(c); } return chars; } size_t wide_ulen(const vector w_str) { unsigned int chars = 0; for (auto c : w_str) { chars += widechar_wcwidth(c); } return chars; } string uresize(string str, const size_t len, bool wide) { if (len < 1 or str.empty()) return ""; if (wide) { const char* str_data = &str.data()[0]; size_t w_len = 1 + std::mbstowcs(nullptr, str_data, 0); if (w_len <= 1) return uresize(str, len, false); vector w_str(w_len); std::mbstowcs(&w_str[0], str_data, w_len); while (wide_ulen(w_str) > len) w_str.pop_back(); string n_str; n_str.resize(w_str.size()); std::wcstombs(&n_str[0], &w_str[0], w_str.size()); return n_str; } else { for (size_t x = 0, i = 0; i < str.size(); i++) { if ((static_cast(str.at(i)) & 0xC0) != 0x80) x++; if (x >= len + 1) { str.resize(i); break; } } } str.shrink_to_fit(); return str; } string luresize(string str, const size_t len, bool wide) { if (len < 1 or str.empty()) return ""; for (size_t x = 0, last_pos = 0, i = str.size() - 1; i > 0 ; i--) { if (wide and static_cast(str.at(i)) > 0xef) { x += 2; last_pos = max((size_t)0, i - 1); } else if ((static_cast(str.at(i)) & 0xC0) != 0x80) { x++; last_pos = i; } if (x >= len) { str = str.substr(last_pos); str.shrink_to_fit(); break; } } return str; } string s_replace(const string& str, const string& from, const string& to) { string out = str; for (size_t start_pos = out.find(from); start_pos != std::string::npos; start_pos = out.find(from)) { out.replace(start_pos, from.length(), to); } return out; } string_view ltrim(string_view str, const string_view t_str) { while (str.starts_with(t_str)) str.remove_prefix(t_str.size()); return str; } string_view rtrim(string_view str, const string_view t_str) { while (str.ends_with(t_str)) str.remove_suffix(t_str.size()); return str; } string ljust(string str, const size_t x, bool utf, bool wide, bool limit) { if (utf) { if (limit and ulen(str, wide) > x) return uresize(str, x, wide); return str + string(max((int)(x - ulen(str)), 0), ' '); } else { if (limit and str.size() > x) { str.resize(x); return str; } return str + string(max((int)(x - str.size()), 0), ' '); } } string rjust(string str, const size_t x, bool utf, bool wide, bool limit) { if (utf) { if (limit and ulen(str, wide) > x) return uresize(str, x, wide); return string(max((int)(x - ulen(str)), 0), ' ') + str; } else { if (limit and str.size() > x) { str.resize(x); return str; }; return string(max((int)(x - str.size()), 0), ' ') + str; } } string cjust(string str, const size_t x, bool utf, bool wide, bool limit) { if (utf) { if (limit and ulen(str, wide) > x) return uresize(str, x, wide); return string(max((int)ceil((double)(x - ulen(str)) / 2), 0), ' ') + str + string(max((int)floor((double)(x - ulen(str)) / 2), 0), ' '); } else { if (limit and str.size() > x) { str.resize(x); return str; } return string(max((int)ceil((double)(x - str.size()) / 2), 0), ' ') + str + string(max((int)floor((double)(x - str.size()) / 2), 0), ' '); } } string trans(const string& str) { std::string_view oldstr{str}; string newstr; newstr.reserve(str.size()); for (size_t pos; (pos = oldstr.find(' ')) != string::npos;) { newstr.append(oldstr.substr(0, pos)); size_t x = 0; while (pos + x < oldstr.size() and oldstr.at(pos + x) == ' ') x++; newstr.append(Mv::r(x)); oldstr.remove_prefix(pos + x); } return (newstr.empty()) ? str : newstr + string{oldstr}; } string sec_to_dhms(size_t seconds, bool no_days, bool no_seconds) { size_t days = seconds / 86400; seconds %= 86400; size_t hours = seconds / 3600; seconds %= 3600; size_t minutes = seconds / 60; seconds %= 60; string out = (not no_days and days > 0 ? to_string(days) + "d " : "") + (hours < 10 ? "0" : "") + to_string(hours) + ':' + (minutes < 10 ? "0" : "") + to_string(minutes) + (not no_seconds ? ":" + string(std::cmp_less(seconds, 10) ? "0" : "") + to_string(seconds) : ""); return out; } string floating_humanizer(uint64_t value, bool shorten, size_t start, bool bit, bool per_second) { string out; const size_t mult = (bit) ? 8 : 1; bool mega = Config::getB("base_10_sizes"); // Bitrates if(bit && per_second) { const auto& base_10_bitrate = Config::getS("base_10_bitrate"); if(base_10_bitrate == "True") { mega = true; } else if(base_10_bitrate == "False") { mega = false; } // Default or "Auto": Uses base_10_sizes for bitrates } // taking advantage of type deduction for array creation (since C++17) // combined with string literals (operator""s) static const array mebiUnits_bit { "bit"s, "Kib"s, "Mib"s, "Gib"s, "Tib"s, "Pib"s, "Eib"s, "Zib"s, "Yib"s, "Bib"s, "GEb"s }; static const array mebiUnits_byte { "Byte"s, "KiB"s, "MiB"s, "GiB"s, "TiB"s, "PiB"s, "EiB"s, "ZiB"s, "YiB"s, "BiB"s, "GEB"s }; static const array megaUnits_bit { "bit"s, "Kb"s, "Mb"s, "Gb"s, "Tb"s, "Pb"s, "Eb"s, "Zb"s, "Yb"s, "Bb"s, "Gb"s }; static const array megaUnits_byte { "Byte"s, "KB"s, "MB"s, "GB"s, "TB"s, "PB"s, "EB"s, "ZB"s, "YB"s, "BB"s, "GB"s }; const auto& units = (bit) ? ( mega ? megaUnits_bit : mebiUnits_bit) : ( mega ? megaUnits_byte : mebiUnits_byte); value *= 100 * mult; if (mega) { while (value >= 100000) { value /= 1000; start++; } } else { while (value >= 102400) { value >>= 10; start++; } } if (out.empty()) { out = fmt::format("{}", value); if (not mega and out.size() == 4 and start > 0) { out.pop_back(); out.insert(2, "."); } else if (out.size() == 3 and start > 0) { out.insert(1, "."); } else if (out.size() >= 2) { out.resize(out.size() - 2); } if (out.empty()) { out = "0"; } } if (shorten) { auto has_sep = out.find(".") != string::npos; if (has_sep) { out = fmt::format("{:.1f}", stod(out)); } if (out.size() > 3) { // if out is of the form xy.z if (has_sep) { out = fmt::format("{:.0f}", stod(out)); } // if out is of the form xyzw (only when not using base 10) else { out = fmt::format("{:d}.0", out[0] - '0'); start++; } } out.push_back(units[start][0]); } else out += " " + units[start]; if (per_second) out += (bit) ? "ps" : "/s"; return out; } std::string operator*(const string& str, int64_t n) { if (n < 1 or str.empty()) { return ""; } else if (n == 1) { return str; } string new_str; new_str.reserve(str.size() * n); for (; n > 0; n--) new_str.append(str); return new_str; } string strf_time(const string& strf) { auto in_time_t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); std::tm bt {}; std::stringstream ss; ss << std::put_time(localtime_r(&in_time_t, &bt), strf.c_str()); return ss.str(); } void atomic_wait(const atomic& atom, bool old) noexcept { atom.wait(old, std::memory_order_relaxed); } void atomic_wait_for(const atomic& atom, bool old, const uint64_t wait_ms) noexcept { const uint64_t start_time = time_ms(); while (atom.load(std::memory_order_relaxed) == old and (time_ms() - start_time < wait_ms)) sleep_ms(1); } atomic_lock::atomic_lock(atomic& atom, bool wait) : atom(atom) { if (wait) while (not this->atom.compare_exchange_strong(this->not_true, true)); else this->atom.store(true); this->atom.notify_all(); } atomic_lock::~atomic_lock() noexcept { this->atom.store(false); this->atom.notify_all(); } string readfile(const std::filesystem::path& path, const string& fallback) { if (not fs::exists(path)) return fallback; string out; try { std::ifstream file(path); for (string readstr; getline(file, readstr); out += readstr); } catch (const std::exception& e) { Logger::error("readfile() : Exception when reading {} : {}", path, e.what()); return fallback; } return (out.empty() ? fallback : out); } auto celsius_to(const long long& celsius, const string& scale) -> tuple { if (scale == "celsius") return {celsius, "ยฐC"}; else if (scale == "fahrenheit") return {(long long)round((double)celsius * 1.8 + 32), "ยฐF"}; else if (scale == "kelvin") return {(long long)round((double)celsius + 273.15), "K "}; else if (scale == "rankine") return {(long long)round((double)celsius * 1.8 + 491.67), "ยฐR"}; return {0, ""}; } string hostname() { char host[HOST_NAME_MAX]; gethostname(host, HOST_NAME_MAX); host[HOST_NAME_MAX - 1] = '\0'; return string{host}; } string username() { auto user = getenv("LOGNAME"); if (user == nullptr or strlen(user) == 0) user = getenv("USER"); return (user != nullptr ? user : ""); } DebugTimer::DebugTimer(string name, bool start, bool delayed_report) : name(std::move(name)), delayed_report(delayed_report) { if (start) this->start(); } DebugTimer::~DebugTimer() { if (running) this->stop(true); this->force_report(); } void DebugTimer::start() { if (running) return; running = true; start_time = time_micros(); } void DebugTimer::stop(bool report) { if (not running) return; running = false; elapsed_time = time_micros() - start_time; if (report) this->report(); } void DebugTimer::reset(bool restart) { running = false; start_time = 0; elapsed_time = 0; if (restart) this->start(); } void DebugTimer::stop_rename_reset(const string &new_name, bool report, bool restart) { this->stop(report); name = new_name; this->reset(restart); } void DebugTimer::report() { string report_line; if (start_time == 0 and elapsed_time == 0) report_line = fmt::format("DebugTimer::report() warning -> Timer [{}] has not been started!", name); else if (running) report_line = fmt::format(custom_locale, "Timer [{}] (running) currently at {:L} ฮผs", name, time_micros() - start_time); else report_line = fmt::format(custom_locale, "Timer [{}] took {:L} ฮผs", name, elapsed_time); if (delayed_report) report_buffer.emplace_back(report_line); else Logger::debug("{}", report_line); } void DebugTimer::force_report() { if (report_buffer.empty()) return; for (const auto& line : report_buffer) Logger::debug("{}", line); report_buffer.clear(); } uint64_t DebugTimer::elapsed() { if (running) return time_micros() - start_time; return elapsed_time; } bool DebugTimer::is_running() { return running; } } aristocratos-btop-d43a485/src/btop_tools.hpp000066400000000000000000000367611517514752700212460ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #if !defined(NDEBUG) # define BTOP_DEBUG #endif #include // for std::ranges::count_if #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BTOP_DEBUG #include #endif #ifndef HOST_NAME_MAX #ifdef __APPLE__ #define HOST_NAME_MAX 255 #else #define HOST_NAME_MAX 64 #endif #endif #include #include #include "btop_log.hpp" using std::array; using std::atomic; using std::string; using std::to_string; using std::string_view; using std::tuple; using std::vector; using namespace fmt::literals; //? ------------------------------------------------- NAMESPACES ------------------------------------------------------ //* Collection of escape codes for text style and formatting namespace Fx { const string e = "\x1b["; //* Escape sequence start const string b = e + "1m"; //* Bold on/off const string ub = e + "22m"; //* Bold off const string d = e + "2m"; //* Dark on const string ud = e + "22m"; //* Dark off const string i = e + "3m"; //* Italic on const string ui = e + "23m"; //* Italic off const string ul = e + "4m"; //* Underline on const string uul = e + "24m"; //* Underline off const string bl = e + "5m"; //* Blink on const string ubl = e + "25m"; //* Blink off const string s = e + "9m"; //* Strike/crossed-out on const string us = e + "29m"; //* Strike/crossed-out on/off //* Reset foreground/background color and text effects const string reset_base = e + "0m"; //* Reset text effects and restore theme foregrund and background color extern string reset; //* Regex for matching color, style and cursor move escape sequences const std::regex escape_regex("\033\\[\\d+;?\\d?;?\\d*;?\\d*;?\\d*(m|f|s|u|C|D|A|B){1}"); //* Regex for matching only color and style escape sequences const std::regex color_regex("\033\\[\\d+;?\\d?;?\\d*;?\\d*;?\\d*(m){1}"); //* Return a string with all colors and text styling removed inline string uncolor(const string& s) { return std::regex_replace(s, color_regex, ""); } // string uncolor(const string& s); } //* Collection of escape codes and functions for cursor manipulation namespace Mv { //* Move cursor to , inline string to(int line, int col) { return Fx::e + to_string(line) + ';' + to_string(col) + 'f'; } //* Move cursor right columns inline string r(int x) { return Fx::e + to_string(x) + 'C'; } //* Move cursor left columns inline string l(int x) { return Fx::e + to_string(x) + 'D'; } //* Move cursor up x lines inline string u(int x) { return Fx::e + to_string(x) + 'A'; } //* Move cursor down x lines inline string d(int x) { return Fx::e + to_string(x) + 'B'; } //* Save cursor position const string save = Fx::e + "s"; //* Restore saved cursor position const string restore = Fx::e + "u"; } //* Collection of escape codes and functions for terminal manipulation namespace Term { extern atomic initialized; extern atomic width; extern atomic height; extern string fg, bg, current_tty; const string hide_cursor = Fx::e + "?25l"; const string show_cursor = Fx::e + "?25h"; const string alt_screen = Fx::e + "?1049h"; const string normal_screen = Fx::e + "?1049l"; const string clear = Fx::e + "2J" + Fx::e + "0;0f"; const string clear_end = Fx::e + "0J"; const string clear_begin = Fx::e + "1J"; const string mouse_on = Fx::e + "?1002h" + Fx::e + "?1015h" + Fx::e + "?1006h"; //? Enable reporting of mouse position on click and release const string mouse_off = Fx::e + "?1002l" + Fx::e + "?1015l" + Fx::e + "?1006l"; const string mouse_direct_on = Fx::e + "?1003h"; //? Enable reporting of mouse position at any movement const string mouse_direct_off = Fx::e + "?1003l"; const string sync_start = Fx::e + "?2026h"; //? Start of terminal synchronized output const string sync_end = Fx::e + "?2026l"; //? End of terminal synchronized output //* Returns true if terminal has been resized and updates width and height bool refresh(bool only_check=false); //* Returns an array with the lowest possible width, height with current box config auto get_min_size(const string& boxes) -> array; //* Check for a valid tty, save terminal options and set new options bool init(); //* Restore terminal options void restore(); } //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace Tools { constexpr auto SSmax = std::numeric_limits::max(); class MyNumPunct : public std::numpunct { protected: virtual char do_thousands_sep() const override { return '\''; } virtual std::string do_grouping() const override { return "\03"; } }; size_t wide_ulen(const std::string_view str); size_t wide_ulen(const vector w_str); //* Return number of UTF8 characters in a string (wide=true for column size needed on terminal) inline size_t ulen(const std::string_view str, bool wide = false) { return (wide ? wide_ulen(str) : std::ranges::count_if(str, [](char c) { return (static_cast(c) & 0xC0) != 0x80; })); } //* Resize a string consisting of UTF8 characters (only reduces size) string uresize(const string str, const size_t len, bool wide = false); //* Resize a string consisting of UTF8 characters from left (only reduces size) string luresize(const string str, const size_t len, bool wide = false); //* Replace in with and return new string string s_replace(const string& str, const string& from, const string& to); //* Replace ascii control characters with in and return new string string replace_ascii_control(string str, const char replacement = ' '); //* Capitalize inline string capitalize(string str) { str.at(0) = toupper(str.at(0)); return str; } //* Return with only uppercase characters inline auto str_to_upper(string str) { std::ranges::for_each(str, [](auto& c) { c = ::toupper(c); } ); return str; } //* Return with only lowercase characters inline auto str_to_lower(string str) { std::ranges::for_each(str, [](char& c) { c = ::tolower(c); } ); return str; } //* Check if vector contains value template inline bool v_contains(const vector& vec, const T2& find_val) { return std::ranges::find(vec, find_val) != vec.end(); } //* Check if string contains string , while ignoring case inline bool s_contains_ic(const std::string_view str, const std::string_view find_val) { auto it = std::search( str.begin(), str.end(), find_val.begin(), find_val.end(), [](char ch1, char ch2) { return std::toupper(ch1) == std::toupper(ch2); } ); return it != str.end(); } //* Return index of from vector , returns size of if is not present template inline size_t v_index(const vector& vec, const T& find_val) { return std::ranges::distance(vec.begin(), std::ranges::find(vec, find_val)); } //* Compare with all following values template inline bool is_in(const First& first, const T& ... t) { return ((first == t) or ...); } //* Return current time since epoch in seconds inline uint64_t time_s() { return std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); } //* Return current time since epoch in milliseconds inline uint64_t time_ms() { return std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); } //* Return current time since epoch in microseconds inline uint64_t time_micros() { return std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); } //* Check if a string is a valid bool value inline bool isbool(const std::string_view str) { return is_in(str, "true", "false", "True", "False"); } //* Convert string to bool, returning any value not equal to "true" or "True" as false inline bool stobool(const std::string_view str) { return is_in(str, "true", "True"); } //* Check if a string is a valid integer value (only positive) constexpr bool isint(const std::string_view str) { return std::ranges::all_of(str, ::isdigit); } //* Left-trim from and return new string string_view ltrim(string_view str, string_view t_str = " "); //* Right-trim from and return new string string_view rtrim(string_view str, string_view t_str = " "); //* Left/right-trim from and return new string inline string_view trim(string_view str, string_view t_str = " ") { return ltrim(rtrim(str, t_str), t_str); } //* Split at all occurrences of and return as vector of strings constexpr auto ssplit(std::string_view str, char delim = ' ') { return str | std::views::split(delim) | std::views::filter([](auto&& range) { return !std::ranges::empty(range); }) | std::ranges::to>(); } //* Put current thread to sleep for milliseconds inline void sleep_ms(const size_t& ms) { std::this_thread::sleep_for(std::chrono::milliseconds(ms)); } //* Put current thread to sleep for microseconds inline void sleep_micros(const size_t& micros) { std::this_thread::sleep_for(std::chrono::microseconds(micros)); } //* Left justify string if is greater than length, limit return size to by default string ljust(string str, const size_t x, bool utf = false, bool wide = false, bool limit = true); //* Right justify string if is greater than length, limit return size to by default string rjust(string str, const size_t x, bool utf = false, bool wide = false, bool limit = true); //* Center justify string if is greater than length, limit return size to by default string cjust(string str, const size_t x, bool utf = false, bool wide = false, bool limit = true); //* Replace whitespaces " " with escape code for move right string trans(const string& str); //* Convert seconds to format "d ::" and return string string sec_to_dhms(size_t seconds, bool no_days = false, bool no_seconds = false); //* Scales up in steps of 1024 to highest positive value unit and returns string with unit suffixed //* bit=true or defaults to bytes //* start=int to set 1024 multiplier starting unit //* shorten=true shortens value to at most 3 characters and shortens unit to 1 character string floating_humanizer(uint64_t value, bool shorten = false, size_t start = 0, bool bit = false, bool per_second = false); //* Add std::string operator * : Repeat string number of times std::string operator*(const string& str, int64_t n); template #ifdef BTOP_DEBUG const T& safeVal(const std::unordered_map& map, const K& key, const T& fallback = T{}, std::source_location loc = std::source_location::current()) { if (auto it = map.find(key); it != map.end()) { return it->second; } else { Logger::error("safeVal() called with invalid key: [{}] in file: {} on line: {}", key, loc.file_name(), loc.line()); return fallback; } }; #else const T& safeVal(const std::unordered_map& map, const K& key, const T& fallback = T{}) { if (auto it = map.find(key); it != map.end()) { return it->second; } else { Logger::error("safeVal() called with invalid key: [{}] (Compile btop with DEBUG=true for more extensive logging!)", key); return fallback; } }; #endif template #ifdef BTOP_DEBUG const T& safeVal(const std::vector& vec, const size_t& index, const T& fallback = T{}, std::source_location loc = std::source_location::current()) { if (index < vec.size()) { return vec[index]; } else { Logger::error("safeVal() called with invalid index: [{}] in file: {} on line: {}", index, loc.file_name(), loc.line()); return fallback; } }; #else const T& safeVal(const std::vector& vec, const size_t& index, const T& fallback = T{}) { if (index < vec.size()) { return vec[index]; } else { Logger::error("safeVal() called with invalid index: [{}] (Compile btop with DEBUG=true for more extensive logging!)", index); return fallback; } }; #endif //* Return current time in format string strf_time(const string& strf); string hostname(); string username(); void atomic_wait(const atomic& atom, bool old = true) noexcept; void atomic_wait_for(const atomic& atom, bool old = true, const uint64_t wait_ms = 0) noexcept; //* Sets atomic to true on construct, sets to false on destruct class atomic_lock { atomic& atom; bool not_true{}; public: explicit atomic_lock(atomic& atom, bool wait = false); ~atomic_lock() noexcept; atomic_lock(const atomic_lock& other) = delete; atomic_lock& operator=(const atomic_lock& other) = delete; atomic_lock(atomic_lock&& other) = delete; atomic_lock& operator=(atomic_lock&& other) = delete; }; //* Read a complete file and return as a string string readfile(const std::filesystem::path& path, const string& fallback = ""); //* Convert a celsius value to celsius, fahrenheit, kelvin or rankin and return tuple with new value and unit. auto celsius_to(const long long& celsius, const string& scale) -> tuple; } namespace Tools { //* Creates a named timer that is started on construct (by default) and reports elapsed time in microseconds to Logger::debug() on destruct if running //* Unless delayed_report is set to false, all reporting is buffered and delayed until DebugTimer is destructed or .force_report() is called //* Usage example: Tools::DebugTimer timer(name:"myTimer", [start:true], [delayed_report:true]) // Create timer and start //* timer.stop(); // Stop timer and report elapsed time //* timer.stop_rename_reset("myTimer2"); // Stop timer, report elapsed time, rename timer, reset and restart class DebugTimer { uint64_t start_time{}; uint64_t elapsed_time{}; bool running{}; std::locale custom_locale = std::locale(std::locale::classic(), new Tools::MyNumPunct); vector report_buffer{}; string name{}; bool delayed_report{}; public: DebugTimer() = default; explicit DebugTimer(string name, bool start = true, bool delayed_report = true); ~DebugTimer(); DebugTimer(const DebugTimer& other) = delete; DebugTimer& operator=(const DebugTimer& other) = delete; DebugTimer(DebugTimer&& other) = delete; DebugTimer& operator=(DebugTimer&& other) = delete; void start(); void stop(bool report = true); void reset(bool restart = true); //* Stops and reports (default), renames timer then resets and restarts (default) void stop_rename_reset(const string& new_name, bool report = true, bool restart = true); void report(); void force_report(); uint64_t elapsed(); bool is_running(); }; } aristocratos-btop-d43a485/src/config.h.in000066400000000000000000000005251517514752700203610ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #pragma once #include constexpr std::string_view GIT_COMMIT = "@GIT_COMMIT@"; constexpr std::string_view COMPILER = "@COMPILER@"; constexpr std::string_view COMPILER_VERSION = "@COMPILER_VERSION@"; constexpr std::string_view CONFIGURE_COMMAND = "@CONFIGURE_COMMAND@"; aristocratos-btop-d43a485/src/freebsd/000077500000000000000000000000001517514752700177465ustar00rootroot00000000000000aristocratos-btop-d43a485/src/freebsd/btop_collect.cpp000066400000000000000000001330071517514752700231270ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include // man 3 getifaddrs: "BUGS: If both and are being included, must be included before " #include #include #include #include #include #include #include // for inet_ntop stuff #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../btop_config.hpp" #include "../btop_log.hpp" #include "../btop_shared.hpp" #include "../btop_tools.hpp" using std::clamp, std::string_literals::operator""s, std::cmp_equal, std::cmp_less, std::cmp_greater; using std::ifstream, std::numeric_limits, std::streamsize, std::round, std::max, std::min; namespace fs = std::filesystem; namespace rng = std::ranges; using namespace Tools; //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace Cpu { vector core_old_totals; vector core_old_idles; vector available_fields = {"Auto", "total"}; vector available_sensors = {"Auto"}; cpu_info current_cpu; bool got_sensors = false, cpu_temp_only = false, supports_watts = false; //* Populate found_sensors map bool get_sensors(); //* Get current cpu clock speed string get_cpuHz(); //* Search /proc/cpuinfo for a cpu name string get_cpuName(); struct Sensor { fs::path path; string label; int64_t temp = 0; int64_t high = 0; int64_t crit = 0; }; string cpu_sensor; vector core_sensors; std::unordered_map core_mapping; } // namespace Cpu namespace Mem { double old_uptime; std::vector zpools; void get_zpools(); } namespace Shared { fs::path passwd_path; uint64_t totalMem; long pageSize, clkTck, coreCount, physicalCoreCount, arg_max; int totalMem_len, kfscale; long bootTime; void init() { //? Shared global variables init int mib[2]; mib[0] = CTL_HW; mib[1] = HW_NCPU; int ncpu; size_t len = sizeof(ncpu); if (sysctl(mib, 2, &ncpu, &len, nullptr, 0) == -1) { Logger::warning("Could not determine number of cores, defaulting to 1."); } else { coreCount = ncpu; } pageSize = sysconf(_SC_PAGE_SIZE); if (pageSize <= 0) { pageSize = 4096; Logger::warning("Could not get system page size. Defaulting to 4096, processes memory usage might be incorrect."); } clkTck = sysconf(_SC_CLK_TCK); if (clkTck <= 0) { clkTck = 100; Logger::warning("Could not get system clock ticks per second. Defaulting to 100, processes cpu usage might be incorrect."); } int64_t memsize = 0; size_t size = sizeof(memsize); if (sysctlbyname("hw.physmem", &memsize, &size, nullptr, 0) < 0) { Logger::warning("Could not get memory size"); } totalMem = memsize; struct timeval result; size = sizeof(result); if (sysctlbyname("kern.boottime", &result, &size, nullptr, 0) < 0) { Logger::warning("Could not get boot time"); } else { bootTime = result.tv_sec; } size = sizeof(kfscale); if (sysctlbyname("kern.fscale", &kfscale, &size, nullptr, 0) == -1) { kfscale = 2048; } //* Get maximum length of process arguments arg_max = sysconf(_SC_ARG_MAX); //? Init for namespace Cpu Cpu::current_cpu.core_percent.insert(Cpu::current_cpu.core_percent.begin(), Shared::coreCount, {}); Cpu::current_cpu.temp.insert(Cpu::current_cpu.temp.begin(), Shared::coreCount + 1, {}); Cpu::core_old_totals.insert(Cpu::core_old_totals.begin(), Shared::coreCount, 0); Cpu::core_old_idles.insert(Cpu::core_old_idles.begin(), Shared::coreCount, 0); Logger::debug("Init -> Cpu::collect()"); Cpu::collect(); for (auto &[field, vec] : Cpu::current_cpu.cpu_percent) { if (not vec.empty() and not v_contains(Cpu::available_fields, field)) Cpu::available_fields.push_back(field); } Logger::debug("Init -> Cpu::get_cpuName()"); Cpu::cpuName = Cpu::get_cpuName(); Logger::debug("Init -> Cpu::get_sensors()"); Cpu::got_sensors = Cpu::get_sensors(); Logger::debug("Init -> Cpu::get_core_mapping()"); Cpu::core_mapping = Cpu::get_core_mapping(); //? Init for namespace Mem Mem::old_uptime = system_uptime(); Logger::debug("Init -> Mem::collect()"); Mem::collect(); Logger::debug("Init -> Mem::get_zpools()"); Mem::get_zpools(); } } // namespace Shared namespace Cpu { string cpuName; string cpuHz; bool has_battery = true; tuple current_bat; const array time_names = {"user", "nice", "system", "idle"}; std::unordered_map cpu_old = { {"totals", 0}, {"idles", 0}, {"user", 0}, {"nice", 0}, {"system", 0}, {"idle", 0} }; string get_cpuName() { string name; char buffer[1024]; size_t size = sizeof(buffer); if (sysctlbyname("hw.model", &buffer, &size, nullptr, 0) < 0) { Logger::error("Failed to get CPU name"); return name; } return trim_name(string(buffer)); } bool get_sensors() { got_sensors = false; if (Config::getB("show_coretemp") and Config::getB("check_temp")) { int32_t temp; size_t size = sizeof(temp); if (sysctlbyname("dev.cpu.0.temperature", &temp, &size, nullptr, 0) < 0) { Logger::warning("Could not get temp sensor - maybe you need to load the coretemp module"); } else { got_sensors = true; int temp; size_t size = sizeof(temp); sysctlbyname("dev.cpu.0.coretemp.tjmax", &temp, &size, nullptr, 0); //assuming the max temp is same for all cores temp = (temp - 2732) / 10; // since it's an int, it's multiplied by 10, and offset to absolute zero... current_cpu.temp_max = temp; } } return got_sensors; } void update_sensors() { int temp = 0; int p_temp = 0; int found = 0; bool got_package = false; size_t size = sizeof(p_temp); if (sysctlbyname("hw.acpi.thermal.tz0.temperature", &p_temp, &size, nullptr, 0) >= 0) { got_package = true; p_temp = (p_temp - 2732) / 10; // since it's an int, it's multiplied by 10, and offset to absolute zero... } size = sizeof(temp); for (int i = 0; i < Shared::coreCount; i++) { string s = "dev.cpu." + std::to_string(i) + ".temperature"; if (sysctlbyname(s.c_str(), &temp, &size, nullptr, 0) >= 0) { temp = (temp - 2732) / 10; if (not got_package) { p_temp += temp; found++; } if (cmp_less(i + 1, current_cpu.temp.size())) { current_cpu.temp.at(i + 1).push_back(temp); if (current_cpu.temp.at(i + 1).size() > 20) current_cpu.temp.at(i + 1).pop_front(); } } } if (not got_package) p_temp /= found; current_cpu.temp.at(0).push_back(p_temp); if (current_cpu.temp.at(0).size() > 20) current_cpu.temp.at(0).pop_front(); } string get_cpuHz() { unsigned int freq = 1; size_t size = sizeof(freq); if (sysctlbyname("dev.cpu.0.freq", &freq, &size, nullptr, 0) < 0) { return ""; } return std::to_string(freq / 1000.0 ).substr(0, 3); // seems to be in MHz } auto get_core_mapping() -> std::unordered_map { std::unordered_map core_map; if (cpu_temp_only) return core_map; for (long i = 0; i < Shared::coreCount; i++) { core_map[i] = i; } //? If core mapping from cpuinfo was incomplete try to guess remainder, if missing completely, map 0-0 1-1 2-2 etc. if (cmp_less(core_map.size(), Shared::coreCount)) { if (Shared::coreCount % 2 == 0 and (long) core_map.size() == Shared::coreCount / 2) { for (int i = 0, n = 0; i < Shared::coreCount / 2; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[Shared::coreCount / 2 + i] = n++; } } else { core_map.clear(); for (int i = 0, n = 0; i < Shared::coreCount; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[i] = n++; } } } //? Apply user set custom mapping if any const auto &custom_map = Config::getS("cpu_core_map"); if (not custom_map.empty()) { try { for (const auto &split : ssplit(custom_map)) { const auto vals = ssplit(split, ':'); if (vals.size() != 2) continue; int change_id = std::stoi(vals.at(0)); int new_id = std::stoi(vals.at(1)); if (not core_map.contains(change_id) or cmp_greater(new_id, core_sensors.size())) continue; core_map.at(change_id) = new_id; } } catch (...) { } } return core_map; } auto get_battery() -> tuple { if (not has_battery) return {0, 0, 0, ""}; long seconds = -1; float watts = -1; uint32_t percent = -1; size_t size = sizeof(percent); string status = "discharging"; if (sysctlbyname("hw.acpi.battery.life", &percent, &size, nullptr, 0) < 0) { has_battery = false; } else { has_battery = true; size_t size = sizeof(seconds); if (sysctlbyname("hw.acpi.battery.time", &seconds, &size, nullptr, 0) < 0) { seconds = 0; } size = sizeof(watts); if (sysctlbyname("hw.acpi.battery.rate", &watts, &size, nullptr, 0) < 0) { watts = -1; } int state; size = sizeof(state); if (sysctlbyname("hw.acpi.battery.state", &state, &size, nullptr, 0) < 0) { status = "unknown"; } else { if (state == 2) { status = "charging"; } } if (percent == 100) { status = "full"; } } return {percent, watts, seconds, status}; } auto collect(bool no_update) -> cpu_info & { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto &cpu = current_cpu; if (getloadavg(cpu.load_avg.data(), cpu.load_avg.size()) < 0) { Logger::error("failed to get load averages"); } vector> cpu_time(Shared::coreCount); size_t size = sizeof(long) * CPUSTATES * Shared::coreCount; if (sysctlbyname("kern.cp_times", &cpu_time[0], &size, nullptr, 0) == -1) { Logger::error("failed to get CPU times"); } long long global_totals = 0; long long global_idles = 0; vector times_summed = {0, 0, 0, 0}; for (long i = 0; i < Shared::coreCount; i++) { vector times; //? 0=user, 1=nice, 2=system, 3=idle for (int x = 0; const unsigned int c_state : {CP_USER, CP_NICE, CP_SYS, CP_IDLE}) { auto val = cpu_time[i][c_state]; times.push_back(val); times_summed.at(x++) += val; } try { //? All values const long long totals = std::accumulate(times.begin(), times.end(), 0ll); //? Idle time const long long idles = times.at(3); global_totals += totals; global_idles += idles; //? Calculate cpu total for each core if (i > Shared::coreCount) break; const long long calc_totals = max(0ll, totals - core_old_totals.at(i)); const long long calc_idles = max(0ll, idles - core_old_idles.at(i)); core_old_totals.at(i) = totals; core_old_idles.at(i) = idles; cpu.core_percent.at(i).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph if (cpu.core_percent.at(i).size() > 40) cpu.core_percent.at(i).pop_front(); } catch (const std::exception &e) { Logger::error("Cpu::collect() : {}", e.what()); throw std::runtime_error(fmt::format("collect() : {}", e.what())); } } const long long calc_totals = max(1ll, global_totals - cpu_old.at("totals")); const long long calc_idles = max(1ll, global_idles - cpu_old.at("idles")); //? Populate cpu.cpu_percent with all fields from syscall for (int ii = 0; const auto &val : times_summed) { cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); cpu_old.at(time_names.at(ii)) = val; //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); ii++; } cpu_old.at("totals") = global_totals; cpu_old.at("idles") = global_idles; //? Total usage of cpu cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); if (Config::getB("show_cpu_freq")) { auto hz = get_cpuHz(); if (hz != "") { cpuHz = hz; } } if (Config::getB("check_temp") and got_sensors) update_sensors(); if (Config::getB("show_battery") and has_battery) current_bat = get_battery(); return cpu; } } // namespace Cpu namespace Mem { bool has_swap = false; vector fstab; fs::file_time_type fstab_time; int disk_ios = 0; vector last_found; mem_info current_mem{}; uint64_t get_totalMem() { return Shared::totalMem; } void assign_values(struct disk_info& disk, int64_t readBytes, int64_t writeBytes) { disk_ios++; if (disk.io_read.empty()) { disk.io_read.push_back(0); } else { disk.io_read.push_back(max((int64_t)0, (readBytes - disk.old_io.at(0)))); } disk.old_io.at(0) = readBytes; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); if (disk.io_write.empty()) { disk.io_write.push_back(0); } else { disk.io_write.push_back(max((int64_t)0, (writeBytes - disk.old_io.at(1)))); } disk.old_io.at(1) = writeBytes; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); // no io times - need to push something anyway or we'll get an ABORT if (disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(clamp((long)round((double)(disk.io_write.back() + disk.io_read.back()) / (1 << 20)), 0l, 100l)); while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } class PipeWrapper { public: PipeWrapper(const char *file, const char *mode) {fd = popen(file, mode);} virtual ~PipeWrapper() {if (fd) pclose(fd);} auto operator()() -> FILE* { return fd;}; private: FILE *fd; }; // find all zpools in the system. Do this only at startup. void get_zpools() { std::regex toReplace("\\."); PipeWrapper poolPipe = PipeWrapper("zpool list -H -o name", "r"); while (not std::feof(poolPipe())) { char poolName[512]; size_t len = 512; if (fgets(poolName, len, poolPipe())) { poolName[strcspn(poolName, "\n")] = 0; Logger::debug("zpool found: {}", poolName); Mem::zpools.push_back(std::regex_replace(poolName, toReplace, "%25")); } } } void collect_disk(std::unordered_map &disks, std::unordered_map &mapping) { // this bit is for 'regular' mounts static struct statinfo cur; long double etime = 0; uint64_t total_bytes_read; uint64_t total_bytes_write; static std::unique_ptr curDevInfo (reinterpret_cast(std::calloc(1, sizeof(struct devinfo))), std::free); cur.dinfo = curDevInfo.get(); if (devstat_getdevs(nullptr, &cur) != -1) { for (int i = 0; i < cur.dinfo->numdevs; i++) { auto d = cur.dinfo->devices[i]; string devStatName = "/dev/" + string(d.device_name) + std::to_string(d.unit_number); for (auto& [ignored, disk] : disks) { // find matching mountpoints - could be multiple as d.device_name is only ada (and d.unit_number is the device number), while the disk.dev is like /dev/ada0s1 if (disk.dev.string().rfind(devStatName, 0) == 0 and mapping.contains(disk.dev)) { devstat_compute_statistics(&d, nullptr, etime, DSM_TOTAL_BYTES_READ, &total_bytes_read, DSM_TOTAL_BYTES_WRITE, &total_bytes_write, DSM_NONE); assign_values(disk, total_bytes_read, total_bytes_write); string mountpoint = mapping.at(disk.dev); Logger::debug("dev {} -> {} read={} write={}", devStatName, mountpoint, total_bytes_read, total_bytes_write); } } } } // this code is for ZFS mounts for (const auto &poolName : Mem::zpools) { char sysCtl[1024]; snprintf(sysCtl, sizeof(sysCtl), "sysctl kstat.zfs.%s.dataset | grep -E \'dataset_name|nread|nwritten\'", poolName.c_str()); PipeWrapper f = PipeWrapper(sysCtl, "r"); if (f()) { char buf[512]; size_t len = 512; uint64_t nread = 0, nwritten = 0; while (not std::feof(f())) { if (fgets(buf, len, f())) { char *name = std::strtok(buf, ": \n"); char *value = std::strtok(nullptr, ": \n"); if (string(name).find("dataset_name") != string::npos) { // create entry if datasetname matches with anything in mapping // relies on the fact that the dataset name is last value in the list // alternatively you could parse the objset-0x... when this changes, you have a new entry string datasetname = string(value);// this is the zfs volume, like 'zroot/usr/home' -> this maps onto the device we get back from getmntinfo(3) if (mapping.contains(datasetname)) { string mountpoint = mapping.at(datasetname); if (disks.contains(mountpoint)) { auto& disk = disks.at(mountpoint); assign_values(disk, nread, nwritten); } } } else if (string(name).find("nread") != string::npos) { nread = atoll(value); } else if (string(name).find("nwritten") != string::npos) { nwritten = atoll(value); } } } } } } auto collect(bool no_update) -> mem_info & { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; auto show_swap = Config::getB("show_swap"); auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; static bool snapped = (getenv("BTOP_SNAPPED") != nullptr); int mib[4]; u_int memActive, memWire, cachedMem, freeMem; size_t len; len = 4; sysctlnametomib("vm.stats.vm.v_active_count", mib, &len); len = sizeof(memActive); sysctl(mib, 4, &(memActive), &len, nullptr, 0); memActive *= Shared::pageSize; len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", mib, &len); len = sizeof(memWire); sysctl(mib, 4, &(memWire), &len, nullptr, 0); memWire *= Shared::pageSize; mem.stats.at("used") = memWire + memActive; mem.stats.at("available") = Shared::totalMem - memActive - memWire; len = sizeof(cachedMem); len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", mib, &len); sysctl(mib, 4, &(cachedMem), &len, nullptr, 0); cachedMem *= Shared::pageSize; mem.stats.at("cached") = cachedMem; len = sizeof(freeMem); len = 4; sysctlnametomib("vm.stats.vm.v_free_count", mib, &len); sysctl(mib, 4, &(freeMem), &len, nullptr, 0); freeMem *= Shared::pageSize; mem.stats.at("free") = freeMem; if (show_swap) { char buf[_POSIX2_LINE_MAX]; Shared::KvmPtr kd {kvm_openfiles(nullptr, _PATH_DEVNULL, nullptr, O_RDONLY, buf)}; struct kvm_swap swap[16]; int nswap = kvm_getswapinfo(kd.get(), swap, 16, 0); int totalSwap = 0, usedSwap = 0; for (int i = 0; i < nswap; i++) { totalSwap += swap[i].ksw_total; usedSwap += swap[i].ksw_used; } mem.stats.at("swap_total") = totalSwap * Shared::pageSize; mem.stats.at("swap_used") = usedSwap * Shared::pageSize; } if (show_swap and mem.stats.at("swap_total") > 0) { for (const auto &name : swap_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / mem.stats.at("swap_total"))); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } has_swap = true; } else has_swap = false; //? Calculate percentages for (const auto &name : mem_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / Shared::totalMem)); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } if (show_disks) { std::unordered_map mapping; // keep mapping from device -> mountpoint, since IOKit doesn't give us the mountpoint double uptime = system_uptime(); auto &disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; // auto only_physical = Config::getB("only_physical"); auto &disks = mem.disks; vector filter; if (not disks_filter.empty()) { filter = ssplit(disks_filter); if (filter.at(0).starts_with("exclude=")) { filter_exclude = true; filter.at(0) = filter.at(0).substr(8); } } struct statfs *stfs; int count = getmntinfo(&stfs, MNT_WAIT); vector found; found.reserve(last_found.size()); for (int i = 0; i < count; i++) { auto fstype = string(stfs[i].f_fstypename); if (fstype == "autofs" || fstype == "devfs" || fstype == "linprocfs" || fstype == "procfs" || fstype == "tmpfs" || fstype == "linsysfs" || fstype == "fdesckfs") { // in memory filesystems -> not useful to show continue; } std::error_code ec; string mountpoint = stfs[i].f_mntonname; string dev = stfs[i].f_mntfromname; mapping[dev] = mountpoint; //? Match filter if not empty if (not filter.empty()) { bool match = v_contains(filter, mountpoint); if ((filter_exclude and match) or (not filter_exclude and not match)) continue; } found.push_back(mountpoint); if (not disks.contains(mountpoint)) { disks[mountpoint] = disk_info{fs::canonical(dev, ec), fs::path(mountpoint).filename()}; if (disks.at(mountpoint).dev.empty()) disks.at(mountpoint).dev = dev; if (disks.at(mountpoint).name.empty()) disks.at(mountpoint).name = (mountpoint == "/" ? "root" : mountpoint); } if (not v_contains(last_found, mountpoint)) redraw = true; disks.at(mountpoint).free = stfs[i].f_bfree; disks.at(mountpoint).total = stfs[i].f_iosize; } //? Remove disks no longer mounted or filtered out if (swap_disk and has_swap) found.push_back("swap"); for (auto it = disks.begin(); it != disks.end();) { if (not v_contains(found, it->first)) it = disks.erase(it); else it++; } if (found.size() != last_found.size()) redraw = true; last_found = std::move(found); //? Get disk/partition stats for (auto &[mountpoint, disk] : disks) { if (std::error_code ec; not fs::exists(mountpoint, ec)) continue; struct statvfs vfs; if (statvfs(mountpoint.c_str(), &vfs) < 0) { Logger::warning("Failed to get disk/partition stats with statvfs() for: {}", mountpoint); continue; } disk.total = vfs.f_blocks * vfs.f_frsize; disk.free = vfs.f_bfree * vfs.f_frsize; disk.used = disk.total - disk.free; if (disk.total != 0) { disk.used_percent = round((double)disk.used * 100 / disk.total); disk.free_percent = 100 - disk.used_percent; } else { disk.used_percent = 0; disk.free_percent = 0; } } //? Setup disks order in UI and add swap if enabled mem.disks_order.clear(); if (snapped and disks.contains("/mnt")) mem.disks_order.push_back("/mnt"); else if (disks.contains("/")) mem.disks_order.push_back("/"); if (swap_disk and has_swap) { mem.disks_order.push_back("swap"); if (not disks.contains("swap")) disks["swap"] = {"", "swap"}; disks.at("swap").total = mem.stats.at("swap_total"); disks.at("swap").used = mem.stats.at("swap_used"); disks.at("swap").free = mem.stats.at("swap_free"); disks.at("swap").used_percent = mem.percent.at("swap_used").back(); disks.at("swap").free_percent = mem.percent.at("swap_free").back(); } for (const auto &name : last_found) if (not is_in(name, "/", "swap", "/dev")) mem.disks_order.push_back(name); disk_ios = 0; collect_disk(disks, mapping); old_uptime = uptime; } return mem; } } // namespace Mem namespace Net { std::unordered_map current_net; net_info empty_net = {}; vector interfaces; string selected_iface; int errors = 0; std::unordered_map graph_max = {{"download", {}}, {"upload", {}}}; std::unordered_map> max_count = {{"download", {}}, {"upload", {}}}; bool rescale = true; uint64_t timestamp = 0; auto collect(bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { //? Get interface list using getifaddrs() wrapper IfAddrsPtr if_addrs {}; if (if_addrs.get_status() != 0) { errors++; Logger::error("Net::collect() -> getifaddrs() failed with id {}", if_addrs.get_status()); redraw = true; return empty_net; } int family = 0; static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; //? Iteration over all items in getifaddrs() list for (auto *ifa = if_addrs.get(); ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr == nullptr) continue; family = ifa->ifa_addr->sa_family; const auto &iface = ifa->ifa_name; //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); // An interface can have more than one IP of the same family associated with it, // but we pick only the first one to show in the NET box. // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! net[iface].ipv4.clear(); net[iface].ipv6.clear(); } //? Get IPv4 address if (family == AF_INET) { if (net[iface].ipv4.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv4 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //? Get IPv6 address else if (family == AF_INET6) { if (net[iface].ipv6.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv6 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //else, ignoring family==AF_LINK (see man 3 getifaddrs) } std::unordered_map> ifstats; int mib[] = {CTL_NET, PF_ROUTE, 0, 0, NET_RT_IFLIST, 0}; size_t len; if (sysctl(mib, 6, nullptr, &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { std::unique_ptr buf(new char[len]); if (sysctl(mib, 6, buf.get(), &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { char *lim = buf.get() + len; char *next = nullptr; for (next = buf.get(); next < lim;) { struct if_msghdr *ifm = (struct if_msghdr *)next; next += ifm->ifm_msglen; struct if_data ifm_data = ifm->ifm_data; if (ifm->ifm_addrs & RTA_IFP) { struct sockaddr_dl *sdl = (struct sockaddr_dl *)(ifm + 1); char iface[32]; strncpy(iface, sdl->sdl_data, sdl->sdl_nlen); iface[sdl->sdl_nlen] = 0; ifstats[iface] = std::tuple(ifm_data.ifi_ibytes, ifm_data.ifi_obytes); } } } } //? Get total received and transmitted bytes + device address if no ip was found for (const auto &iface : interfaces) { for (const string dir : {"download", "upload"}) { auto &saved_stat = net.at(iface).stat.at(dir); auto &bandwidth = net.at(iface).bandwidth.at(dir); uint64_t val = dir == "download" ? std::get<0>(ifstats[iface]) : std::get<1>(ifstats[iface]); //? Update speed, total and top values if (val < saved_stat.last) { saved_stat.rollover += saved_stat.last; saved_stat.last = 0; } if (cmp_greater((unsigned long long)saved_stat.rollover + (unsigned long long)val, numeric_limits::max())) { saved_stat.rollover = 0; saved_stat.last = 0; } saved_stat.speed = round((double)(val - saved_stat.last) / ((double)(new_timestamp - timestamp) / 1000)); if (saved_stat.speed > saved_stat.top) saved_stat.top = saved_stat.speed; if (saved_stat.offset > val + saved_stat.rollover) saved_stat.offset = 0; saved_stat.total = (val + saved_stat.rollover) - saved_stat.offset; saved_stat.last = val; //? Add values to graph bandwidth.push_back(saved_stat.speed); while (cmp_greater(bandwidth.size(), width * 2)) bandwidth.pop_front(); //? Set counters for auto scaling if (net_auto and selected_iface == iface) { if (saved_stat.speed > graph_max[dir]) { ++max_count[dir][0]; if (max_count[dir][1] > 0) --max_count[dir][1]; } else if (graph_max[dir] > 10 << 10 and saved_stat.speed < graph_max[dir] / 10) { ++max_count[dir][1]; if (max_count[dir][0] > 0) --max_count[dir][0]; } } } } //? Clean up net map if needed if (net.size() > interfaces.size()) { for (auto it = net.begin(); it != net.end();) { if (not v_contains(interfaces, it->first)) it = net.erase(it); else it++; } } timestamp = new_timestamp; } //? Return empty net_info struct if no interfaces was found if (net.empty()) return empty_net; //? Find an interface to display if selected isn't set or valid if (selected_iface.empty() or not v_contains(interfaces, selected_iface)) { max_count["download"][0] = max_count["download"][1] = max_count["upload"][0] = max_count["upload"][1] = 0; redraw = true; if (net_auto) rescale = true; if (not config_iface.empty() and v_contains(interfaces, config_iface)) selected_iface = config_iface; else { //? Sort interfaces by total upload + download bytes auto sorted_interfaces = interfaces; rng::sort(sorted_interfaces, [&](const auto &a, const auto &b) { return cmp_greater(net.at(a).stat["download"].total + net.at(a).stat["upload"].total, net.at(b).stat["download"].total + net.at(b).stat["upload"].total); }); selected_iface.clear(); //? Try to set to a connected interface for (const auto &iface : sorted_interfaces) { if (net.at(iface).connected) selected_iface = iface; break; } //? If no interface is connected set to first available if (selected_iface.empty() and not sorted_interfaces.empty()) selected_iface = sorted_interfaces.at(0); else if (sorted_interfaces.empty()) return empty_net; } } //? Calculate max scale for graphs if needed if (net_auto) { bool sync = false; for (const auto &dir : {"download", "upload"}) { for (const auto &sel : {0, 1}) { if (rescale or max_count[dir][sel] >= 5) { const long long avg_speed = (net[selected_iface].bandwidth[dir].size() > 5 ? std::accumulate(net.at(selected_iface).bandwidth.at(dir).rbegin(), net.at(selected_iface).bandwidth.at(dir).rbegin() + 5, 0ll) / 5 : net[selected_iface].stat[dir].speed); graph_max[dir] = max(uint64_t(avg_speed * (sel == 0 ? 1.3 : 3.0)), (uint64_t)10 << 10); max_count[dir][0] = max_count[dir][1] = 0; redraw = true; if (net_sync) sync = true; break; } } //? Sync download/upload graphs if enabled if (sync) { const auto other = (string(dir) == "upload" ? "download" : "upload"); graph_max[other] = graph_max[dir]; max_count[other][0] = max_count[other][1] = 0; break; } } } rescale = false; return net.at(selected_iface); } } // namespace Net namespace Proc { vector current_procs; std::unordered_map uid_user; string current_sort; string current_filter; bool current_rev = false; bool is_tree_mode; fs::file_time_type passwd_time; uint64_t cputimes; int collapse = -1, expand = -1, toggle_children = -1, collapse_all = -1; uint64_t old_cputimes = 0; atomic numpids = 0; int filter_found = 0; detail_container detailed; static std::unordered_set dead_procs; string get_status(char s) { if (s & SRUN) return "Running"; if (s & SSLEEP) return "Sleeping"; if (s & SIDL) return "Idle"; if (s & SSTOP) return "Stopped"; if (s & SZOMB) return "Zombie"; return "Unknown"; } //* Get detailed info for selected process void _collect_details(const size_t pid, vector &procs) { if (pid != detailed.last_pid) { detailed = {}; detailed.last_pid = pid; detailed.skip_smaps = not Config::getB("proc_info_smaps"); } //? Copy proc_info for process from proc vector auto p_info = rng::find(procs, pid, &proc_info::pid); detailed.entry = *p_info; //? Update cpu percent deque for process cpu graph if (not Config::getB("proc_per_core")) detailed.entry.cpu_p *= Shared::coreCount; detailed.cpu_percent.push_back(clamp((long long)round(detailed.entry.cpu_p), 0ll, 100ll)); while (cmp_greater(detailed.cpu_percent.size(), width)) detailed.cpu_percent.pop_front(); //? Process runtime : current time - start time (both in unix time - seconds since epoch) struct timeval currentTime; gettimeofday(¤tTime, nullptr); // only interested in second granularity, so ignoring tc_usec if (detailed.entry.state != 'X') detailed.elapsed = sec_to_dhms(currentTime.tv_sec - detailed.entry.cpu_s); else detailed.elapsed = sec_to_dhms(detailed.entry.death_time); if (detailed.elapsed.size() > 8) detailed.elapsed.resize(detailed.elapsed.size() - 3); //? Get parent process name if (detailed.parent.empty()) { auto p_entry = rng::find(procs, detailed.entry.ppid, &proc_info::pid); if (p_entry != procs.end()) detailed.parent = p_entry->name; } //? Expand process status from single char to explanative string detailed.status = get_status(detailed.entry.state); detailed.mem_bytes.push_back(detailed.entry.mem); detailed.memory = floating_humanizer(detailed.entry.mem); if (detailed.first_mem == -1 or detailed.first_mem < detailed.mem_bytes.back() / 2 or detailed.first_mem > detailed.mem_bytes.back() * 4) { detailed.first_mem = min((uint64_t)detailed.mem_bytes.back() * 2, Mem::get_totalMem()); redraw = true; } while (cmp_greater(detailed.mem_bytes.size(), width)) detailed.mem_bytes.pop_front(); // rusage_info_current rusage; // if (proc_pid_rusage(pid, RUSAGE_INFO_CURRENT, (void **)&rusage) == 0) { // // this fails for processes we don't own - same as in Linux // detailed.io_read = floating_humanizer(rusage.ri_diskio_bytesread); // detailed.io_write = floating_humanizer(rusage.ri_diskio_byteswritten); // } } //* Collects and sorts process information from /proc auto collect(bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); auto per_core = Config::getB("proc_per_core"); auto tree = Config::getB("proc_tree"); auto show_detailed = Config::getB("show_detailed"); const auto pause_proc_list = Config::getB("pause_proc_list"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); bool tree_mode_change = tree != is_tree_mode; if (sorted_change) { current_sort = sorting; current_rev = reverse; } if (tree_mode_change) is_tree_mode = tree; const int cmult = (per_core) ? Shared::coreCount : 1; bool got_detailed = false; static vector found; vector> cpu_time(Shared::coreCount); size_t size = sizeof(long) * CPUSTATES * Shared::coreCount; if (sysctlbyname("kern.cp_times", &cpu_time[0], &size, nullptr, 0) == -1) { Logger::error("failed to get CPU times"); } cputimes = 0; for (const auto core : cpu_time) { for (const unsigned int c_state : {CP_USER, CP_NICE, CP_SYS, CP_IDLE}) { cputimes += core[c_state]; } } //* Use pids from last update if only changing filter, sorting or tree options if (no_update and not current_procs.empty()) { if (show_detailed and detailed_pid != detailed.last_pid) _collect_details(detailed_pid, current_procs); } else { //* ---------------------------------------------Collection start---------------------------------------------- should_filter = true; found.clear(); struct timeval currentTime; gettimeofday(¤tTime, nullptr); const double timeNow = currentTime.tv_sec + (currentTime.tv_usec / 1'000'000); int count = 0; char buf[_POSIX2_LINE_MAX]; Shared::KvmPtr kd {kvm_openfiles(nullptr, _PATH_DEVNULL, nullptr, O_RDONLY, buf)}; const struct kinfo_proc* kprocs = kvm_getprocs(kd.get(), KERN_PROC_PROC, 0, &count); for (int i = 0; i < count; i++) { const struct kinfo_proc* kproc = &kprocs[i]; const size_t pid = (size_t)kproc->ki_pid; if (pid < 1) continue; found.push_back(pid); //? Check if pid already exists in current_procs bool no_cache = false; auto find_old = rng::find(current_procs, pid, &proc_info::pid); //? Only add new processes if not paused if (find_old == current_procs.end()) { if (not pause_proc_list) { current_procs.push_back({pid}); find_old = current_procs.end() - 1; no_cache = true; } else continue; } else if (dead_procs.contains(pid)) continue; auto &new_proc = *find_old; //? Get program name, command, username, parent pid, nice and status if (no_cache) { if (string(kproc->ki_comm) == "idle"s) { current_procs.pop_back(); found.pop_back(); continue; } new_proc.name = kproc->ki_comm; char** argv = kvm_getargv(kd.get(), kproc, 0); if (argv) { for (int i = 0; argv[i] and cmp_less(new_proc.cmd.size(), 1000); i++) { new_proc.cmd += argv[i] + " "s; } if (not new_proc.cmd.empty()) new_proc.cmd.pop_back(); } if (new_proc.cmd.empty()) new_proc.cmd = new_proc.name; if (new_proc.cmd.size() > 1000) { new_proc.cmd.resize(1000); new_proc.cmd.shrink_to_fit(); } new_proc.ppid = kproc->ki_ppid; new_proc.cpu_s = round(kproc->ki_start.tv_sec); struct passwd *pwd = getpwuid(kproc->ki_uid); if (pwd) new_proc.user = pwd->pw_name; } new_proc.p_nice = kproc->ki_nice; new_proc.state = kproc->ki_stat; int cpu_t = 0; cpu_t = kproc->ki_rusage.ru_utime.tv_sec * 1'000'000 + kproc->ki_rusage.ru_utime.tv_usec + kproc->ki_rusage.ru_stime.tv_sec * 1'000'000 + kproc->ki_rusage.ru_stime.tv_usec; new_proc.mem = kproc->ki_rssize * Shared::pageSize; new_proc.threads = kproc->ki_numthreads; //? Process cpu usage since last update new_proc.cpu_p = clamp((100.0 * kproc->ki_pctcpu / Shared::kfscale) * cmult, 0.0, 100.0 * Shared::coreCount); //? Process cumulative cpu usage since process start new_proc.cpu_c = (double)(cpu_t * Shared::clkTck / 1'000'000) / max(1.0, timeNow - new_proc.cpu_s); //? Update cached value with latest cpu times new_proc.cpu_t = cpu_t; if (show_detailed and not got_detailed and new_proc.pid == detailed_pid) { got_detailed = true; } } //? Clear dead processes from current_procs if not paused if (not pause_proc_list) { auto eraser = rng::remove_if(current_procs, [&](const auto& element) { return not v_contains(found, element.pid); }); current_procs.erase(eraser.begin(), eraser.end()); if (!dead_procs.empty()) dead_procs.clear(); } //? Set correct state of dead processes if paused else { const bool keep_dead_proc_usage = Config::getB("keep_dead_proc_usage"); for (auto& r : current_procs) { if (rng::find(found, r.pid) == found.end()) { if (r.state != 'X') { struct timeval currentTime; gettimeofday(¤tTime, nullptr); r.death_time = currentTime.tv_sec - r.cpu_s; } r.state = 'X'; dead_procs.emplace(r.pid); //? Reset cpu usage for dead processes if paused and option is set if (!keep_dead_proc_usage) { r.cpu_p = 0.0; r.mem = 0; } } } } //? Update the details info box for process if active if (show_detailed and got_detailed) { _collect_details(detailed_pid, current_procs); } else if (show_detailed and not got_detailed and detailed.status != "Dead") { detailed.status = "Dead"; redraw = true; } old_cputimes = cputimes; } //* ---------------------------------------------Collection done----------------------------------------------- //* Match filter if defined if (should_filter) { filter_found = 0; for (auto& p : current_procs) { if (not tree and not filter.empty()) { if (!matches_filter(p, filter)) { p.filtered = true; filter_found++; } else { p.filtered = false; } } else { p.filtered = false; } } } //* Sort processes if ((sorted_change or tree_mode_change) or (not no_update and not pause_proc_list)) { proc_sorter(current_procs, sorting, reverse, tree); } //* Generate tree view if enabled if (tree and (not no_update or should_filter or sorted_change)) { bool locate_selection = false; if (toggle_children != -1) { auto collapser = rng::find(current_procs, toggle_children, &proc_info::pid); if (collapser != current_procs.end()){ for (auto& p : current_procs) { if (p.ppid == collapser->pid) { auto child = rng::find(current_procs, p.pid, &proc_info::pid); if (child != current_procs.end()){ child->collapsed = not child->collapsed; } } } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } toggle_children = -1; } if (auto find_pid = (collapse != -1 ? collapse : expand); find_pid != -1) { auto collapser = rng::find(current_procs, find_pid, &proc_info::pid); if (collapser != current_procs.end()) { if (collapse == expand) { collapser->collapsed = not collapser->collapsed; } else if (collapse > -1) { collapser->collapsed = true; } else if (expand > -1) { collapser->collapsed = false; } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } collapse = expand = -1; } if (collapse_all != -1) { toggle_tree_collapse(current_procs); collapse_all = -1; if (Config::ints.at("proc_selected") > 0) locate_selection = true; } if (should_filter or not filter.empty()) filter_found = 0; vector tree_procs; tree_procs.reserve(current_procs.size()); if (!pause_proc_list) { for (auto& p : current_procs) { if (not v_contains(found, p.ppid)) p.ppid = 0; } } //? Stable sort to retain selected sorting among processes with the same parent rng::stable_sort(current_procs, rng::less{}, & proc_info::ppid); //? Start recursive iteration over processes with the lowest shared parent pids for (auto& p : rng::equal_range(current_procs, current_procs.at(0).ppid, rng::less{}, &proc_info::ppid)) { _tree_gen(p, current_procs, tree_procs, 0, false, filter, false, no_update, should_filter); } //? Recursive sort over tree structure to account for collapsed processes in the tree int index = 0; tree_sort(tree_procs, sorting, reverse, (pause_proc_list and not (sorted_change or tree_mode_change)), index, current_procs.size()); //? Recursive construction of ASCII tree prefixes. for (auto t = tree_procs.begin(); t != tree_procs.end(); ++t) { _collect_prefixes(*t, t == tree_procs.end() - 1); } //? Final sort based on tree index rng::stable_sort(current_procs, rng::less {}, &proc_info::tree_index); //? Move current selection/view to the selected process when collapsing/expanding in the tree if (locate_selection) { int loc = rng::find(current_procs, Proc::selected_pid, &proc_info::pid)->tree_index; if (Config::ints.at("proc_start") >= loc or Config::ints.at("proc_start") <= loc - Proc::select_max) Config::ints.at("proc_start") = max(0, loc - 1); Config::ints.at("proc_selected") = loc - Config::ints.at("proc_start") + 1; } } numpids = (int)current_procs.size() - filter_found; return current_procs; } } // namespace Proc namespace Tools { double system_uptime() { struct timeval ts, currTime; std::size_t len = sizeof(ts); int mib[2] = {CTL_KERN, KERN_BOOTTIME}; if (sysctl(mib, 2, &ts, &len, nullptr, 0) != -1) { gettimeofday(&currTime, nullptr); return currTime.tv_sec - ts.tv_sec; } return 0.0; } } // namespace Tools aristocratos-btop-d43a485/src/linux/000077500000000000000000000000001517514752700174735ustar00rootroot00000000000000aristocratos-btop-d43a485/src/linux/btop_collect.cpp000066400000000000000000003577021517514752700226660ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // for inet_ntop() #include #include #include #include #include #include #include #include #if defined(RSMI_STATIC) #include #endif #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) #include #endif #include "../btop_config.hpp" #include "../btop_log.hpp" #include "../btop_shared.hpp" #include "../btop_tools.hpp" #if defined(GPU_SUPPORT) // Redefining C++ keywords fortunately has a warning in clang, however it's unavoidable here // since the C library uses "class" as a struct member and keywords are not allowed to be used // as identifiers in C++. #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wkeyword-macro" #endif // __clang__ #define class class_ extern "C" { #include "intel_gpu_top/intel_gpu_top.h" } #undef class #if defined(__clang__) #pragma clang diagnostic pop #endif // __clang__ #endif using std::abs; using std::clamp; using std::cmp_greater; using std::cmp_less; using std::ifstream; using std::max; using std::min; using std::numeric_limits; using std::round; using std::streamsize; using std::vector; using std::future; using std::async; using std::pair; namespace fs = std::filesystem; namespace rng = std::ranges; using namespace Tools; using namespace std::literals; // for operator""s using namespace std::chrono_literals; //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace { long long get_monotonicTimeUSec() { struct timespec time; clock_gettime(CLOCK_MONOTONIC, &time); return time.tv_sec * 1000000 + time.tv_nsec / 1000; } // Wrapper with join behavior of std::jthread to avoid -fexperimental-library // flag usage for Clang 19, ideally replace once flag is no longer needed. struct join_thread { std::thread t; join_thread() noexcept = default; template explicit join_thread(Args&&... args) : t(std::forward(args)...) {} ~join_thread() { if (t.joinable()) t.join(); } join_thread(join_thread&&) noexcept = default; join_thread& operator=(join_thread&& other) noexcept { if (t.joinable()) t.join(); t = std::move(other.t); return *this; } void join() { t.join(); } }; } namespace Cpu { vector core_old_totals; vector core_old_idles; vector core_freq; vector available_fields = {"Auto", "total"}; vector available_sensors = {"Auto"}; cpu_info current_cpu; bool got_sensors{}; bool cpu_temp_only{}; bool supports_watts = true; //* Populate found_sensors map bool get_sensors(); //* Get current cpu clock speed string get_cpuHz(); //* Search /proc/cpuinfo for a cpu name string get_cpuName(); struct Sensor { fs::path path; int64_t temp{}; int64_t crit{}; }; std::unordered_map found_sensors; string cpu_sensor; vector core_sensors; std::unordered_map core_mapping; } #if defined(GPU_SUPPORT) namespace Gpu { vector gpus; //? NVIDIA data collection namespace Nvml { //? NVML defines, structs & typedefs #define NVML_DEVICE_NAME_BUFFER_SIZE 64 #define NVML_SUCCESS 0 #define NVML_TEMPERATURE_THRESHOLD_SHUTDOWN 0 #define NVML_CLOCK_GRAPHICS 0 #define NVML_CLOCK_MEM 2 #define NVML_TEMPERATURE_GPU 0 #define NVML_PCIE_UTIL_TX_BYTES 0 #define NVML_PCIE_UTIL_RX_BYTES 1 typedef void* nvmlDevice_t; // we won't be accessing any of the underlying struct's properties, so this is fine typedef int nvmlReturn_t, // enums are basically ints nvmlTemperatureThresholds_t, nvmlClockType_t, nvmlPstates_t, nvmlTemperatureSensors_t, nvmlPcieUtilCounter_t; struct nvmlUtilization_t {unsigned int gpu, memory;}; struct nvmlMemory_t {unsigned long long total, free, used;}; //? Function pointers const char* (*nvmlErrorString)(nvmlReturn_t); nvmlReturn_t (*nvmlInit)(); nvmlReturn_t (*nvmlShutdown)(); nvmlReturn_t (*nvmlDeviceGetCount)(unsigned int*); nvmlReturn_t (*nvmlDeviceGetHandleByIndex)(unsigned int, nvmlDevice_t*); nvmlReturn_t (*nvmlDeviceGetName)(nvmlDevice_t, char*, unsigned int); nvmlReturn_t (*nvmlDeviceGetPowerManagementLimit)(nvmlDevice_t, unsigned int*); nvmlReturn_t (*nvmlDeviceGetTemperatureThreshold)(nvmlDevice_t, nvmlTemperatureThresholds_t, unsigned int*); nvmlReturn_t (*nvmlDeviceGetUtilizationRates)(nvmlDevice_t, nvmlUtilization_t*); nvmlReturn_t (*nvmlDeviceGetClockInfo)(nvmlDevice_t, nvmlClockType_t, unsigned int*); nvmlReturn_t (*nvmlDeviceGetPowerUsage)(nvmlDevice_t, unsigned int*); nvmlReturn_t (*nvmlDeviceGetPowerState)(nvmlDevice_t, nvmlPstates_t*); nvmlReturn_t (*nvmlDeviceGetTemperature)(nvmlDevice_t, nvmlTemperatureSensors_t, unsigned int*); nvmlReturn_t (*nvmlDeviceGetMemoryInfo)(nvmlDevice_t, nvmlMemory_t*); nvmlReturn_t (*nvmlDeviceGetPcieThroughput)(nvmlDevice_t, nvmlPcieUtilCounter_t, unsigned int*); nvmlReturn_t (*nvmlDeviceGetEncoderUtilization)(nvmlDevice_t, unsigned int*, unsigned int*); nvmlReturn_t (*nvmlDeviceGetDecoderUtilization)(nvmlDevice_t, unsigned int*, unsigned int*); //? Data void* nvml_dl_handle; bool initialized = false; bool init(); bool shutdown(); template bool collect(gpu_info* gpus_slice); vector devices; unsigned int device_count = 0; } //? AMD data collection namespace Rsmi { //? RSMI defines, structs & typedefs #define RSMI_DEVICE_NAME_BUFFER_SIZE 128 #if !defined(RSMI_STATIC) #define RSMI_MAX_NUM_FREQUENCIES_V5 32 #define RSMI_MAX_NUM_FREQUENCIES_V6 33 #define RSMI_STATUS_SUCCESS 0 #define RSMI_MEM_TYPE_VRAM 0 #define RSMI_TEMP_CURRENT 0 #define RSMI_TEMP_TYPE_EDGE 0 #define RSMI_CLK_TYPE_MEM 4 #define RSMI_CLK_TYPE_SYS 0 #define RSMI_TEMP_MAX 1 typedef int rsmi_status_t, rsmi_temperature_metric_t, rsmi_clk_type_t, rsmi_memory_type_t; struct rsmi_version_t {uint32_t major, minor, patch; const char* build;}; struct rsmi_frequencies_t_v5 {uint32_t num_supported, current; uint64_t frequency[RSMI_MAX_NUM_FREQUENCIES_V5];}; struct rsmi_frequencies_t_v6 {bool has_deep_sleep; uint32_t num_supported, current; uint64_t frequency[RSMI_MAX_NUM_FREQUENCIES_V6];}; //? Function pointers rsmi_status_t (*rsmi_init)(uint64_t); rsmi_status_t (*rsmi_shut_down)(); rsmi_status_t (*rsmi_version_get)(rsmi_version_t*); rsmi_status_t (*rsmi_num_monitor_devices)(uint32_t*); rsmi_status_t (*rsmi_dev_name_get)(uint32_t, char*, size_t); rsmi_status_t (*rsmi_dev_power_cap_get)(uint32_t, uint32_t, uint64_t*); rsmi_status_t (*rsmi_dev_temp_metric_get)(uint32_t, uint32_t, rsmi_temperature_metric_t, int64_t*); rsmi_status_t (*rsmi_dev_busy_percent_get)(uint32_t, uint32_t*); rsmi_status_t (*rsmi_dev_memory_busy_percent_get)(uint32_t, uint32_t*); rsmi_status_t (*rsmi_dev_gpu_clk_freq_get_v5)(uint32_t, rsmi_clk_type_t, rsmi_frequencies_t_v5*); rsmi_status_t (*rsmi_dev_gpu_clk_freq_get_v6)(uint32_t, rsmi_clk_type_t, rsmi_frequencies_t_v6*); rsmi_status_t (*rsmi_dev_power_ave_get)(uint32_t, uint32_t, uint64_t*); rsmi_status_t (*rsmi_dev_memory_total_get)(uint32_t, rsmi_memory_type_t, uint64_t*); rsmi_status_t (*rsmi_dev_memory_usage_get)(uint32_t, rsmi_memory_type_t, uint64_t*); rsmi_status_t (*rsmi_dev_pci_throughput_get)(uint32_t, uint64_t*, uint64_t*, uint64_t*); uint32_t version_major = 0; //? Data void* rsmi_dl_handle; #endif bool initialized = false; bool init(); bool shutdown(); template bool collect(gpu_info* gpus_slice); uint32_t device_count = 0; } //? Intel data collection namespace Intel { const char* device = "i915"; struct engines *engines = nullptr; bool initialized = false; bool init(); bool shutdown(); template bool collect(gpu_info* gpus_slice); uint32_t device_count = 0; } } #endif // GPU_SUPPORT namespace Mem { double old_uptime; } namespace Shared { fs::path procPath, passwd_path; long pageSize, clkTck, coreCount; void init() { //? Shared global variables init procPath = (fs::is_directory(fs::path("/proc")) and access("/proc", R_OK) != -1) ? "/proc" : ""; if (procPath.empty()) throw std::runtime_error("Proc filesystem not found or no permission to read from it!"); passwd_path = (fs::is_regular_file(fs::path("/etc/passwd")) and access("/etc/passwd", R_OK) != -1) ? "/etc/passwd" : ""; if (passwd_path.empty()) Logger::warning("Could not read /etc/passwd, will show UID instead of username."); coreCount = sysconf(_SC_NPROCESSORS_ONLN); if (coreCount < 1) { coreCount = sysconf(_SC_NPROCESSORS_CONF); if (coreCount < 1) { coreCount = 1; Logger::warning("Could not determine number of cores, defaulting to 1."); } } pageSize = sysconf(_SC_PAGE_SIZE); if (pageSize <= 0) { pageSize = 4096; Logger::warning("Could not get system page size. Defaulting to 4096, processes memory usage might be incorrect."); } clkTck = sysconf(_SC_CLK_TCK); if (clkTck <= 0) { clkTck = 100; Logger::warning("Could not get system clock ticks per second. Defaulting to 100, processes cpu usage might be incorrect."); } //? Init for namespace Cpu Cpu::current_cpu.core_percent.insert(Cpu::current_cpu.core_percent.begin(), Shared::coreCount, {}); Cpu::current_cpu.temp.insert(Cpu::current_cpu.temp.begin(), Shared::coreCount + 1, {}); Cpu::core_old_totals.insert(Cpu::core_old_totals.begin(), Shared::coreCount, 0); Cpu::core_old_idles.insert(Cpu::core_old_idles.begin(), Shared::coreCount, 0); for (int i = 0; i < Shared::coreCount; ++i) { Cpu::core_freq.push_back("/sys/devices/system/cpu/cpufreq/policy" + to_string(i) + "/scaling_cur_freq"); if (not fs::exists(Cpu::core_freq.back()) or access(Cpu::core_freq.back().c_str(), R_OK) == -1) { Cpu::core_freq.pop_back(); } } Cpu::collect(); if (Runner::coreNum_reset) Runner::coreNum_reset = false; for (auto& [field, vec] : Cpu::current_cpu.cpu_percent) { if (not vec.empty() and not v_contains(Cpu::available_fields, field)) Cpu::available_fields.push_back(field); } Cpu::cpuName = Cpu::get_cpuName(); Cpu::got_sensors = Cpu::get_sensors(); for (const auto& [sensor, ignored] : Cpu::found_sensors) { Cpu::available_sensors.push_back(sensor); } Cpu::core_mapping = Cpu::get_core_mapping(); Cpu::container_engine = detect_container(); //? Init for namespace Gpu #ifdef GPU_SUPPORT auto shown_gpus = Config::getS("shown_gpus"); if (shown_gpus.contains("nvidia")) { Gpu::Nvml::init(); } if (shown_gpus.contains("amd")) { Gpu::Rsmi::init(); } if (shown_gpus.contains("intel")) { Gpu::Intel::init(); } if (not Gpu::gpu_names.empty()) { for (auto const& [key, _] : Gpu::gpus[0].gpu_percent) Cpu::available_fields.push_back(key); for (auto const& [key, _] : Gpu::shared_gpu_percent) Cpu::available_fields.push_back(key); using namespace Gpu; count = gpus.size(); gpu_b_height_offsets.resize(gpus.size()); for (size_t i = 0; i < gpu_b_height_offsets.size(); ++i) gpu_b_height_offsets[i] = gpus[i].supported_functions.gpu_utilization + gpus[i].supported_functions.pwr_usage + (gpus[i].supported_functions.encoder_utilization or gpus[i].supported_functions.decoder_utilization) + (gpus[i].supported_functions.mem_total or gpus[i].supported_functions.mem_used) * (1 + 2*(gpus[i].supported_functions.mem_total and gpus[i].supported_functions.mem_used) + 2*gpus[i].supported_functions.mem_utilization); } #endif //? Init for namespace Mem Mem::old_uptime = system_uptime(); Mem::collect(); Logger::debug("Shared::init() : Initialized."); } } namespace Cpu { string cpuName; string cpuHz; bool has_battery = true; tuple current_bat; const array time_names { "user"s, "nice"s, "system"s, "idle"s, "iowait"s, "irq"s, "softirq"s, "steal"s, "guest"s, "guest_nice"s }; std::unordered_map cpu_old = { {"totals", 0}, {"idles", 0}, {"user", 0}, {"nice", 0}, {"system", 0}, {"idle", 0}, {"iowait", 0}, {"irq", 0}, {"softirq", 0}, {"steal", 0}, {"guest", 0}, {"guest_nice", 0} }; string get_cpuName() { string name; ifstream cpuinfo(Shared::procPath / "cpuinfo"); if (cpuinfo.good()) { for (string instr; getline(cpuinfo, instr, ':') and not instr.starts_with("model name");) cpuinfo.ignore(SSmax, '\n'); if (cpuinfo.bad()) return name; else if (not cpuinfo.eof()) { cpuinfo.ignore(1); getline(cpuinfo, name); } else if (fs::exists("/sys/devices")) { for (const auto& d : fs::directory_iterator("/sys/devices")) { if (string(d.path().filename()).starts_with("arm")) { name = d.path().filename(); break; } } if (not name.empty()) { auto name_vec = ssplit(name, '_'); if (name_vec.size() < 2) return capitalize(name); else return capitalize(name_vec.at(1)) + (name_vec.size() > 2 ? ' ' + capitalize(name_vec.at(2)) : ""); } } name = trim_name(name); } return name; } bool get_sensors() { bool got_cpu = false, got_coretemp = false; vector search_paths; try { //? Setup up paths to search for sensors if (fs::exists(fs::path("/sys/class/hwmon")) and access("/sys/class/hwmon", R_OK) != -1) { for (const auto& dir : fs::directory_iterator(fs::path("/sys/class/hwmon"))) { fs::path add_path = fs::canonical(dir.path()); if (v_contains(search_paths, add_path) or v_contains(search_paths, add_path / "device")) continue; if (std::string_view { add_path.c_str() }.contains("coretemp")) got_coretemp = true; for (const auto & file : fs::directory_iterator(add_path)) { if (file.path().filename() == "device") { for (const auto & dev_file : fs::directory_iterator(file.path())) { string dev_filename = dev_file.path().filename(); if (dev_filename.starts_with("temp") and dev_filename.ends_with("_input")) { search_paths.push_back(file.path()); break; } } } string filename = file.path().filename(); if (filename.starts_with("temp") and filename.ends_with("_input")) { search_paths.push_back(add_path); break; } } } } if (not got_coretemp and fs::exists(fs::path("/sys/devices/platform/coretemp.0/hwmon"))) { for (auto& d : fs::directory_iterator(fs::path("/sys/devices/platform/coretemp.0/hwmon"))) { fs::path add_path = fs::canonical(d.path()); for (const auto & file : fs::directory_iterator(add_path)) { string filename = file.path().filename(); if (filename.starts_with("temp") and filename.ends_with("_input") and not v_contains(search_paths, add_path)) { search_paths.push_back(add_path); got_coretemp = true; break; } } } } //? Scan any found directories for temperature sensors if (not search_paths.empty()) { for (const auto& path : search_paths) { const string pname = readfile(path / "name", path.filename()); for (const auto & file : fs::directory_iterator(path)) { const string file_suffix = "input"; const int file_id = atoi(file.path().filename().c_str() + 4); // skip "temp" prefix string file_path = file.path(); if (!file_path.contains(file_suffix) or file_path.contains("nvme")) { continue; } const string basepath = file_path.erase(file_path.find(file_suffix), file_suffix.length()); const string label = readfile(fs::path(basepath + "label"), "temp" + to_string(file_id)); const string sensor_name = pname + "/" + label; const int64_t temp = stol(readfile(fs::path(basepath + "input"), "0")) / 1000; const int64_t crit = stol(readfile(fs::path(basepath + "crit"), "95000")) / 1000; found_sensors[sensor_name] = Sensor { fs::path(basepath + "input"), temp, crit }; if (not got_cpu and (label.starts_with("Package id") or label.starts_with("Tdie") or label.starts_with("SoC Temperature"))) { got_cpu = true; cpu_sensor = sensor_name; } else if (label.starts_with("Core") or label.starts_with("Tccd")) { got_coretemp = true; if (not v_contains(core_sensors, sensor_name)) core_sensors.push_back(sensor_name); } } } } //? If no good candidate for cpu temp has been found scan /sys/class/thermal if (not got_cpu and fs::exists(fs::path("/sys/class/thermal"))) { const string rootpath = fs::path("/sys/class/thermal/thermal_zone"); for (int i = 0; fs::exists(fs::path(rootpath + to_string(i))); i++) { const fs::path basepath = rootpath + to_string(i); if (not fs::exists(basepath / "temp")) continue; const string label = readfile(basepath / "type", "temp" + to_string(i)); const string sensor_name = "thermal" + to_string(i) + "/" + label; const int64_t temp = stol(readfile(basepath / "temp", "0")) / 1000; int64_t high = 0; int64_t crit = 0; for (int ii = 0; fs::exists(basepath / fmt::format("trip_point_{}_temp", ii)); ii++) { const string trip_type = readfile(basepath / fmt::format("trip_point_{}_type", ii)); if (not is_in(trip_type, "high", "critical")) continue; auto& val = (trip_type == "high" ? high : crit); val = stol(readfile(basepath / fmt::format("trip_point_{}_temp", ii), "0")) / 1000; } if (high < 1) high = 80; if (crit < 1) crit = 95; found_sensors[sensor_name] = Sensor { basepath / "temp", temp, crit }; } } } catch (...) {} if (not got_coretemp or core_sensors.empty()) { cpu_temp_only = true; } else { rng::sort(core_sensors, rng::less{}); rng::stable_sort(core_sensors, [](const auto& a, const auto& b){ return a.size() < b.size(); }); } if (cpu_sensor.empty() and not found_sensors.empty()) { for (const auto& [name, sensor] : found_sensors) { if (str_to_lower(name).contains("cpu") or str_to_lower(name).contains("k10temp")) { cpu_sensor = name; break; } } if (cpu_sensor.empty()) { cpu_sensor = found_sensors.begin()->first; Logger::warning("No good candidate for cpu sensor found, using random from all found sensors."); } } return not found_sensors.empty(); } static void update_sensors() { if (cpu_sensor.empty()) return; const auto& cpu_sensor = (not Config::getS("cpu_sensor").empty() and found_sensors.contains(Config::getS("cpu_sensor")) ? Config::getS("cpu_sensor") : Cpu::cpu_sensor); found_sensors.at(cpu_sensor).temp = stol(readfile(found_sensors.at(cpu_sensor).path, "0")) / 1000; current_cpu.temp.at(0).push_back(found_sensors.at(cpu_sensor).temp); current_cpu.temp_max = found_sensors.at(cpu_sensor).crit; if (current_cpu.temp.at(0).size() > 20) current_cpu.temp.at(0).pop_front(); if (Config::getB("show_coretemp") and not cpu_temp_only) { for (vector done; const auto& sensor : core_sensors) { if (v_contains(done, sensor)) continue; found_sensors.at(sensor).temp = stol(readfile(found_sensors.at(sensor).path, "0")) / 1000; done.push_back(sensor); } for (const auto& [core, temp] : core_mapping) { if (cmp_less(core + 1, current_cpu.temp.size()) and cmp_less(temp, core_sensors.size())) { current_cpu.temp.at(core + 1).push_back(found_sensors.at(core_sensors.at(temp)).temp); if (current_cpu.temp.at(core + 1).size() > 20) current_cpu.temp.at(core + 1).pop_front(); } } } } static string normalize_frequency(double hz) { string str; if (hz > 999999) { str = fmt::format("{:.1f}", hz / 1'000'000); str.resize(3); if (str.back() == '.') str.pop_back(); str += " THz"; } else if (hz > 999) { str = fmt::format("{:.1f}", hz / 1'000); str.resize(3); if (str.back() == '.') str.pop_back(); str += " GHz"; } else { str = fmt::format("{:.0f} MHz", hz); } return str; } string get_cpuHz() { static int failed{}; if (failed > 4) return ""s; string cpuhz; const auto &freq_mode = Config::getS("freq_mode"); try { double hz = 0.0; // Read frequencies from all CPU cores vector frequencies; for (auto it = Cpu::core_freq.begin(); it != Cpu::core_freq.end(); ) { if (it->empty()) { it = Cpu::core_freq.erase(it); continue; } double core_hz = stod(readfile(*it, "0.0")) / 1000; if (core_hz <= 0.0 and ++failed >= 2) { it = Cpu::core_freq.erase(it); } else { frequencies.push_back(core_hz); if (freq_mode == "first") break; ++it; } } if (not frequencies.empty()) { if (freq_mode == "first") { hz = frequencies.front(); } if (freq_mode == "average") { hz = std::accumulate(frequencies.begin(), frequencies.end(), 0.0) / static_cast(frequencies.size()); } else if (freq_mode == "highest") { hz = *std::max_element(frequencies.begin(), frequencies.end()); } else if (freq_mode == "lowest") { hz = *std::min_element(frequencies.begin(), frequencies.end()); } else if (freq_mode == "range") { auto [min_hz,max_hz] = std::minmax_element(frequencies.begin(), frequencies.end()); // Format as range string min_str, max_str; min_str = normalize_frequency(*min_hz); max_str = normalize_frequency(*max_hz); return min_str + " - " + max_str; } } //? If freq from /sys failed or is missing try to use /proc/cpuinfo if (hz <= 0.0) { ifstream cpufreq(Shared::procPath / "cpuinfo"); if (cpufreq.good()) { while (cpufreq.ignore(SSmax, '\n')) { // peek is caps sensitive so it was skipping 'CPU MHz'. This aims to fix it. if (cpufreq.peek() == 'c' || cpufreq.peek() == 'C') { cpufreq.ignore(SSmax, ' '); if (cpufreq.peek() == 'M') { cpufreq.ignore(SSmax, ':'); cpufreq.ignore(1); cpufreq >> hz; break; } } } } } if (hz <= 1 or hz >= 999999999) throw std::runtime_error("Failed to read /sys/devices/system/cpu/cpufreq/policy and /proc/cpuinfo."); cpuhz = normalize_frequency(hz); } catch (const std::exception& e) { if (++failed < 5) return ""s; else { Logger::warning("get_cpuHZ() : {}", e.what()); return ""s; } } return cpuhz; } auto get_core_mapping() -> std::unordered_map { std::unordered_map core_map; if (cpu_temp_only) return core_map; const int num_sensors = core_sensors.size(); //? Try to get core mapping from /proc/cpuinfo ifstream cpuinfo(Shared::procPath / "cpuinfo"); if (cpuinfo.good()) { int cpu{}; int core{}; int max_core{}; std::unordered_map cpu_to_core; for (string instr; cpuinfo >> instr;) { if (instr == "processor") { cpuinfo.ignore(SSmax, ':'); cpuinfo >> cpu; } else if (instr.starts_with("core")) { cpuinfo.ignore(SSmax, ':'); cpuinfo >> core; cpu_to_core[cpu] = core; max_core = std::max(max_core, core); } cpuinfo.ignore(SSmax, '\n'); } if (not cpu_to_core.empty()) //? Divide core ID space evenly across sensors (handles AMD multi-CCD, e.g. 5950x: IDs 0-7 -> Tccd1, 8-15 -> Tccd2) for (const auto& [cpu_id, core_id] : cpu_to_core) { core_map[cpu_id] = core_id * num_sensors / (max_core + 1); } } //? If core mapping from cpuinfo was incomplete try to guess remainder, if missing completely, map 0-0 1-1 2-2 etc. if (cmp_less(core_map.size(), Shared::coreCount)) { if (Shared::coreCount % 2 == 0 and (long)core_map.size() == Shared::coreCount / 2) { //? SMT siblings mirror their first half of cores. for (int i = 0; i < Shared::coreCount / 2; i++) { core_map[Shared::coreCount / 2 + i] = core_map.count(i) ? core_map.at(i) : (i % num_sensors); } } else { core_map.clear(); for (int i = 0; i < Shared::coreCount; i++) { core_map[i] = (i * num_sensors) / Shared::coreCount; } } } //? Apply user set custom mapping if any const auto& custom_map = Config::getS("cpu_core_map"); if (not custom_map.empty()) { try { for (const auto& split : ssplit(custom_map)) { const auto vals = ssplit(split, ':'); if (vals.size() != 2) continue; int change_id = std::stoi(vals.at(0)); int new_id = std::stoi(vals.at(1)); if (not core_map.contains(change_id) or cmp_greater(new_id, num_sensors)) continue; core_map.at(change_id) = new_id; } } catch (...) {} } return core_map; } struct battery { fs::path base_dir, energy_now, charge_now, energy_full, charge_full, power_now, current_now, voltage_now, status, online; string device_type; bool use_energy_or_charge = true; bool use_power = true; }; auto get_battery() -> tuple { if (not has_battery) return {0, 0, 0, ""}; static string auto_sel; static std::unordered_map batteries; //? Get paths to needed files and check for valid values on first run if (batteries.empty() and has_battery) { try { if (fs::exists("/sys/class/power_supply")) { for (const auto& d : fs::directory_iterator("/sys/class/power_supply")) { //? Only consider online power supplies of type Battery or UPS //? see kernel docs for details on the file structure and contents //? https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-class-power battery new_bat; fs::path bat_dir; try { if (not d.is_directory() or not fs::exists(d.path() / "type") or not fs::exists(d.path() / "present") or stoi(readfile(d.path() / "present")) != 1) continue; string dev_type = readfile(d.path() / "type"); if (is_in(dev_type, "Battery", "UPS")) { bat_dir = d.path(); new_bat.base_dir = d.path(); new_bat.device_type = dev_type; } } catch (...) { //? skip power supplies not conforming to the kernel standard continue; } if (fs::exists(bat_dir / "energy_now")) new_bat.energy_now = bat_dir / "energy_now"; else if (fs::exists(bat_dir / "charge_now")) new_bat.charge_now = bat_dir / "charge_now"; else new_bat.use_energy_or_charge = false; if (fs::exists(bat_dir / "energy_full")) new_bat.energy_full = bat_dir / "energy_full"; else if (fs::exists(bat_dir / "charge_full")) new_bat.charge_full = bat_dir / "charge_full"; else new_bat.use_energy_or_charge = false; if (not new_bat.use_energy_or_charge and not fs::exists(bat_dir / "capacity")) { continue; } if (fs::exists(bat_dir / "power_now")) { new_bat.power_now = bat_dir / "power_now"; } else if ((fs::exists(bat_dir / "current_now")) and (fs::exists(bat_dir / "voltage_now"))) { new_bat.current_now = bat_dir / "current_now"; new_bat.voltage_now = bat_dir / "voltage_now"; } else { new_bat.use_power = false; } if (fs::exists(bat_dir / "AC0/online")) new_bat.online = bat_dir / "AC0/online"; else if (fs::exists(bat_dir / "AC/online")) new_bat.online = bat_dir / "AC/online"; batteries[bat_dir.filename()] = new_bat; Config::available_batteries.push_back(bat_dir.filename()); } } } catch (...) { batteries.clear(); } if (batteries.empty()) { has_battery = false; return {0, 0, 0, ""}; } } auto& battery_sel = Config::getS("selected_battery"); if (auto_sel.empty()) { for (auto& [name, bat] : batteries) { if (bat.device_type == "Battery") { auto_sel = name; break; } } if (auto_sel.empty()) auto_sel = batteries.begin()->first; } auto& b = (battery_sel != "Auto" and batteries.contains(battery_sel) ? batteries.at(battery_sel) : batteries.at(auto_sel)); int percent = -1; long seconds = -1; float watts = -1; //? Try to get battery percentage if (percent < 0) { try { percent = stoi(readfile(b.base_dir / "capacity", "-1")); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } if (b.use_energy_or_charge and percent < 0) { try { percent = round(100.0 * stod(readfile(b.energy_now, "-1")) / stod(readfile(b.energy_full, "1"))); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } if (b.use_energy_or_charge and percent < 0) { try { percent = round(100.0 * stod(readfile(b.charge_now, "-1")) / stod(readfile(b.charge_full, "1"))); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } if (percent < 0) { has_battery = false; return {0, 0, 0, ""}; } //? Get charging/discharging status string status = str_to_lower(readfile(b.base_dir / "status", "unknown")); if (status == "unknown" and not b.online.empty()) { const auto online = readfile(b.online, "0"); if (online == "1" and percent < 100) status = "charging"; else if (online == "1") status = "full"; else status = "discharging"; } //? Get seconds to empty if (not is_in(status, "charging", "full")) { if (b.use_energy_or_charge ) { if (not b.power_now.empty()) { try { seconds = abs(round(stod(readfile(b.energy_now, "0")) / stod(readfile(b.power_now, "1")) * 3600)); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } else if (not b.current_now.empty()) { try { seconds = abs(round(stod(readfile(b.charge_now, "0")) / stod(readfile(b.current_now, "1")) * 3600)); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } } if (seconds < 0 and fs::exists(b.base_dir / "time_to_empty")) { try { seconds = stoll(readfile(b.base_dir / "time_to_empty", "0")) * 60; } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } } //? Or get seconds to full else if(is_in(status, "charging")) { if (b.use_energy_or_charge ) { if (not b.power_now.empty()) { try { seconds = (round(stod(readfile(b.energy_full , "0")) - round(stod(readfile(b.energy_now, "0")))) / abs(stod(readfile(b.power_now, "1"))) * 3600); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } else if (not b.current_now.empty()) { try { seconds = (round(stod(readfile(b.charge_full , "0")) - stod(readfile(b.charge_now, "0"))) / std::abs(stod(readfile(b.current_now, "1"))) * 3600); } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } } } //? Get power draw if (b.use_power) { if (not b.power_now.empty()) { try { watts = stof(readfile(b.power_now, "-1")) / 1000000.0F; } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } else if (not b.voltage_now.empty() and not b.current_now.empty()) { try { watts = stof(readfile(b.current_now, "-1")) / 1000000.0F * stof(readfile(b.voltage_now, "1")) / 1000000.0F; } catch (const std::invalid_argument&) { } catch (const std::out_of_range&) { } } } return {percent, watts, seconds, status}; } long long get_cpuConsumptionUJoules() { long long consumption = -1; const auto rapl_power_usage_path = "/sys/class/powercap/intel-rapl:0/energy_uj"; std::ifstream file(rapl_power_usage_path); if(file.good()) { file >> consumption; } return consumption; } float get_cpuConsumptionWatts() { static long long previous_usage = 0; static long long previous_timestamp = 0; if (previous_usage == 0) { previous_usage = get_cpuConsumptionUJoules(); previous_timestamp = get_monotonicTimeUSec(); supports_watts = (previous_usage > 0); return 0; } if (!supports_watts) { return -1; } auto current_timestamp = get_monotonicTimeUSec(); auto current_usage = get_cpuConsumptionUJoules(); auto watts = (float)(current_usage - previous_usage) / (float)(current_timestamp - previous_timestamp); previous_timestamp = current_timestamp; previous_usage = current_usage; return watts; } static constexpr auto to_int(std::string_view view) { std::uint32_t value {}; std::from_chars(view.data(), view.data() + view.size(), value); return value; } static constexpr auto detect_active_cpus() { auto stream = std::ifstream { "/sys/fs/cgroup/cpuset.cpus.effective" }; auto buf = std::string { std::istreambuf_iterator { stream }, {} }; if (buf.empty()) { return std::views::iota(0, Shared::coreCount) | std::ranges::to>(); } return buf | std::views::split(',') | std::views::transform([](auto&& range) -> auto { auto view = std::string_view { range }; auto dash = view.find('-'); if (dash == std::string_view::npos) { // Single CPU, return iota of single element auto value = to_int(view); return std::views::iota(value, value + 1); } auto start = to_int(view.substr(0, dash)); auto end = to_int(view.substr(dash + 1)); return std::views::iota(start, end + 1); }) | std::views::join | std::ranges::to>(); } auto collect(bool no_update) -> cpu_info& { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto& cpu = current_cpu; if (Config::getB("show_cpu_freq")) cpuHz = get_cpuHz(); if (getloadavg(cpu.load_avg.data(), cpu.load_avg.size()) < 0) { Logger::error("failed to get load averages"); } ifstream cread; try { //? Get cpu total times for all cores from /proc/stat string cpu_name; cread.open(Shared::procPath / "stat"); int i = 0; int target = Shared::coreCount; for (; i <= target or (cread.good() and cread.peek() == 'c'); i++) { //? Make sure to add zero value for missing core values if at end of file if ((not cread.good() or cread.peek() != 'c') and i <= target) { if (i == 0) throw std::runtime_error("Failed to parse /proc/stat"); else { //? Fix container sizes if new cores are detected while (cmp_less(cpu.core_percent.size(), i)) { core_old_totals.push_back(0); core_old_idles.push_back(0); cpu.core_percent.emplace_back(); } cpu.core_percent.at(i-1).push_back(0); } } else { if (i == 0) cread.ignore(SSmax, ' '); else { cread >> cpu_name; int cpuNum = std::stoi(cpu_name.substr(3)); if (cpuNum >= target - 1) target = cpuNum + (cread.peek() == 'c' ? 2 : 1); //? Add zero value for core if core number is missing from /proc/stat while (i - 1 < cpuNum) { //? Fix container sizes if new cores are detected while (cmp_less(cpu.core_percent.size(), i)) { core_old_totals.push_back(0); core_old_idles.push_back(0); cpu.core_percent.emplace_back(); } cpu.core_percent[i-1].push_back(0); if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); i++; } } //? Expected on kernel 2.6.3> : 0=user, 1=nice, 2=system, 3=idle, 4=iowait, 5=irq, 6=softirq, 7=steal, 8=guest, 9=guest_nice vector times; long long total_sum = 0; for (uint64_t val; cread >> val; total_sum += val) { times.push_back(val); } cread.clear(); if (times.size() < 4) throw std::runtime_error("Malformed /proc/stat"); //? Subtract fields 8-9 and any future unknown fields const long long totals = max(0ll, total_sum - (times.size() > 8 ? std::accumulate(times.begin() + 8, times.end(), 0ll) : 0)); //? Add iowait field if present const long long idles = max(0ll, times.at(3) + (times.size() > 4 ? times.at(4) : 0)); //? Calculate values for totals from first line of stat if (i == 0) { const long long calc_totals = max(1ll, totals - cpu_old.at("totals")); const long long calc_idles = max(0ll, idles - cpu_old.at("idles")); cpu_old.at("totals") = totals; cpu_old.at("idles") = idles; //? Total usage of cpu cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); //? Populate cpu.cpu_percent with all fields from stat for (int ii = 0; const auto& val : times) { cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); cpu_old.at(time_names.at(ii)) = val; //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); if (++ii == 10) break; } continue; } //? Calculate cpu total for each core else { //? Fix container sizes if new cores are detected while (cmp_less(cpu.core_percent.size(), i)) { core_old_totals.push_back(0); core_old_idles.push_back(0); cpu.core_percent.emplace_back(); } const long long calc_totals = max(1ll, totals - core_old_totals.at(i-1)); const long long calc_idles = max(0ll, idles - core_old_idles.at(i-1)); core_old_totals.at(i-1) = totals; core_old_idles.at(i-1) = idles; cpu.core_percent.at(i-1).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); } } //? Reduce size if there are more values than needed for graph if (cpu.core_percent.at(i-1).size() > 40) cpu.core_percent.at(i-1).pop_front(); } //? Notify main thread to redraw screen if we found more cores than previously detected if (cmp_greater(cpu.core_percent.size(), Shared::coreCount)) { Logger::debug("Changing CPU max corecount from {} to {}.", Shared::coreCount, cpu.core_percent.size()); Runner::coreNum_reset = true; Shared::coreCount = cpu.core_percent.size(); while (cmp_less(current_cpu.temp.size(), cpu.core_percent.size() + 1)) current_cpu.temp.push_back({0}); } } catch (const std::exception& e) { Logger::debug("Cpu::collect() : {}", e.what()); if (cread.bad()) throw std::runtime_error("Failed to read /proc/stat"); else throw std::runtime_error(fmt::format("Cpu::collect() : {}", e.what())); } if (Config::getB("check_temp") and got_sensors) update_sensors(); if (Config::getB("show_battery") and has_battery) current_bat = get_battery(); if (Config::getB("show_cpu_watts") and supports_watts) current_cpu.usage_watts = get_cpuConsumptionWatts(); cpu.active_cpus = std::make_optional(detect_active_cpus()); return cpu; } } #ifdef GPU_SUPPORT namespace Gpu { //? NVIDIA namespace Nvml { bool init() { if (initialized) return false; //? Dynamic loading & linking //? Try possible library names for libnvidia-ml.so const array libNvAlts = { "libnvidia-ml.so", "libnvidia-ml.so.1", }; for (const auto& l : libNvAlts) { nvml_dl_handle = dlopen(l, RTLD_LAZY); if (nvml_dl_handle != nullptr) { break; } } if (!nvml_dl_handle) { Logger::info("Failed to load libnvidia-ml.so, NVIDIA GPUs will not be detected: {}", dlerror()); return false; } auto load_nvml_sym = [&](const char sym_name[]) { auto sym = dlsym(nvml_dl_handle, sym_name); auto err = dlerror(); if (err != nullptr) { Logger::error("NVML: Couldn't find function {}: {}", sym_name, err); return (void*)nullptr; } else return sym; }; #define LOAD_SYM(NAME) if ((NAME = (decltype(NAME))load_nvml_sym(#NAME)) == nullptr) return false LOAD_SYM(nvmlErrorString); LOAD_SYM(nvmlInit); LOAD_SYM(nvmlShutdown); LOAD_SYM(nvmlDeviceGetCount); LOAD_SYM(nvmlDeviceGetHandleByIndex); LOAD_SYM(nvmlDeviceGetName); LOAD_SYM(nvmlDeviceGetPowerManagementLimit); LOAD_SYM(nvmlDeviceGetTemperatureThreshold); LOAD_SYM(nvmlDeviceGetUtilizationRates); LOAD_SYM(nvmlDeviceGetClockInfo); LOAD_SYM(nvmlDeviceGetPowerUsage); LOAD_SYM(nvmlDeviceGetPowerState); LOAD_SYM(nvmlDeviceGetTemperature); LOAD_SYM(nvmlDeviceGetMemoryInfo); LOAD_SYM(nvmlDeviceGetPcieThroughput); LOAD_SYM(nvmlDeviceGetEncoderUtilization); LOAD_SYM(nvmlDeviceGetDecoderUtilization); #undef LOAD_SYM //? Function calls nvmlReturn_t result = nvmlInit(); if (result != NVML_SUCCESS) { Logger::debug("Failed to initialize NVML, NVIDIA GPUs will not be detected: {}", nvmlErrorString(result)); return false; } //? Device count result = nvmlDeviceGetCount(&device_count); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get device count: {}", nvmlErrorString(result)); return false; } if (device_count > 0) { devices.resize(device_count); gpus.resize(device_count); gpu_names.resize(device_count); initialized = true; //? Check supported functions & get maximums Nvml::collect<1>(gpus.data()); return true; } else {initialized = true; shutdown(); return false;} } bool shutdown() { if (!initialized) return false; nvmlReturn_t result = nvmlShutdown(); if (NVML_SUCCESS == result) { initialized = false; dlclose(nvml_dl_handle); } else Logger::warning("Failed to shutdown NVML: {}", nvmlErrorString(result)); return !initialized; } template // collect<1> is called in Nvml::init(), and populates gpus.supported_functions bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count if (!initialized) return false; nvmlReturn_t result; join_thread pcie_tx_thread; join_thread pcie_rx_thread; // DebugTimer nvTotalTimer("Nvidia Total"); for (unsigned int i = 0; i < device_count; ++i) { if constexpr(is_init) { //? Device Handle result = nvmlDeviceGetHandleByIndex(i, devices.data() + i); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get device handle: {}", nvmlErrorString(result)); gpus[i].supported_functions = {false, false, false, false, false, false, false, false, false, false}; continue; } //? Device name char name[NVML_DEVICE_NAME_BUFFER_SIZE]; result = nvmlDeviceGetName(devices[i], name, NVML_DEVICE_NAME_BUFFER_SIZE); if (result != NVML_SUCCESS) Logger::warning("NVML: Failed to get device name: {}", nvmlErrorString(result)); else { gpu_names[i] = string(name); for (const auto& brand : {"NVIDIA", "Nvidia", "(R)", "(TM)"}) { gpu_names[i] = s_replace(gpu_names[i], brand, ""); } gpu_names[i] = trim(gpu_names[i]); } //? Power usage unsigned int max_power; result = nvmlDeviceGetPowerManagementLimit(devices[i], &max_power); if (result != NVML_SUCCESS) Logger::warning("NVML: Failed to get maximum GPU power draw, defaulting to 225W: {}", nvmlErrorString(result)); else { gpus[i].pwr_max_usage = max_power; // RSMI reports power in microWatts gpu_pwr_total_max += max_power; } //? Get temp_max unsigned int temp_max; result = nvmlDeviceGetTemperatureThreshold(devices[i], NVML_TEMPERATURE_THRESHOLD_SHUTDOWN, &temp_max); if (result != NVML_SUCCESS) Logger::warning("NVML: Failed to get maximum GPU temperature, defaulting to 110ยฐC: {}", nvmlErrorString(result)); else gpus[i].temp_max = (long long)temp_max; } //? PCIe link speeds, the data collection takes >=20ms each call so they run on separate threads if (gpus_slice[i].supported_functions.pcie_txrx and (Config::getB("nvml_measure_pcie_speeds") or is_init)) { pcie_tx_thread = join_thread([gpus_slice, i]() { unsigned int tx; nvmlReturn_t result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_TX_BYTES, &tx); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get PCIe TX throughput: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.pcie_txrx = false; } else gpus_slice[i].pcie_tx = (long long)tx; }); pcie_rx_thread = join_thread([gpus_slice, i]() { unsigned int rx; nvmlReturn_t result = nvmlDeviceGetPcieThroughput(devices[i], NVML_PCIE_UTIL_RX_BYTES, &rx); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get PCIe RX throughput: {}", nvmlErrorString(result)); } else gpus_slice[i].pcie_rx = (long long)rx; }); } else { gpus_slice[i].pcie_tx = -1; gpus_slice[i].pcie_rx = -1; } // DebugTimer nvTimer("Nv utilization"); //? GPU & memory utilization if (gpus_slice[i].supported_functions.gpu_utilization) { nvmlUtilization_t utilization; result = nvmlDeviceGetUtilizationRates(devices[i], &utilization); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get GPU utilization: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_utilization = false; if constexpr(is_init) gpus_slice[i].supported_functions.mem_utilization = false; } else { gpus_slice[i].gpu_percent.at("gpu-totals").push_back((long long)utilization.gpu); gpus_slice[i].mem_utilization_percent.push_back((long long)utilization.memory); } } // nvTimer.stop_rename_reset("Nv clock"); //? Clock speeds if (gpus_slice[i].supported_functions.gpu_clock) { unsigned int gpu_clock; result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_GRAPHICS, &gpu_clock); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get GPU clock speed: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else gpus_slice[i].gpu_clock_speed = (long long)gpu_clock; } if (gpus_slice[i].supported_functions.mem_clock) { unsigned int mem_clock; result = nvmlDeviceGetClockInfo(devices[i], NVML_CLOCK_MEM, &mem_clock); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get VRAM clock speed: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else gpus_slice[i].mem_clock_speed = (long long)mem_clock; } // nvTimer.stop_rename_reset("Nv power"); //? Power usage & state if (gpus_slice[i].supported_functions.pwr_usage) { unsigned int power; result = nvmlDeviceGetPowerUsage(devices[i], &power); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get GPU power usage: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.pwr_usage = false; } else { gpus_slice[i].pwr_usage = (long long)power; if (gpus_slice[i].pwr_usage > gpus_slice[i].pwr_max_usage) gpus_slice[i].pwr_max_usage = gpus_slice[i].pwr_usage; gpus_slice[i].gpu_percent.at("gpu-pwr-totals").push_back(clamp((long long)round((double)gpus_slice[i].pwr_usage * 100.0 / (double)gpus_slice[i].pwr_max_usage), 0ll, 100ll)); } } if (gpus_slice[i].supported_functions.pwr_state) { nvmlPstates_t pState; result = nvmlDeviceGetPowerState(devices[i], &pState); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get GPU power state: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.pwr_state = false; } else gpus_slice[i].pwr_state = static_cast(pState); } // nvTimer.stop_rename_reset("Nv temp"); //? GPU temperature if (gpus_slice[i].supported_functions.temp_info) { if (Config::getB("check_temp")) { unsigned int temp; nvmlReturn_t result = nvmlDeviceGetTemperature(devices[i], NVML_TEMPERATURE_GPU, &temp); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get GPU temperature: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.temp_info = false; } else gpus_slice[i].temp.push_back((long long)temp); } } // nvTimer.stop_rename_reset("Nv mem"); //? Memory info if (gpus_slice[i].supported_functions.mem_total) { nvmlMemory_t memory; result = nvmlDeviceGetMemoryInfo(devices[i], &memory); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get VRAM info: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.mem_total = false; if constexpr(is_init) gpus_slice[i].supported_functions.mem_used = false; } else { gpus_slice[i].mem_total = memory.total; gpus_slice[i].mem_used = memory.used; //gpu.mem_free = memory.free; auto used_percent = (long long)round((double)memory.used * 100.0 / (double)memory.total); gpus_slice[i].gpu_percent.at("gpu-vram-totals").push_back(used_percent); } } // nvTimer.stop_rename_reset("Nv enc"); //? Encoder info if (gpus_slice[i].supported_functions.encoder_utilization) { unsigned int utilization; unsigned int samplingPeriodUs; result = nvmlDeviceGetEncoderUtilization(devices[i], &utilization, &samplingPeriodUs); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get encoder utilization: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.encoder_utilization = false; } else gpus_slice[i].encoder_utilization = (long long)utilization; } // nvTimer.stop_rename_reset("Nv dec"); //? Decoder info if (gpus_slice[i].supported_functions.decoder_utilization) { unsigned int utilization; unsigned int samplingPeriodUs; result = nvmlDeviceGetDecoderUtilization(devices[i], &utilization, &samplingPeriodUs); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get decoder utilization: {}", nvmlErrorString(result)); if constexpr(is_init) gpus_slice[i].supported_functions.decoder_utilization = false; } else gpus_slice[i].decoder_utilization = (long long)utilization; } //? TODO: Processes using GPU /*unsigned int proc_info_len; nvmlProcessInfo_t* proc_info = 0; result = nvmlDeviceGetComputeRunningProcesses_v3(device, &proc_info_len, proc_info); if (result != NVML_SUCCESS) { Logger::warning("NVML: Failed to get compute processes: {}", nvmlErrorString(result)); } else { for (unsigned int i = 0; i < proc_info_len; ++i) gpus_slice[i].graphics_processes.push_back({proc_info[i].pid, proc_info[i].usedGpuMemory}); }*/ // nvTimer.stop_rename_reset("Nv pcie thread join"); //? Join PCIE TX/RX threads if constexpr(is_init) { // there doesn't seem to be a better way to do this, but this should be fine considering it's just 2 lines pcie_tx_thread.join(); pcie_rx_thread.join(); } else if (gpus_slice[i].supported_functions.pcie_txrx and Config::getB("nvml_measure_pcie_speeds")) { pcie_tx_thread.join(); pcie_rx_thread.join(); } } return true; } } //? AMD namespace Rsmi { bool init() { if (initialized) return false; //? Dynamic loading & linking #if !defined(RSMI_STATIC) //? Try possible library paths and names for librocm_smi64.so const array libRocAlts = { "/opt/rocm/lib/librocm_smi64.so", "librocm_smi64.so", "librocm_smi64.so.5", // fedora "librocm_smi64.so.1.0", // debian "librocm_smi64.so.6" }; for (const auto& l : libRocAlts) { rsmi_dl_handle = dlopen(l, RTLD_LAZY); if (rsmi_dl_handle != nullptr) { break; } } if (!rsmi_dl_handle) { Logger::info("Failed to load librocm_smi64.so, AMD GPUs will not be detected: {}", dlerror()); return false; } auto load_rsmi_sym = [&](const char sym_name[]) { auto sym = dlsym(rsmi_dl_handle, sym_name); auto err = dlerror(); if (err != nullptr) { Logger::error("ROCm SMI: Couldn't find function {}: {}", sym_name, err); return (void*)nullptr; } else return sym; }; #define LOAD_SYM(NAME) if ((NAME = (decltype(NAME))load_rsmi_sym(#NAME)) == nullptr) return false LOAD_SYM(rsmi_init); LOAD_SYM(rsmi_shut_down); LOAD_SYM(rsmi_version_get); LOAD_SYM(rsmi_num_monitor_devices); LOAD_SYM(rsmi_dev_name_get); LOAD_SYM(rsmi_dev_power_cap_get); LOAD_SYM(rsmi_dev_temp_metric_get); LOAD_SYM(rsmi_dev_busy_percent_get); LOAD_SYM(rsmi_dev_memory_busy_percent_get); LOAD_SYM(rsmi_dev_power_ave_get); LOAD_SYM(rsmi_dev_memory_total_get); LOAD_SYM(rsmi_dev_memory_usage_get); LOAD_SYM(rsmi_dev_pci_throughput_get); #undef LOAD_SYM #endif //? Function calls rsmi_status_t result = rsmi_init(0); if (result != RSMI_STATUS_SUCCESS) { Logger::debug("Failed to initialize ROCm SMI, AMD GPUs will not be detected"); return false; } #if !defined(RSMI_STATIC) //? Check version rsmi_version_t version; result = rsmi_version_get(&version); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get version"); return false; } // Two distinct real-world libraries report version.major == 1: // - ROCm 7.2 ships the v6 ABI (see upstream PR #1566). // - Debian/Ubuntu's librocm-smi64 is built from 5.x sources but // rocm_smi64Config.h reports version 1.0.0, so the ABI is v5. // Probe a 6.x-only symbol to disambiguate instead of guessing. uint32_t effective_major = version.major; if (version.major == 1) { bool has_v6_symbol = (dlsym(rsmi_dl_handle, "rsmi_dev_activity_metric_get") != nullptr); (void)dlerror(); // clear error state from the probe effective_major = has_v6_symbol ? 6 : 5; Logger::warning("ROCm SMI: library reports version 1.x; assuming {}.x ABI based on symbol probe", has_v6_symbol ? "6" : "5"); } if (effective_major == 5) { if ((rsmi_dev_gpu_clk_freq_get_v5 = (decltype(rsmi_dev_gpu_clk_freq_get_v5))load_rsmi_sym("rsmi_dev_gpu_clk_freq_get")) == nullptr) return false; // In the release tarballs of rocm 6.0.0 and 6.0.2 the version queried with rsmi_version_get is 7.0.0.0 } else if (effective_major == 6 || effective_major == 7) { if ((rsmi_dev_gpu_clk_freq_get_v6 = (decltype(rsmi_dev_gpu_clk_freq_get_v6))load_rsmi_sym("rsmi_dev_gpu_clk_freq_get")) == nullptr) return false; } else { Logger::warning("ROCm SMI: Dynamic loading only supported for version 5 and 6"); return false; } version_major = effective_major; #endif //? Device count result = rsmi_num_monitor_devices(&device_count); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to fetch number of devices"); return false; } if (device_count > 0) { gpus.resize(gpus.size() + device_count); gpu_names.resize(gpus.size() + device_count); initialized = true; //? Check supported functions & get maximums Rsmi::collect<1>(gpus.data() + Nvml::device_count); return true; } else {initialized = true; shutdown(); return false;} } bool shutdown() { if (!initialized) return false; if (rsmi_shut_down() == RSMI_STATUS_SUCCESS) { initialized = false; #if !defined(RSMI_STATIC) dlclose(rsmi_dl_handle); #endif } else Logger::warning("Failed to shutdown ROCm SMI"); return true; } template bool collect(gpu_info* gpus_slice) { // raw pointer to vector data, size == device_count, offset by Nvml::device_count elements if (!initialized) return false; rsmi_status_t result; for (uint32_t i = 0; i < device_count; ++i) { if constexpr(is_init) { //? Device name char name[RSMI_DEVICE_NAME_BUFFER_SIZE]; result = rsmi_dev_name_get(i, name, RSMI_DEVICE_NAME_BUFFER_SIZE); if (result != RSMI_STATUS_SUCCESS) Logger::warning("ROCm SMI: Failed to get device name"); else gpu_names[Nvml::device_count + i] = string(name); //? Power usage uint64_t max_power; result = rsmi_dev_power_cap_get(i, 0, &max_power); if (result != RSMI_STATUS_SUCCESS) Logger::warning("ROCm SMI: Failed to get maximum GPU power draw, defaulting to 225W"); else { gpus_slice[i].pwr_max_usage = (long long)(max_power/1000); // RSMI reports power in microWatts gpu_pwr_total_max += gpus_slice[i].pwr_max_usage; } //? Get temp_max int64_t temp_max; result = rsmi_dev_temp_metric_get(i, RSMI_TEMP_TYPE_EDGE, RSMI_TEMP_MAX, &temp_max); if (result != RSMI_STATUS_SUCCESS) Logger::warning("ROCm SMI: Failed to get maximum GPU temperature, defaulting to 110ยฐC"); else gpus_slice[i].temp_max = (long long)temp_max; //? Disable encoder and decoder utilisation on AMD gpus_slice[i].supported_functions.encoder_utilization = false; gpus_slice[i].supported_functions.decoder_utilization = false; } //? GPU utilization if (gpus_slice[i].supported_functions.gpu_utilization) { uint32_t utilization; result = rsmi_dev_busy_percent_get(i, &utilization); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get GPU utilization"); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_utilization = false; } else gpus_slice[i].gpu_percent.at("gpu-totals").push_back((long long)utilization); } //? Memory utilization if (gpus_slice[i].supported_functions.mem_utilization) { uint32_t utilization; result = rsmi_dev_memory_busy_percent_get(i, &utilization); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get VRAM utilization"); if constexpr(is_init) gpus_slice[i].supported_functions.mem_utilization = false; } else gpus_slice[i].mem_utilization_percent.push_back((long long)utilization); } #if !defined(RSMI_STATIC) //? Clock speeds // Some AMD devices (e.g. integrated GPUs with the Debian 5.7.0 rocm_smi package) return // RSMI_STATUS_SUCCESS from rsmi_dev_gpu_clk_freq_get but leave frequencies.current // uninitialized, which crashes when used as an array index. Bound-check before indexing. if (gpus_slice[i].supported_functions.gpu_clock) { if (version_major == 5) { rsmi_frequencies_t_v5 frequencies{}; result = rsmi_dev_gpu_clk_freq_get_v5(i, RSMI_CLK_TYPE_SYS, &frequencies); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get GPU clock speed: "); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else if (frequencies.num_supported == 0 || frequencies.current >= frequencies.num_supported || frequencies.num_supported > RSMI_MAX_NUM_FREQUENCIES_V5) { Logger::warning("ROCm SMI: GPU clock speed unsupported on this device"); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else gpus_slice[i].gpu_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz } else if (version_major == 6 || version_major == 7) { rsmi_frequencies_t_v6 frequencies{}; result = rsmi_dev_gpu_clk_freq_get_v6(i, RSMI_CLK_TYPE_SYS, &frequencies); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get GPU clock speed: "); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else if (frequencies.num_supported == 0 || frequencies.current >= frequencies.num_supported || frequencies.num_supported > RSMI_MAX_NUM_FREQUENCIES_V6) { Logger::warning("ROCm SMI: GPU clock speed unsupported on this device"); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else gpus_slice[i].gpu_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz } } if (gpus_slice[i].supported_functions.mem_clock) { if (version_major == 5) { rsmi_frequencies_t_v5 frequencies{}; result = rsmi_dev_gpu_clk_freq_get_v5(i, RSMI_CLK_TYPE_MEM, &frequencies); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get VRAM clock speed: "); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else if (frequencies.num_supported == 0 || frequencies.current >= frequencies.num_supported || frequencies.num_supported > RSMI_MAX_NUM_FREQUENCIES_V5) { Logger::warning("ROCm SMI: VRAM clock speed unsupported on this device"); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else gpus_slice[i].mem_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz } else if (version_major == 6 || version_major == 7) { rsmi_frequencies_t_v6 frequencies{}; result = rsmi_dev_gpu_clk_freq_get_v6(i, RSMI_CLK_TYPE_MEM, &frequencies); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get VRAM clock speed: "); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else if (frequencies.num_supported == 0 || frequencies.current >= frequencies.num_supported || frequencies.num_supported > RSMI_MAX_NUM_FREQUENCIES_V6) { Logger::warning("ROCm SMI: VRAM clock speed unsupported on this device"); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else gpus_slice[i].mem_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz } } #else //? Clock speeds // Same defensive pattern as the dynamic path above: bound-check the reported // frequencies before indexing, in case the driver returns SUCCESS without // populating the struct. if (gpus_slice[i].supported_functions.gpu_clock) { rsmi_frequencies_t frequencies{}; result = rsmi_dev_gpu_clk_freq_get(i, RSMI_CLK_TYPE_SYS, &frequencies); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get GPU clock speed: "); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else if (frequencies.num_supported == 0 || frequencies.current >= frequencies.num_supported || frequencies.num_supported > RSMI_MAX_NUM_FREQUENCIES) { Logger::warning("ROCm SMI: GPU clock speed unsupported on this device"); if constexpr(is_init) gpus_slice[i].supported_functions.gpu_clock = false; } else gpus_slice[i].gpu_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz } if (gpus_slice[i].supported_functions.mem_clock) { rsmi_frequencies_t frequencies{}; result = rsmi_dev_gpu_clk_freq_get(i, RSMI_CLK_TYPE_MEM, &frequencies); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get VRAM clock speed: "); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else if (frequencies.num_supported == 0 || frequencies.current >= frequencies.num_supported || frequencies.num_supported > RSMI_MAX_NUM_FREQUENCIES) { Logger::warning("ROCm SMI: VRAM clock speed unsupported on this device"); if constexpr(is_init) gpus_slice[i].supported_functions.mem_clock = false; } else gpus_slice[i].mem_clock_speed = (long long)frequencies.frequency[frequencies.current]/1000000; // Hz to MHz } #endif //? Power usage & state if (gpus_slice[i].supported_functions.pwr_usage) { uint64_t power; result = rsmi_dev_power_ave_get(i, 0, &power); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get GPU power usage"); if constexpr(is_init) gpus_slice[i].supported_functions.pwr_usage = false; } else { gpus_slice[i].pwr_usage = (long long)power / 1000; if (gpus_slice[i].pwr_usage > gpus_slice[i].pwr_max_usage) gpus_slice[i].pwr_max_usage = gpus_slice[i].pwr_usage; gpus_slice[i].gpu_percent.at("gpu-pwr-totals").push_back(clamp((long long)round((double)gpus_slice[i].pwr_usage * 100.0 / (double)gpus_slice[i].pwr_max_usage), 0ll, 100ll)); } if constexpr(is_init) gpus_slice[i].supported_functions.pwr_state = false; } //? GPU temperature if (gpus_slice[i].supported_functions.temp_info) { if (Config::getB("check_temp") or is_init) { int64_t temp; result = rsmi_dev_temp_metric_get(i, RSMI_TEMP_TYPE_EDGE, RSMI_TEMP_CURRENT, &temp); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get GPU temperature"); if constexpr(is_init) gpus_slice[i].supported_functions.temp_info = false; } else gpus_slice[i].temp.push_back((long long)temp/1000); } } //? Memory info if (gpus_slice[i].supported_functions.mem_total) { uint64_t total; result = rsmi_dev_memory_total_get(i, RSMI_MEM_TYPE_VRAM, &total); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get total VRAM"); if constexpr(is_init) gpus_slice[i].supported_functions.mem_total = false; } else gpus_slice[i].mem_total = total; } if (gpus_slice[i].supported_functions.mem_used) { uint64_t used; result = rsmi_dev_memory_usage_get(i, RSMI_MEM_TYPE_VRAM, &used); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get VRAM usage"); if constexpr(is_init) gpus_slice[i].supported_functions.mem_used = false; } else { gpus_slice[i].mem_used = used; if (gpus_slice[i].supported_functions.mem_total) gpus_slice[i].gpu_percent.at("gpu-vram-totals").push_back((long long)round((double)used * 100.0 / (double)gpus_slice[i].mem_total)); } } //? PCIe link speeds if ((gpus_slice[i].supported_functions.pcie_txrx and Config::getB("rsmi_measure_pcie_speeds")) or is_init) { uint64_t tx, rx; result = rsmi_dev_pci_throughput_get(i, &tx, &rx, nullptr); if (result != RSMI_STATUS_SUCCESS) { Logger::warning("ROCm SMI: Failed to get PCIe throughput"); if constexpr(is_init) gpus_slice[i].supported_functions.pcie_txrx = false; } else { gpus_slice[i].pcie_tx = (long long)tx; gpus_slice[i].pcie_rx = (long long)rx; } } else { gpus_slice[i].pcie_tx = -1; gpus_slice[i].pcie_rx = -1; } } return true; } } namespace Intel { bool init() { if (initialized) return false; char *gpu_path = find_intel_gpu_dir(); if (!gpu_path) { Logger::debug("Failed to find Intel GPU sysfs path, Intel GPUs will not be detected"); return false; } char *gpu_device_id = get_intel_device_id(gpu_path); if (!gpu_device_id) { Logger::debug("Failed to find Intel GPU device ID, Intel GPUs will not be detected"); return false; } char *gpu_device_name = get_intel_device_name(gpu_device_id); if (!gpu_device_name) { Logger::warning("Failed to find Intel GPU device name in internal database"); } free(gpu_device_id); engines = discover_engines(device); if (!engines) { Logger::debug("Failed to find Intel GPU engines, Intel GPUs will not be detected"); return false; } int ret = pmu_init(engines); if (ret) { Logger::warning("Intel GPU: Failed to initialize PMU"); return false; } pmu_sample(engines); device_count = 1; gpus.resize(gpus.size() + device_count); gpu_names.resize(gpus.size() + device_count); if (gpu_device_name) { gpu_names[Nvml::device_count + Rsmi::device_count] = string(gpu_device_name); } else { gpu_names[Nvml::device_count + Rsmi::device_count] = "Intel GPU"; } free(gpu_device_name); initialized = true; Intel::collect<1>(gpus.data() + Nvml::device_count + Rsmi::device_count); return true; } bool shutdown() { if (!initialized) return false; if (engines) { free_engines(engines); engines = nullptr; } initialized = false; return true; } template bool collect(gpu_info* gpus_slice) { if (!initialized) return false; if constexpr(is_init) { gpus_slice->supported_functions = { .gpu_utilization = true, .mem_utilization = false, .gpu_clock = true, .mem_clock = false, .pwr_usage = true, .pwr_state = false, .temp_info = false, .mem_total = false, .mem_used = false, .pcie_txrx = false, .encoder_utilization = false, .decoder_utilization = false }; gpus_slice->pwr_max_usage = 10'000; //? 10W } pmu_sample(engines); double t = (double)(engines->ts.cur - engines->ts.prev) / 1e9; double max_util = 0; for (unsigned int i = 0; i < engines->num_engines; i++) { struct engine *engine = &(&engines->engine)[i]; double util = pmu_calc(&engine->busy.val, 1e9, t, 100); if (util > max_util) { max_util = util; } } gpus_slice->gpu_percent.at("gpu-totals").push_back((long long)round(max_util)); double pwr = pmu_calc(&engines->r_gpu.val, 1, t, engines->r_gpu.scale); // in Watts gpus_slice->pwr_usage = (long long)round(pwr * 1000); if (gpus_slice->pwr_usage > gpus_slice->pwr_max_usage) gpus_slice->pwr_max_usage = gpus_slice->pwr_usage; gpus_slice->gpu_percent.at("gpu-pwr-totals").push_back(clamp((long long)round((double)gpus_slice->pwr_usage * 100.0 / (double)gpus_slice->pwr_max_usage), 0ll, 100ll)); double freq = pmu_calc(&engines->freq_act.val, 1, t, 1); // in MHz gpus_slice->gpu_clock_speed = (unsigned int)round(freq); return true; } } //? Collect data from GPU-specific libraries auto collect(bool no_update) -> vector& { if (Runner::stopping or (no_update and not gpus.empty())) return gpus; // DebugTimer gpu_timer("GPU Total"); //* Collect data Nvml::collect<0>(gpus.data()); // raw pointer to vector data, size == Nvml::device_count Rsmi::collect<0>(gpus.data() + Nvml::device_count); // size = Rsmi::device_count Intel::collect<0>(gpus.data() + Nvml::device_count + Rsmi::device_count); // size = Intel::device_count //* Calculate average usage long long avg = 0; long long mem_usage_total = 0; long long mem_total = 0; long long pwr_total = 0; for (auto& gpu : gpus) { if (gpu.supported_functions.gpu_utilization) avg += gpu.gpu_percent.at("gpu-totals").back(); if (gpu.supported_functions.mem_used) mem_usage_total += gpu.mem_used; if (gpu.supported_functions.mem_total) mem_total += gpu.mem_total; if (gpu.supported_functions.pwr_usage) pwr_total += gpu.pwr_usage; //* Trim vectors if there are more values than needed for graphs if (width != 0) { //? GPU & memory utilization while (cmp_greater(gpu.gpu_percent.at("gpu-totals").size(), width * 2)) gpu.gpu_percent.at("gpu-totals").pop_front(); while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); //? Power usage while (cmp_greater(gpu.gpu_percent.at("gpu-pwr-totals").size(), width)) gpu.gpu_percent.at("gpu-pwr-totals").pop_front(); //? Temperature while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); //? Memory usage while (cmp_greater(gpu.gpu_percent.at("gpu-vram-totals").size(), width/2)) gpu.gpu_percent.at("gpu-vram-totals").pop_front(); } } shared_gpu_percent.at("gpu-average").push_back(avg / gpus.size()); if (mem_total != 0) shared_gpu_percent.at("gpu-vram-total").push_back(static_cast(round(mem_usage_total * 100.0 / mem_total))); if (gpu_pwr_total_max != 0) shared_gpu_percent.at("gpu-pwr-total").push_back(clamp(static_cast(round(pwr_total * 100.0 / gpu_pwr_total_max)), 0ll, 100ll)); if (width != 0) { while (cmp_greater(shared_gpu_percent.at("gpu-average").size(), width * 2)) shared_gpu_percent.at("gpu-average").pop_front(); while (cmp_greater(shared_gpu_percent.at("gpu-pwr-total").size(), width * 2)) shared_gpu_percent.at("gpu-pwr-total").pop_front(); while (cmp_greater(shared_gpu_percent.at("gpu-vram-total").size(), width * 2)) shared_gpu_percent.at("gpu-vram-total").pop_front(); } count = gpus.size(); return gpus; } } #endif /// Convert ascii escapes like \040 into chars. static auto convert_ascii_escapes(const std::string& input) -> std::string { std::string out; out.reserve(input.size()); for (std::size_t i = 0; i < input.size(); ++i) { if (input[i] == '\\' && // Peek the next three characters. i + 3 < input.size() && std::isdigit(input[i + 1]) && std::isdigit(input[i + 2]) && std::isdigit(input[i + 3])) { // Convert octal chars to decimal int. // '0' - '0' -> 0, '4' - '0' -> 4, '0' - '0' -> 0. // 0 * 64 (0) // + 4 * 8 (32) // + 0 // = 32 (ascii space) int value = ((input[i + 1] - '0') * 64) + ((input[i + 2] - '0') * 8) + (input[i + 3] - '0'); out.push_back(static_cast(value)); // Consume the three digits. i += 3; } else { out.push_back(input[i]); } } return out; } namespace Mem { bool has_swap{}; vector fstab; fs::file_time_type fstab_time; int disk_ios{}; vector last_found; //?* Find the filepath to the specified ZFS object's stat file fs::path get_zfs_stat_file(const string& device_name, size_t dataset_name_start, bool zfs_hide_datasets); //?* Collect total ZFS pool io stats bool zfs_collect_pool_total_stats(struct disk_info &disk); mem_info current_mem {}; uint64_t get_totalMem() { ifstream meminfo(Shared::procPath / "meminfo"); int64_t totalMem = 0; if (meminfo.good()) { meminfo.ignore(SSmax, ':'); meminfo >> totalMem; totalMem <<= 10; } if (not meminfo.good() or totalMem == 0) throw std::runtime_error("Could not get total memory size from /proc/meminfo"); return totalMem; } auto collect(bool no_update) -> mem_info& { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; auto show_swap = Config::getB("show_swap"); auto swap_disk = Config::getB("swap_disk"); auto show_disks = Config::getB("show_disks"); auto zfs_arc_cached = Config::getB("zfs_arc_cached"); auto totalMem = get_totalMem(); auto& mem = current_mem; mem.stats.at("swap_total") = 0; //? Read ZFS ARC info from /proc/spl/kstat/zfs/arcstats uint64_t arc_size = 0, arc_min_size = 0; if (zfs_arc_cached) { ifstream arcstats(Shared::procPath / "spl/kstat/zfs/arcstats"); if (arcstats.good()) { for (string label; arcstats >> label;) { if (label == "c_min") { arcstats >> arc_min_size >> arc_min_size; // double read skips type column } else if (label == "size") { arcstats >> arc_size >> arc_size; break; } } } arcstats.close(); } //? Read memory info from /proc/meminfo ifstream meminfo(Shared::procPath / "meminfo"); if (meminfo.good()) { bool got_avail = false; for (string label; meminfo.peek() != 'D' and meminfo >> label;) { if (label == "MemFree:") { meminfo >> mem.stats.at("free"); mem.stats.at("free") <<= 10; } else if (label == "MemAvailable:") { meminfo >> mem.stats.at("available"); mem.stats.at("available") <<= 10; got_avail = true; } else if (label == "Cached:") { meminfo >> mem.stats.at("cached"); mem.stats.at("cached") <<= 10; if (not show_swap and not swap_disk) break; } else if (label == "SwapTotal:") { meminfo >> mem.stats.at("swap_total"); mem.stats.at("swap_total") <<= 10; } else if (label == "SwapFree:") { meminfo >> mem.stats.at("swap_free"); mem.stats.at("swap_free") <<= 10; break; } meminfo.ignore(SSmax, '\n'); } if (not got_avail) mem.stats.at("available") = mem.stats.at("free") + mem.stats.at("cached"); if (zfs_arc_cached) { mem.stats.at("cached") += arc_size; // The ARC will not shrink below arc_min_size, so that memory is not available if (arc_size > arc_min_size) mem.stats.at("available") += arc_size - arc_min_size; } mem.stats.at("used") = totalMem - (mem.stats.at("available") <= totalMem ? mem.stats.at("available") : mem.stats.at("free")); if (mem.stats.at("swap_total") > 0) mem.stats.at("swap_used") = mem.stats.at("swap_total") - mem.stats.at("swap_free"); } else throw std::runtime_error("Failed to read /proc/meminfo"); meminfo.close(); //? Calculate percentages for (const auto& name : mem_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / totalMem)); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } if (show_swap and mem.stats.at("swap_total") > 0) { for (const auto& name : swap_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / mem.stats.at("swap_total"))); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } has_swap = true; } else has_swap = false; //? Get disks stats if (show_disks) { static vector ignore_list; double uptime = system_uptime(); auto free_priv = Config::getB("disk_free_priv"); try { auto& disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; auto use_fstab = Config::getB("use_fstab"); auto only_physical = Config::getB("only_physical"); auto zfs_hide_datasets = Config::getB("zfs_hide_datasets"); auto& disks = mem.disks; static std::unordered_map>> disks_stats_promises; ifstream diskread; vector filter; if (not disks_filter.empty()) { filter = ssplit(disks_filter); if (filter.at(0).starts_with("exclude=")) { filter_exclude = true; filter.at(0) = filter.at(0).substr(8); } } //? Get list of "real" filesystems from /proc/filesystems vector fstypes; if (only_physical and not use_fstab) { fstypes = {"zfs", "wslfs", "drvfs"}; diskread.open(Shared::procPath / "filesystems"); if (diskread.good()) { for (string fstype; diskread >> fstype;) { if (not is_in(fstype, "nodev", "squashfs", "nullfs")) fstypes.push_back(fstype); diskread.ignore(SSmax, '\n'); } } else throw std::runtime_error("Failed to read /proc/filesystems"); diskread.close(); } //? Get disk list to use from fstab if enabled if (use_fstab and fs::last_write_time("/etc/fstab") != fstab_time) { fstab.clear(); fstab_time = fs::last_write_time("/etc/fstab"); diskread.open("/etc/fstab"); if (diskread.good()) { for (string instr; diskread >> instr;) { if (not instr.starts_with('#')) { diskread >> instr; #ifdef SNAPPED if (instr == "/") fstab.push_back("/mnt"); else if (not is_in(instr, "none", "swap")) fstab.push_back(instr); #else if (not is_in(instr, "none", "swap")) fstab.push_back(instr); #endif } diskread.ignore(SSmax, '\n'); } } else throw std::runtime_error("Failed to read /etc/fstab"); diskread.close(); } //? Get mounts from /etc/mtab or /proc/self/mounts diskread.open((fs::exists("/etc/mtab") ? fs::path("/etc/mtab") : Shared::procPath / "self/mounts")); if (diskread.good()) { vector found; found.reserve(last_found.size()); string dev, mountpoint, fstype; while (not diskread.eof()) { std::error_code ec; diskread >> dev >> mountpoint >> fstype; diskread.ignore(SSmax, '\n'); // A mountpoint can ascii escape codes, which will not work with `statvfs`. mountpoint = convert_ascii_escapes(mountpoint); if (v_contains(ignore_list, mountpoint) or v_contains(found, mountpoint)) continue; //? Match filter if not empty if (not filter.empty()) { bool match = v_contains(filter, mountpoint); if ((filter_exclude and match) or (not filter_exclude and not match)) continue; } //? Skip ZFS datasets if zfs_hide_datasets option is enabled size_t zfs_dataset_name_start = 0; if (fstype == "zfs" && (zfs_dataset_name_start = dev.find('/')) != std::string::npos && zfs_hide_datasets) continue; if ((not use_fstab and not only_physical) or (use_fstab and v_contains(fstab, mountpoint)) or (not use_fstab and only_physical and v_contains(fstypes, fstype))) { found.push_back(mountpoint); if (not v_contains(last_found, mountpoint)) redraw = true; //? Save mountpoint, name, fstype, dev path and path to /sys/block stat file if (not disks.contains(mountpoint)) { disks[mountpoint] = disk_info{fs::canonical(dev, ec), fs::path(mountpoint).filename(), fstype}; if (disks.at(mountpoint).dev.empty()) disks.at(mountpoint).dev = dev; #ifdef SNAPPED if (mountpoint == "/mnt") disks.at(mountpoint).name = "root"; #endif if (disks.at(mountpoint).name.empty()) disks.at(mountpoint).name = (mountpoint == "/" ? "root" : mountpoint); string devname = disks.at(mountpoint).dev.filename(); int c = 0; while (devname.size() >= 2) { const auto stat = fmt::format("/sys/block/{}/stat", devname); if (fs::exists(stat, ec) and access(stat.c_str(), R_OK) == 0) { const auto mount_stat = fmt::format("/sys/block/{}/{}/stat", devname, disks.at(mountpoint).dev.filename()); if (c > 0 and fs::exists(mount_stat, ec)) disks.at(mountpoint).stat = std::move(mount_stat); else disks.at(mountpoint).stat = std::move(stat); break; //? Set ZFS stat filepath } else if (fstype == "zfs") { disks.at(mountpoint).stat = get_zfs_stat_file(dev, zfs_dataset_name_start, zfs_hide_datasets); if (disks.at(mountpoint).stat.empty()) { Logger::debug("Failed to get ZFS stat file for device {}", dev); } break; } devname.resize(devname.size() - 1); c++; } } //? If zfs_hide_datasets option was switched, refresh stat filepath if (fstype == "zfs" && ((zfs_hide_datasets && !is_directory(disks.at(mountpoint).stat)) || (!zfs_hide_datasets && is_directory(disks.at(mountpoint).stat)))) { disks.at(mountpoint).stat = get_zfs_stat_file(dev, zfs_dataset_name_start, zfs_hide_datasets); if (disks.at(mountpoint).stat.empty()) { Logger::debug("Failed to get ZFS stat file for device {}", dev); } } } } //? Remove disks no longer mounted or filtered out if (swap_disk and has_swap) found.push_back("swap"); for (auto it = disks.begin(); it != disks.end();) { if (not v_contains(found, it->first)) it = disks.erase(it); else it++; } if (found.size() != last_found.size()) redraw = true; last_found = std::move(found); } else throw std::runtime_error("Failed to get mounts from /etc/mtab and /proc/self/mounts"); diskread.close(); //? Get disk/partition stats for (auto it = disks.begin(); it != disks.end(); ) { auto &[mountpoint, disk] = *it; if (v_contains(ignore_list, mountpoint) or disk.name == "swap") { it = disks.erase(it); continue; } if(auto promises_it = disks_stats_promises.find(mountpoint); promises_it != disks_stats_promises.end()){ auto& promise = promises_it->second; if(promise.valid() && promise.wait_for(0s) == std::future_status::timeout) { ++it; continue; } auto promise_res = promises_it->second.get(); if(promise_res.second != -1){ ignore_list.push_back(mountpoint); Logger::warning("Failed to get disk/partition stats for mount \"{}\" with statvfs error code: {}. Ignoring...", mountpoint, promise_res.second); it = disks.erase(it); continue; } auto &updated_stats = promise_res.first; disk.total = updated_stats.total; disk.free = updated_stats.free; disk.used = updated_stats.used; disk.used_percent = updated_stats.used_percent; disk.free_percent = updated_stats.free_percent; } disks_stats_promises[mountpoint] = async(std::launch::async, [mountpoint, free_priv]() -> pair { struct statvfs vfs; disk_info disk; if (statvfs(mountpoint.c_str(), &vfs) < 0) { return pair{disk, errno}; } disk.total = vfs.f_blocks * vfs.f_frsize; disk.free = (free_priv ? vfs.f_bfree : vfs.f_bavail) * vfs.f_frsize; disk.used = disk.total - disk.free; if (disk.total != 0) { disk.used_percent = round((double)disk.used * 100 / disk.total); disk.free_percent = 100 - disk.used_percent; } else { disk.used_percent = 0; disk.free_percent = 0; } return pair{disk, -1}; }); ++it; } //? Setup disks order in UI and add swap if enabled mem.disks_order.clear(); #ifdef SNAPPED if (disks.contains("/mnt")) mem.disks_order.push_back("/mnt"); #else if (disks.contains("/")) mem.disks_order.push_back("/"); #endif if (swap_disk and has_swap) { mem.disks_order.push_back("swap"); if (not disks.contains("swap")) disks["swap"] = {"", "swap", "swap"}; disks.at("swap").total = mem.stats.at("swap_total"); disks.at("swap").used = mem.stats.at("swap_used"); disks.at("swap").free = mem.stats.at("swap_free"); disks.at("swap").used_percent = mem.percent.at("swap_used").back(); disks.at("swap").free_percent = mem.percent.at("swap_free").back(); } for (const auto& name : last_found) #ifdef SNAPPED if (not is_in(name, "/mnt", "swap")) mem.disks_order.push_back(name); #else if (not is_in(name, "/", "swap")) mem.disks_order.push_back(name); #endif //? Get disks IO int64_t sectors_read, sectors_write, io_ticks, io_ticks_temp; disk_ios = 0; for (auto& [ignored, disk] : disks) { if (disk.stat.empty() or access(disk.stat.c_str(), R_OK) != 0) continue; if (disk.fstype == "zfs" && zfs_hide_datasets && zfs_collect_pool_total_stats(disk)) { disk_ios++; continue; } diskread.open(disk.stat); if (diskread.good()) { disk_ios++; //? ZFS Pool Support if (disk.fstype == "zfs") { // skip first three lines for (int i = 0; i < 3; i++) diskread.ignore(numeric_limits::max(), '\n'); // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> io_ticks; // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> sectors_write; // nbytes written if (disk.io_write.empty()) disk.io_write.push_back(0); else disk.io_write.push_back(max((int64_t)0, (sectors_write - disk.old_io.at(1)))); disk.old_io.at(1) = sectors_write; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> io_ticks_temp; io_ticks += io_ticks_temp; // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> sectors_read; // nbytes read if (disk.io_read.empty()) disk.io_read.push_back(0); else disk.io_read.push_back(max((int64_t)0, (sectors_read - disk.old_io.at(0)))); disk.old_io.at(0) = sectors_read; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); if (disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(max((int64_t)0, (io_ticks - disk.old_io.at(2)))); disk.old_io.at(2) = io_ticks; while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } else { for (int i = 0; i < 2; i++) { diskread >> std::ws; diskread.ignore(SSmax, ' '); } diskread >> sectors_read; if (disk.io_read.empty()) disk.io_read.push_back(0); else disk.io_read.push_back(max((int64_t)0, (sectors_read - disk.old_io.at(0)) * 512)); disk.old_io.at(0) = sectors_read; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); for (int i = 0; i < 3; i++) { diskread >> std::ws; diskread.ignore(SSmax, ' '); } diskread >> sectors_write; if (disk.io_write.empty()) disk.io_write.push_back(0); else disk.io_write.push_back(max((int64_t)0, (sectors_write - disk.old_io.at(1)) * 512)); disk.old_io.at(1) = sectors_write; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); for (int i = 0; i < 2; i++) { diskread >> std::ws; diskread.ignore(SSmax, ' '); } diskread >> io_ticks; if (uptime == old_uptime || disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(clamp((long)round((double)(io_ticks - disk.old_io.at(2)) / (uptime - old_uptime) / 10), 0l, 100l)); disk.old_io.at(2) = io_ticks; while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } } else { Logger::debug("Error in Mem::collect() : when opening {}", disk.stat); } diskread.close(); } old_uptime = uptime; } catch (const std::exception& e) { Logger::warning("Error in Mem::collect() : {}", e.what()); } } return mem; } fs::path get_zfs_stat_file(const string& device_name, size_t dataset_name_start, bool zfs_hide_datasets) { fs::path zfs_pool_stat_path; if (zfs_hide_datasets) { zfs_pool_stat_path = Shared::procPath / "spl/kstat/zfs" / device_name; if (access(zfs_pool_stat_path.c_str(), R_OK) == 0) { return zfs_pool_stat_path; } else { Logger::debug("Can't access folder: {}", zfs_pool_stat_path); return ""; } } ifstream filestream; string filename; string name_compare; if (dataset_name_start != std::string::npos) { // device is a dataset zfs_pool_stat_path = Shared::procPath / "spl/kstat/zfs" / device_name.substr(0, dataset_name_start); } else { // device is a pool zfs_pool_stat_path = Shared::procPath / "spl/kstat/zfs" / device_name; } // looking through all files that start with 'objset' to find the one containing `device_name` object stats try { for (const auto& file: fs::directory_iterator(zfs_pool_stat_path)) { filename = file.path().filename(); if (filename.starts_with("objset")) { filestream.open(file.path()); if (filestream.good()) { // skip first two lines for (int i = 0; i < 2; i++) filestream.ignore(numeric_limits::max(), '\n'); // skip characters until '7' is reached, indicating data type 7, next value will be object name filestream.ignore(numeric_limits::max(), '7'); filestream >> name_compare; if (name_compare == device_name) { filestream.close(); if (access(file.path().c_str(), R_OK) == 0) { return file.path(); } else { Logger::debug("Can't access file: {}", file.path()); return ""; } } } filestream.close(); } } } catch (fs::filesystem_error& e) {} Logger::debug("Could not read directory: {}", zfs_pool_stat_path); return ""; } bool zfs_collect_pool_total_stats(struct disk_info &disk) { ifstream diskread; int64_t bytes_read; int64_t bytes_write; int64_t io_ticks; int64_t bytes_read_total{}; int64_t bytes_write_total{}; int64_t io_ticks_total{}; int64_t objects_read{}; // looking through all files that start with 'objset' for (const auto& file: fs::directory_iterator(disk.stat)) { if ((file.path().filename()).string().starts_with("objset")) { diskread.open(file.path()); if (diskread.good()) { try { // skip first three lines for (int i = 0; i < 3; i++) diskread.ignore(numeric_limits::max(), '\n'); // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> io_ticks; io_ticks_total += io_ticks; // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> bytes_write; bytes_write_total += bytes_write; // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> io_ticks; io_ticks_total += io_ticks; // skip characters until '4' is reached, indicating data type 4, next value will be out target diskread.ignore(numeric_limits::max(), '4'); diskread >> bytes_read; bytes_read_total += bytes_read; } catch (const std::exception& e) { continue; } // increment read objects counter if no errors were encountered objects_read++; } else { Logger::debug("Could not read file: {}", file.path()); } diskread.close(); } } // if for some reason no objects were read if (objects_read == 0) return false; if (disk.io_write.empty()) disk.io_write.push_back(0); else disk.io_write.push_back(max((int64_t)0, (bytes_write_total - disk.old_io.at(1)))); disk.old_io.at(1) = bytes_write_total; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); if (disk.io_read.empty()) disk.io_read.push_back(0); else disk.io_read.push_back(max((int64_t)0, (bytes_read_total - disk.old_io.at(0)))); disk.old_io.at(0) = bytes_read_total; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); if (disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(max((int64_t)0, (io_ticks_total - disk.old_io.at(2)))); disk.old_io.at(2) = io_ticks_total; while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); return true; } } namespace Net { std::unordered_map current_net; net_info empty_net = {}; vector interfaces; string selected_iface; int errors{}; std::unordered_map graph_max = { {"download", {}}, {"upload", {}} }; std::unordered_map> max_count = { {"download", {}}, {"upload", {}} }; bool rescale{true}; uint64_t timestamp{}; auto collect(bool no_update) -> net_info& { if (Runner::stopping) return empty_net; auto& net = current_net; auto& config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { //? Get interface list using getifaddrs() wrapper IfAddrsPtr if_addrs {}; if (if_addrs.get_status() != 0) { errors++; Logger::error("Net::collect() -> getifaddrs() failed with id {}", if_addrs.get_status()); redraw = true; return empty_net; } int family = 0; static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; //? Iteration over all items in getifaddrs() list for (auto* ifa = if_addrs.get(); ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr == nullptr) continue; family = ifa->ifa_addr->sa_family; const auto& iface = ifa->ifa_name; //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); // An interface can have more than one IP of the same family associated with it, // but we pick only the first one to show in the NET box. // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! net[iface].ipv4.clear(); net[iface].ipv6.clear(); } //? Get IPv4 address if (family == AF_INET) { if (net[iface].ipv4.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv4 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //? Get IPv6 address else if (family == AF_INET6) { if (net[iface].ipv6.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv6 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //else, ignoring family==AF_PACKET (see man 3 getifaddrs) which is the first one in the `for` loop. } //? Get total received and transmitted bytes + device address if no ip was found for (const auto& iface : interfaces) { auto& netif = net.at(iface); if (netif.ipv4.empty() and netif.ipv6.empty()) netif.ipv4 = readfile("/sys/class/net/" + iface + "/address"); for (const string dir : {"download", "upload"}) { const fs::path sys_file = "/sys/class/net/" + iface + "/statistics/" + (dir == "download" ? "rx_bytes" : "tx_bytes"); auto& saved_stat = netif.stat.at(dir); auto& bandwidth = netif.bandwidth.at(dir); uint64_t val{}; try { val = stoull(readfile(sys_file, "0")); } catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} //? Update speed, total and top values if (val < saved_stat.last) { saved_stat.rollover += saved_stat.last; saved_stat.last = 0; } if (cmp_greater((unsigned long long)saved_stat.rollover + (unsigned long long)val, numeric_limits::max())) { saved_stat.rollover = 0; saved_stat.last = 0; } saved_stat.speed = round((double)(val - saved_stat.last) / ((double)(new_timestamp - timestamp) / 1000)); if (saved_stat.speed > saved_stat.top) saved_stat.top = saved_stat.speed; if (saved_stat.offset > val + saved_stat.rollover) saved_stat.offset = 0; saved_stat.total = (val + saved_stat.rollover) - saved_stat.offset; saved_stat.last = val; //? Add values to graph bandwidth.push_back(saved_stat.speed); while (cmp_greater(bandwidth.size(), width * 2)) bandwidth.pop_front(); //? Set counters for auto scaling if (net_auto and selected_iface == iface) { if (net_sync and saved_stat.speed < netif.stat.at(dir == "download" ? "upload" : "download").speed) continue; if (saved_stat.speed > graph_max[dir]) { ++max_count[dir][0]; if (max_count[dir][1] > 0) --max_count[dir][1]; } else if (graph_max[dir] > 10 << 10 and saved_stat.speed < graph_max[dir] / 10) { ++max_count[dir][1]; if (max_count[dir][0] > 0) --max_count[dir][0]; } } } } //? Clean up net map if needed if (net.size() > interfaces.size()) { for (auto it = net.begin(); it != net.end();) { if (not v_contains(interfaces, it->first)) it = net.erase(it); else it++; } } timestamp = new_timestamp; } //? Return empty net_info struct if no interfaces was found if (net.empty()) return empty_net; //? Find an interface to display if selected isn't set or valid if (selected_iface.empty() or not v_contains(interfaces, selected_iface)) { max_count["download"][0] = max_count["download"][1] = max_count["upload"][0] = max_count["upload"][1] = 0; redraw = true; if (net_auto) rescale = true; if (not config_iface.empty() and v_contains(interfaces, config_iface)) selected_iface = config_iface; else { //? Sort interfaces by total upload + download bytes auto sorted_interfaces = interfaces; rng::sort(sorted_interfaces, [&](const auto& a, const auto& b){ return cmp_greater(net.at(a).stat["download"].total + net.at(a).stat["upload"].total, net.at(b).stat["download"].total + net.at(b).stat["upload"].total); }); selected_iface.clear(); //? Try to set to a connected interface for (const auto& iface : sorted_interfaces) { if (net.at(iface).connected) { selected_iface = iface; break; } } //? If no interface is connected set to first available if (selected_iface.empty() and not sorted_interfaces.empty()) selected_iface = sorted_interfaces.at(0); else if (sorted_interfaces.empty()) return empty_net; } } //? Calculate max scale for graphs if needed if (net_auto) { bool sync = false; for (const auto& dir: {"download", "upload"}) { for (const auto& sel : {0, 1}) { if (rescale or max_count[dir][sel] >= 5) { const long long avg_speed = (net[selected_iface].bandwidth[dir].size() > 5 ? std::accumulate(net.at(selected_iface).bandwidth.at(dir).rbegin(), net.at(selected_iface).bandwidth.at(dir).rbegin() + 5, 0ll) / 5 : net[selected_iface].stat[dir].speed); graph_max[dir] = max(uint64_t(avg_speed * (sel == 0 ? 1.3 : 3.0)), (uint64_t)10 << 10); max_count[dir][0] = max_count[dir][1] = 0; redraw = true; if (net_sync) sync = true; break; } } //? Sync download/upload graphs if enabled if (sync) { const auto other = (string(dir) == "upload" ? "download" : "upload"); graph_max[other] = graph_max[dir]; max_count[other][0] = max_count[other][1] = 0; break; } } } rescale = false; return net.at(selected_iface); } } namespace Proc { vector current_procs; std::unordered_map uid_user; string current_sort; string current_filter; bool current_rev{}; bool is_tree_mode; fs::file_time_type passwd_time; uint64_t cputimes; int collapse = -1, expand = -1, toggle_children = -1, collapse_all = -1; uint64_t old_cputimes{}; atomic numpids{}; int filter_found{}; detail_container detailed; constexpr size_t KTHREADD = 2; static std::unordered_set kernels_procs = {KTHREADD}; static std::unordered_set dead_procs; //* Get detailed info for selected process static void _collect_details(const size_t pid, const uint64_t uptime, vector& procs) { fs::path pid_path = Shared::procPath / std::to_string(pid); if (pid != detailed.last_pid) { detailed = {}; detailed.last_pid = pid; detailed.skip_smaps = not Config::getB("proc_info_smaps"); } //? Copy proc_info for process from proc vector auto p_info = rng::find(procs, pid, &proc_info::pid); detailed.entry = *p_info; //? Update cpu percent deque for process cpu graph if (not Config::getB("proc_per_core")) detailed.entry.cpu_p *= Shared::coreCount; detailed.cpu_percent.push_back(clamp((long long)round(detailed.entry.cpu_p), 0ll, 100ll)); while (cmp_greater(detailed.cpu_percent.size(), width)) detailed.cpu_percent.pop_front(); //? Process runtime if (detailed.entry.state != 'X') detailed.elapsed = sec_to_dhms(uptime - (detailed.entry.cpu_s / Shared::clkTck)); else detailed.elapsed = sec_to_dhms(detailed.entry.death_time); if (detailed.elapsed.size() > 8) detailed.elapsed.resize(detailed.elapsed.size() - 3); //? Get parent process name if (detailed.parent.empty()) { auto p_entry = rng::find(procs, detailed.entry.ppid, &proc_info::pid); if (p_entry != procs.end()) detailed.parent = p_entry->name; } //? Expand process status from single char to explanative string detailed.status = (proc_states.contains(detailed.entry.state)) ? proc_states.at(detailed.entry.state) : "Unknown"; ifstream d_read; string short_str; //? Try to get RSS mem from proc/[pid]/smaps detailed.memory.clear(); if (not detailed.skip_smaps and fs::exists(pid_path / "smaps")) { d_read.open(pid_path / "smaps"); uint64_t rss = 0; try { while (d_read.good()) { d_read.ignore(SSmax, 'R'); if (d_read.peek() == 's') { d_read.ignore(SSmax, ':'); getline(d_read, short_str, 'k'); rss += stoull(short_str); } } if (rss == detailed.entry.mem >> 10) detailed.skip_smaps = true; else { detailed.mem_bytes.push_back(rss << 10); detailed.memory = floating_humanizer(rss, false, 1); } } catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} d_read.close(); } if (detailed.memory.empty()) { detailed.mem_bytes.push_back(detailed.entry.mem); detailed.memory = floating_humanizer(detailed.entry.mem); } if (detailed.first_mem == -1 or detailed.first_mem < detailed.mem_bytes.back() / 2 or detailed.first_mem > detailed.mem_bytes.back() * 4) { detailed.first_mem = min((uint64_t)detailed.mem_bytes.back() * 2, Mem::get_totalMem()); redraw = true; } while (cmp_greater(detailed.mem_bytes.size(), width)) detailed.mem_bytes.pop_front(); //? Get bytes read and written from proc/[pid]/io if (fs::exists(pid_path / "io")) { d_read.open(pid_path / "io"); try { string name; while (d_read.good()) { getline(d_read, name, ':'); if (name.ends_with("read_bytes")) { getline(d_read, short_str); detailed.io_read = floating_humanizer(stoull(short_str)); } else if (name.ends_with("write_bytes")) { getline(d_read, short_str); detailed.io_write = floating_humanizer(stoull(short_str)); break; } else d_read.ignore(SSmax, '\n'); } } catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} d_read.close(); } } //* Collects and sorts process information from /proc auto collect(bool no_update) -> vector& { if (Runner::stopping) return current_procs; const auto& sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto& filter = Config::getS("proc_filter"); auto per_core = Config::getB("proc_per_core"); auto should_filter_kernel = Config::getB("proc_filter_kernel"); auto tree = Config::getB("proc_tree"); auto show_detailed = Config::getB("show_detailed"); const auto pause_proc_list = Config::getB("pause_proc_list"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); bool tree_mode_change = tree != is_tree_mode; if (sorted_change) { current_sort = sorting; current_rev = reverse; } if (tree_mode_change) is_tree_mode = tree; ifstream pread; string long_string; string short_str; static vector found; const double uptime = system_uptime(); const int cmult = (per_core) ? Shared::coreCount : 1; bool got_detailed = false; static size_t proc_clear_count{}; //* Use pids from last update if only changing filter, sorting or tree options if (no_update and not current_procs.empty()) { if (show_detailed and detailed_pid != detailed.last_pid) _collect_details(detailed_pid, round(uptime), current_procs); } //* ---------------------------------------------Collection start---------------------------------------------- else { should_filter = true; found.clear(); //? First make sure kernel proc cache is cleared. if (should_filter_kernel and ++proc_clear_count >= 256) { //? Clearing the cache is used in the event of a pid wrap around. //? In that event processes that acquire old kernel pids would also be filtered out so we need to manually clean the cache every now and then. kernels_procs.clear(); kernels_procs.emplace(KTHREADD); proc_clear_count = 0; } auto totalMem = Mem::get_totalMem(); int totalMem_len = to_string(totalMem >> 10).size(); //? Update uid_user map if /etc/passwd changed since last run if (not Shared::passwd_path.empty() and fs::last_write_time(Shared::passwd_path) != passwd_time) { string r_uid, r_user; passwd_time = fs::last_write_time(Shared::passwd_path); uid_user.clear(); pread.open(Shared::passwd_path); if (pread.good()) { while (pread.good()) { getline(pread, r_user, ':'); pread.ignore(SSmax, ':'); getline(pread, r_uid, ':'); if (uid_user.contains(r_uid)) break; uid_user[r_uid] = r_user; pread.ignore(SSmax, '\n'); } } else { Shared::passwd_path.clear(); } pread.close(); } //? Get cpu total times from /proc/stat up to the guest field cputimes = 0; pread.open(Shared::procPath / "stat"); if (pread.good()) { pread.ignore(SSmax, ' '); int i = 0; for (uint64_t times; i < 8 and pread >> times; cputimes += times, i++); } else throw std::runtime_error("Failure to read /proc/stat"); pread.close(); //? Iterate over all pids in /proc for (const auto& d: fs::directory_iterator(Shared::procPath)) { if (Runner::stopping) return current_procs; if (pread.is_open()) pread.close(); const string pid_str = d.path().filename(); if (not isdigit(pid_str[0])) continue; const size_t pid = stoul(pid_str); if (should_filter_kernel and kernels_procs.contains(pid)) { continue; } found.push_back(pid); //? Check if pid already exists in current_procs auto find_old = rng::find(current_procs, pid, &proc_info::pid); bool no_cache{}; //? Only add new processes if not paused if (find_old == current_procs.end()) { if (not pause_proc_list) { current_procs.push_back({pid}); find_old = current_procs.end() - 1; no_cache = true; } else continue; } else if (dead_procs.contains(pid)) continue; auto& new_proc = *find_old; //? Get program name, command and username if (no_cache) { pread.open(d.path() / "comm"); if (not pread.good()) continue; getline(pread, new_proc.name); pread.close(); //? Check for whitespace characters in name and set offset to get correct fields from stat file new_proc.name_offset = rng::count(new_proc.name, ' '); pread.open(d.path() / "cmdline"); if (not pread.good()) continue; long_string.clear(); while(getline(pread, long_string, '\0')) { new_proc.cmd += long_string + ' '; if (new_proc.cmd.size() > 1000) { new_proc.cmd.resize(1000); break; } } pread.close(); if (not new_proc.cmd.empty()) new_proc.cmd.pop_back(); pread.open(d.path() / "status"); if (not pread.good()) continue; string uid; string line; while (pread.good()) { getline(pread, line, ':'); if (line == "Uid") { pread.ignore(); getline(pread, uid, '\t'); break; } else { pread.ignore(SSmax, '\n'); } } pread.close(); if (uid_user.contains(uid)) { new_proc.user = uid_user.at(uid); } else { #if !(defined(STATIC_BUILD) && defined(__GLIBC__)) try { struct passwd* udet; udet = getpwuid(stoi(uid)); if (udet != nullptr and udet->pw_name != nullptr) { new_proc.user = string(udet->pw_name); } else { new_proc.user = uid; } } catch (...) { new_proc.user = uid; } #else new_proc.user = uid; #endif } } //? Parse /proc/[pid]/stat pread.open(d.path() / "stat"); if (not pread.good()) continue; const auto& offset = new_proc.name_offset; short_str.clear(); int x = 0, next_x = 3; uint64_t cpu_t = 0; try { for (;;) { while (pread.good() and ++x < next_x + offset) pread.ignore(SSmax, ' '); if (not pread.good()) break; else getline(pread, short_str, ' '); switch (x-offset) { case 3: //? Process state new_proc.state = short_str.at(0); if (new_proc.ppid != 0) next_x = 14; continue; case 4: //? Parent pid new_proc.ppid = stoull(short_str); next_x = 14; continue; case 14: //? Process utime cpu_t = stoull(short_str); continue; case 15: //? Process stime cpu_t += stoull(short_str); next_x = 19; continue; case 19: //? Nice value new_proc.p_nice = stoll(short_str); continue; case 20: //? Number of threads new_proc.threads = stoull(short_str); if (new_proc.cpu_s == 0) { next_x = 22; new_proc.cpu_t = cpu_t; } else next_x = 24; continue; case 22: //? Get cpu seconds if missing new_proc.cpu_s = stoull(short_str); next_x = 24; continue; case 24: //? RSS memory (can be inaccurate, but parsing smaps increases total cpu usage by ~20x) if (cmp_greater(short_str.size(), totalMem_len)) new_proc.mem = totalMem; else new_proc.mem = stoull(short_str) * Shared::pageSize; } break; } } catch (const std::invalid_argument&) { continue; } catch (const std::out_of_range&) { continue; } pread.close(); if (should_filter_kernel and new_proc.ppid == KTHREADD) { kernels_procs.emplace(new_proc.pid); found.pop_back(); } if (x-offset < 24) continue; //? Get RSS memory from /proc/[pid]/statm if value from /proc/[pid]/stat looks wrong if (new_proc.mem >= totalMem) { pread.open(d.path() / "statm"); if (not pread.good()) continue; pread.ignore(SSmax, ' '); pread >> new_proc.mem; new_proc.mem *= Shared::pageSize; pread.close(); } //? Process cpu usage since last update new_proc.cpu_p = clamp(round(cmult * 1000 * (cpu_t - new_proc.cpu_t) / max((uint64_t)1, cputimes - old_cputimes)) / 10.0, 0.0, 100.0 * Shared::coreCount); //? Process cumulative cpu usage since process start new_proc.cpu_c = (double)cpu_t / max(1.0, (uptime * Shared::clkTck) - new_proc.cpu_s); //? Update cached value with latest cpu times new_proc.cpu_t = cpu_t; if (show_detailed and not got_detailed and new_proc.pid == detailed_pid) { got_detailed = true; } } //? Clear dead processes from current_procs and remove kernel processes if enabled and not paused if (not pause_proc_list) { auto eraser = rng::remove_if(current_procs, [&](const auto& element){ return not v_contains(found, element.pid); }); current_procs.erase(eraser.begin(), eraser.end()); if (!dead_procs.empty()) dead_procs.clear(); } //? Set correct state of dead processes if paused else { const bool keep_dead_proc_usage = Config::getB("keep_dead_proc_usage"); for (auto& r : current_procs) { if (rng::find(found, r.pid) == found.end()) { if (r.state != 'X') r.death_time = round(uptime) - (r.cpu_s / Shared::clkTck); r.state = 'X'; dead_procs.emplace(r.pid); //? Reset cpu usage for dead processes if paused and option is set if (!keep_dead_proc_usage) { r.cpu_p = 0.0; r.mem = 0; } } } } //? Update the details info box for process if active if (show_detailed and got_detailed) { _collect_details(detailed_pid, round(uptime), current_procs); } else if (show_detailed and not got_detailed and detailed.status != "Dead") { detailed.status = "Dead"; redraw = true; } old_cputimes = cputimes; } //* ---------------------------------------------Collection done----------------------------------------------- //* Match filter if defined if (should_filter) { filter_found = 0; for (auto& p : current_procs) { if (not tree and not filter.empty()) { if (!matches_filter(p, filter)) { p.filtered = true; filter_found++; } else { p.filtered = false; } } else { p.filtered = false; } } } //* Sort processes if ((sorted_change or tree_mode_change) or (not no_update and not pause_proc_list)) { proc_sorter(current_procs, sorting, reverse, tree); } //* Generate tree view if enabled if (tree and (not no_update or should_filter or sorted_change)) { bool locate_selection = false; if (toggle_children != -1) { auto collapser = rng::find(current_procs, toggle_children, &proc_info::pid); if (collapser != current_procs.end()){ for (auto& p : current_procs) { if (p.ppid == collapser->pid) { auto child = rng::find(current_procs, p.pid, &proc_info::pid); if (child != current_procs.end()){ child->collapsed = not child->collapsed; } } } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } toggle_children = -1; } if (auto find_pid = (collapse != -1 ? collapse : expand); find_pid != -1) { auto collapser = rng::find(current_procs, find_pid, &proc_info::pid); if (collapser != current_procs.end()) { if (collapse == expand) { collapser->collapsed = not collapser->collapsed; } else if (collapse > -1) { collapser->collapsed = true; } else if (expand > -1) { collapser->collapsed = false; } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } collapse = expand = -1; } if (collapse_all != -1) { toggle_tree_collapse(current_procs); collapse_all = -1; if (Config::ints.at("proc_selected") > 0) locate_selection = true; } if (should_filter or not filter.empty()) filter_found = 0; vector tree_procs; tree_procs.reserve(current_procs.size()); if (!pause_proc_list) { for (auto& p : current_procs) { if (not v_contains(found, p.ppid)) p.ppid = 0; } } //? Stable sort to retain selected sorting among processes with the same parent rng::stable_sort(current_procs, rng::less{}, & proc_info::ppid); //? Start recursive iteration over processes with the lowest shared parent pids for (auto& p : rng::equal_range(current_procs, current_procs.at(0).ppid, rng::less{}, &proc_info::ppid)) { _tree_gen(p, current_procs, tree_procs, 0, false, filter, false, no_update, should_filter); } //? Recursive sort over tree structure to account for collapsed processes in the tree int index = 0; tree_sort(tree_procs, sorting, reverse, (pause_proc_list and not (sorted_change or tree_mode_change)), index, current_procs.size()); //? Recursive construction of ASCII tree prefixes. for (auto t = tree_procs.begin(); t != tree_procs.end(); ++t) { _collect_prefixes(*t, t == tree_procs.end() - 1); } //? Final sort based on tree index rng::stable_sort(current_procs, rng::less {}, &proc_info::tree_index); //? Move current selection/view to the selected process when collapsing/expanding in the tree if (locate_selection) { int loc = rng::find(current_procs, Proc::selected_pid, &proc_info::pid)->tree_index; if (Config::ints.at("proc_start") >= loc or Config::ints.at("proc_start") <= loc - Proc::select_max) Config::ints.at("proc_start") = max(0, loc - 1); Config::ints.at("proc_selected") = loc - Config::ints.at("proc_start") + 1; } } numpids = (int)current_procs.size() - filter_found; return current_procs; } } namespace Tools { double system_uptime() { string upstr; ifstream pread(Shared::procPath / "uptime"); if (pread.good()) { try { getline(pread, upstr, ' '); pread.close(); return stod(upstr); } catch (const std::invalid_argument&) {} catch (const std::out_of_range&) {} } throw std::runtime_error(fmt::format("Failed to get uptime from {}", Shared::procPath / "uptime")); } } aristocratos-btop-d43a485/src/linux/intel_gpu_top/000077500000000000000000000000001517514752700223435ustar00rootroot00000000000000aristocratos-btop-d43a485/src/linux/intel_gpu_top/CMakeLists.txt000066400000000000000000000006431517514752700251060ustar00rootroot00000000000000enable_language(C) add_library(igt OBJECT igt_perf.c intel_device_info.c intel_gpu_top.c intel_name_lookup_shim.c ) if(BTOP_LTO) # We have checked LTO support already and it's supported :) set_target_properties(igt PROPERTIES INTERPROCEDURAL_OPTIMIZATION ON) endif() # Disable all warnings target_compile_options(igt PRIVATE -w) # Link igt into btop target_link_libraries(libbtop $) aristocratos-btop-d43a485/src/linux/intel_gpu_top/drm.h000066400000000000000000001220141517514752700232760ustar00rootroot00000000000000/* * Header for the Direct Rendering Manager * * Author: Rickard E. (Rik) Faith * * Acknowledgments: * Dec 1999, Richard Henderson , move to generic cmpxchg. */ /* * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. * All rights reserved. * * 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 (including the next * paragraph) 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 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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 _DRM_H_ #define _DRM_H_ #if defined(__linux__) #include #include typedef unsigned int drm_handle_t; #else /* One of the BSDs */ #include #include #include typedef int8_t __s8; typedef uint8_t __u8; typedef int16_t __s16; typedef uint16_t __u16; typedef int32_t __s32; typedef uint32_t __u32; typedef int64_t __s64; typedef uint64_t __u64; typedef size_t __kernel_size_t; typedef unsigned long drm_handle_t; #endif #if defined(__cplusplus) extern "C" { #endif #define DRM_NAME "drm" /**< Name in kernel, /dev, and /proc */ #define DRM_MIN_ORDER 5 /**< At least 2^5 bytes = 32 bytes */ #define DRM_MAX_ORDER 22 /**< Up to 2^22 bytes = 4MB */ #define DRM_RAM_PERCENT 10 /**< How much system ram can we lock? */ #define _DRM_LOCK_HELD 0x80000000U /**< Hardware lock is held */ #define _DRM_LOCK_CONT 0x40000000U /**< Hardware lock is contended */ #define _DRM_LOCK_IS_HELD(lock) ((lock) & _DRM_LOCK_HELD) #define _DRM_LOCK_IS_CONT(lock) ((lock) & _DRM_LOCK_CONT) #define _DRM_LOCKING_CONTEXT(lock) ((lock) & ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT)) typedef unsigned int drm_context_t; typedef unsigned int drm_drawable_t; typedef unsigned int drm_magic_t; /* * Cliprect. * * \warning: If you change this structure, make sure you change * XF86DRIClipRectRec in the server as well * * \note KW: Actually it's illegal to change either for * backwards-compatibility reasons. */ struct drm_clip_rect { unsigned short x1; unsigned short y1; unsigned short x2; unsigned short y2; }; /* * Drawable information. */ struct drm_drawable_info { unsigned int num_rects; struct drm_clip_rect *rects; }; /* * Texture region, */ struct drm_tex_region { unsigned char next; unsigned char prev; unsigned char in_use; unsigned char padding; unsigned int age; }; /* * Hardware lock. * * The lock structure is a simple cache-line aligned integer. To avoid * processor bus contention on a multiprocessor system, there should not be any * other data stored in the same cache line. */ struct drm_hw_lock { __volatile__ unsigned int lock; /**< lock variable */ char padding[60]; /**< Pad to cache line */ }; /* * DRM_IOCTL_VERSION ioctl argument type. * * \sa drmGetVersion(). */ struct drm_version { int version_major; /**< Major version */ int version_minor; /**< Minor version */ int version_patchlevel; /**< Patch level */ __kernel_size_t name_len; /**< Length of name buffer */ char *name; /**< Name of driver */ __kernel_size_t date_len; /**< Length of date buffer */ char *date; /**< User-space buffer to hold date */ __kernel_size_t desc_len; /**< Length of desc buffer */ char *desc; /**< User-space buffer to hold desc */ }; /* * DRM_IOCTL_GET_UNIQUE ioctl argument type. * * \sa drmGetBusid() and drmSetBusId(). */ struct drm_unique { __kernel_size_t unique_len; /**< Length of unique */ char *unique; /**< Unique name for driver instantiation */ }; struct drm_list { int count; /**< Length of user-space structures */ struct drm_version *version; }; struct drm_block { int unused; }; /* * DRM_IOCTL_CONTROL ioctl argument type. * * \sa drmCtlInstHandler() and drmCtlUninstHandler(). */ struct drm_control { enum { DRM_ADD_COMMAND, DRM_RM_COMMAND, DRM_INST_HANDLER, DRM_UNINST_HANDLER } func; int irq; }; /* * Type of memory to map. */ enum drm_map_type { _DRM_FRAME_BUFFER = 0, /**< WC (no caching), no core dump */ _DRM_REGISTERS = 1, /**< no caching, no core dump */ _DRM_SHM = 2, /**< shared, cached */ _DRM_AGP = 3, /**< AGP/GART */ _DRM_SCATTER_GATHER = 4, /**< Scatter/gather memory for PCI DMA */ _DRM_CONSISTENT = 5 /**< Consistent memory for PCI DMA */ }; /* * Memory mapping flags. */ enum drm_map_flags { _DRM_RESTRICTED = 0x01, /**< Cannot be mapped to user-virtual */ _DRM_READ_ONLY = 0x02, _DRM_LOCKED = 0x04, /**< shared, cached, locked */ _DRM_KERNEL = 0x08, /**< kernel requires access */ _DRM_WRITE_COMBINING = 0x10, /**< use write-combining if available */ _DRM_CONTAINS_LOCK = 0x20, /**< SHM page that contains lock */ _DRM_REMOVABLE = 0x40, /**< Removable mapping */ _DRM_DRIVER = 0x80 /**< Managed by driver */ }; struct drm_ctx_priv_map { unsigned int ctx_id; /**< Context requesting private mapping */ void *handle; /**< Handle of map */ }; /* * DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls * argument type. * * \sa drmAddMap(). */ struct drm_map { unsigned long offset; /**< Requested physical address (0 for SAREA)*/ unsigned long size; /**< Requested physical size (bytes) */ enum drm_map_type type; /**< Type of memory to map */ enum drm_map_flags flags; /**< Flags */ void *handle; /**< User-space: "Handle" to pass to mmap() */ /**< Kernel-space: kernel-virtual address */ int mtrr; /**< MTRR slot used */ /* Private data */ }; /* * DRM_IOCTL_GET_CLIENT ioctl argument type. */ struct drm_client { int idx; /**< Which client desired? */ int auth; /**< Is client authenticated? */ unsigned long pid; /**< Process ID */ unsigned long uid; /**< User ID */ unsigned long magic; /**< Magic */ unsigned long iocs; /**< Ioctl count */ }; enum drm_stat_type { _DRM_STAT_LOCK, _DRM_STAT_OPENS, _DRM_STAT_CLOSES, _DRM_STAT_IOCTLS, _DRM_STAT_LOCKS, _DRM_STAT_UNLOCKS, _DRM_STAT_VALUE, /**< Generic value */ _DRM_STAT_BYTE, /**< Generic byte counter (1024bytes/K) */ _DRM_STAT_COUNT, /**< Generic non-byte counter (1000/k) */ _DRM_STAT_IRQ, /**< IRQ */ _DRM_STAT_PRIMARY, /**< Primary DMA bytes */ _DRM_STAT_SECONDARY, /**< Secondary DMA bytes */ _DRM_STAT_DMA, /**< DMA */ _DRM_STAT_SPECIAL, /**< Special DMA (e.g., priority or polled) */ _DRM_STAT_MISSED /**< Missed DMA opportunity */ /* Add to the *END* of the list */ }; /* * DRM_IOCTL_GET_STATS ioctl argument type. */ struct drm_stats { unsigned long count; struct { unsigned long value; enum drm_stat_type type; } data[15]; }; /* * Hardware locking flags. */ enum drm_lock_flags { _DRM_LOCK_READY = 0x01, /**< Wait until hardware is ready for DMA */ _DRM_LOCK_QUIESCENT = 0x02, /**< Wait until hardware quiescent */ _DRM_LOCK_FLUSH = 0x04, /**< Flush this context's DMA queue first */ _DRM_LOCK_FLUSH_ALL = 0x08, /**< Flush all DMA queues first */ /* These *HALT* flags aren't supported yet -- they will be used to support the full-screen DGA-like mode. */ _DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */ _DRM_HALT_CUR_QUEUES = 0x20 /**< Halt all current queues */ }; /* * DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument type. * * \sa drmGetLock() and drmUnlock(). */ struct drm_lock { int context; enum drm_lock_flags flags; }; /* * DMA flags * * \warning * These values \e must match xf86drm.h. * * \sa drm_dma. */ enum drm_dma_flags { /* Flags for DMA buffer dispatch */ _DRM_DMA_BLOCK = 0x01, /**< * Block until buffer dispatched. * * \note The buffer may not yet have * been processed by the hardware -- * getting a hardware lock with the * hardware quiescent will ensure * that the buffer has been * processed. */ _DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */ _DRM_DMA_PRIORITY = 0x04, /**< High priority dispatch */ /* Flags for DMA buffer request */ _DRM_DMA_WAIT = 0x10, /**< Wait for free buffers */ _DRM_DMA_SMALLER_OK = 0x20, /**< Smaller-than-requested buffers OK */ _DRM_DMA_LARGER_OK = 0x40 /**< Larger-than-requested buffers OK */ }; /* * DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type. * * \sa drmAddBufs(). */ struct drm_buf_desc { int count; /**< Number of buffers of this size */ int size; /**< Size in bytes */ int low_mark; /**< Low water mark */ int high_mark; /**< High water mark */ enum { _DRM_PAGE_ALIGN = 0x01, /**< Align on page boundaries for DMA */ _DRM_AGP_BUFFER = 0x02, /**< Buffer is in AGP space */ _DRM_SG_BUFFER = 0x04, /**< Scatter/gather memory buffer */ _DRM_FB_BUFFER = 0x08, /**< Buffer is in frame buffer */ _DRM_PCI_BUFFER_RO = 0x10 /**< Map PCI DMA buffer read-only */ } flags; unsigned long agp_start; /**< * Start address of where the AGP buffers are * in the AGP aperture */ }; /* * DRM_IOCTL_INFO_BUFS ioctl argument type. */ struct drm_buf_info { int count; /**< Entries in list */ struct drm_buf_desc *list; }; /* * DRM_IOCTL_FREE_BUFS ioctl argument type. */ struct drm_buf_free { int count; int *list; }; /* * Buffer information * * \sa drm_buf_map. */ struct drm_buf_pub { int idx; /**< Index into the master buffer list */ int total; /**< Buffer size */ int used; /**< Amount of buffer in use (for DMA) */ void *address; /**< Address of buffer */ }; /* * DRM_IOCTL_MAP_BUFS ioctl argument type. */ struct drm_buf_map { int count; /**< Length of the buffer list */ #ifdef __cplusplus void *virt; #else void *virtual; /**< Mmap'd area in user-virtual */ #endif struct drm_buf_pub *list; /**< Buffer information */ }; /* * DRM_IOCTL_DMA ioctl argument type. * * Indices here refer to the offset into the buffer list in drm_buf_get. * * \sa drmDMA(). */ struct drm_dma { int context; /**< Context handle */ int send_count; /**< Number of buffers to send */ int *send_indices; /**< List of handles to buffers */ int *send_sizes; /**< Lengths of data to send */ enum drm_dma_flags flags; /**< Flags */ int request_count; /**< Number of buffers requested */ int request_size; /**< Desired size for buffers */ int *request_indices; /**< Buffer information */ int *request_sizes; int granted_count; /**< Number of buffers granted */ }; enum drm_ctx_flags { _DRM_CONTEXT_PRESERVED = 0x01, _DRM_CONTEXT_2DONLY = 0x02 }; /* * DRM_IOCTL_ADD_CTX ioctl argument type. * * \sa drmCreateContext() and drmDestroyContext(). */ struct drm_ctx { drm_context_t handle; enum drm_ctx_flags flags; }; /* * DRM_IOCTL_RES_CTX ioctl argument type. */ struct drm_ctx_res { int count; struct drm_ctx *contexts; }; /* * DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type. */ struct drm_draw { drm_drawable_t handle; }; /* * DRM_IOCTL_UPDATE_DRAW ioctl argument type. */ typedef enum { DRM_DRAWABLE_CLIPRECTS } drm_drawable_info_type_t; struct drm_update_draw { drm_drawable_t handle; unsigned int type; unsigned int num; unsigned long long data; }; /* * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type. */ struct drm_auth { drm_magic_t magic; }; /* * DRM_IOCTL_IRQ_BUSID ioctl argument type. * * \sa drmGetInterruptFromBusID(). */ struct drm_irq_busid { int irq; /**< IRQ number */ int busnum; /**< bus number */ int devnum; /**< device number */ int funcnum; /**< function number */ }; enum drm_vblank_seq_type { _DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */ _DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */ /* bits 1-6 are reserved for high crtcs */ _DRM_VBLANK_HIGH_CRTC_MASK = 0x0000003e, _DRM_VBLANK_EVENT = 0x4000000, /**< Send event instead of blocking */ _DRM_VBLANK_FLIP = 0x8000000, /**< Scheduled buffer swap should flip */ _DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for next vblank */ _DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */ _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking, unsupported */ }; #define _DRM_VBLANK_HIGH_CRTC_SHIFT 1 #define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE) #define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_EVENT | _DRM_VBLANK_SIGNAL | \ _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS) struct drm_wait_vblank_request { enum drm_vblank_seq_type type; unsigned int sequence; unsigned long signal; }; struct drm_wait_vblank_reply { enum drm_vblank_seq_type type; unsigned int sequence; long tval_sec; long tval_usec; }; /* * DRM_IOCTL_WAIT_VBLANK ioctl argument type. * * \sa drmWaitVBlank(). */ union drm_wait_vblank { struct drm_wait_vblank_request request; struct drm_wait_vblank_reply reply; }; #define _DRM_PRE_MODESET 1 #define _DRM_POST_MODESET 2 /* * DRM_IOCTL_MODESET_CTL ioctl argument type * * \sa drmModesetCtl(). */ struct drm_modeset_ctl { __u32 crtc; __u32 cmd; }; /* * DRM_IOCTL_AGP_ENABLE ioctl argument type. * * \sa drmAgpEnable(). */ struct drm_agp_mode { unsigned long mode; /**< AGP mode */ }; /* * DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type. * * \sa drmAgpAlloc() and drmAgpFree(). */ struct drm_agp_buffer { unsigned long size; /**< In bytes -- will round to page boundary */ unsigned long handle; /**< Used for binding / unbinding */ unsigned long type; /**< Type of memory to allocate */ unsigned long physical; /**< Physical used by i810 */ }; /* * DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type. * * \sa drmAgpBind() and drmAgpUnbind(). */ struct drm_agp_binding { unsigned long handle; /**< From drm_agp_buffer */ unsigned long offset; /**< In bytes -- will round to page boundary */ }; /* * DRM_IOCTL_AGP_INFO ioctl argument type. * * \sa drmAgpVersionMajor(), drmAgpVersionMinor(), drmAgpGetMode(), * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(), * drmAgpVendorId() and drmAgpDeviceId(). */ struct drm_agp_info { int agp_version_major; int agp_version_minor; unsigned long mode; unsigned long aperture_base; /* physical address */ unsigned long aperture_size; /* bytes */ unsigned long memory_allowed; /* bytes */ unsigned long memory_used; /* PCI information */ unsigned short id_vendor; unsigned short id_device; }; /* * DRM_IOCTL_SG_ALLOC ioctl argument type. */ struct drm_scatter_gather { unsigned long size; /**< In bytes -- will round to page boundary */ unsigned long handle; /**< Used for mapping / unmapping */ }; /* * DRM_IOCTL_SET_VERSION ioctl argument type. */ struct drm_set_version { int drm_di_major; int drm_di_minor; int drm_dd_major; int drm_dd_minor; }; /* DRM_IOCTL_GEM_CLOSE ioctl argument type */ struct drm_gem_close { /** Handle of the object to be closed. */ __u32 handle; __u32 pad; }; /* DRM_IOCTL_GEM_FLINK ioctl argument type */ struct drm_gem_flink { /** Handle for the object being named */ __u32 handle; /** Returned global name */ __u32 name; }; /* DRM_IOCTL_GEM_OPEN ioctl argument type */ struct drm_gem_open { /** Name of object being opened */ __u32 name; /** Returned handle for the object */ __u32 handle; /** Returned size of the object */ __u64 size; }; /** * DRM_CAP_DUMB_BUFFER * * If set to 1, the driver supports creating dumb buffers via the * &DRM_IOCTL_MODE_CREATE_DUMB ioctl. */ #define DRM_CAP_DUMB_BUFFER 0x1 /** * DRM_CAP_VBLANK_HIGH_CRTC * * If set to 1, the kernel supports specifying a :ref:`CRTC index` * in the high bits of &drm_wait_vblank_request.type. * * Starting kernel version 2.6.39, this capability is always set to 1. */ #define DRM_CAP_VBLANK_HIGH_CRTC 0x2 /** * DRM_CAP_DUMB_PREFERRED_DEPTH * * The preferred bit depth for dumb buffers. * * The bit depth is the number of bits used to indicate the color of a single * pixel excluding any padding. This is different from the number of bits per * pixel. For instance, XRGB8888 has a bit depth of 24 but has 32 bits per * pixel. * * Note that this preference only applies to dumb buffers, it's irrelevant for * other types of buffers. */ #define DRM_CAP_DUMB_PREFERRED_DEPTH 0x3 /** * DRM_CAP_DUMB_PREFER_SHADOW * * If set to 1, the driver prefers userspace to render to a shadow buffer * instead of directly rendering to a dumb buffer. For best speed, userspace * should do streaming ordered memory copies into the dumb buffer and never * read from it. * * Note that this preference only applies to dumb buffers, it's irrelevant for * other types of buffers. */ #define DRM_CAP_DUMB_PREFER_SHADOW 0x4 /** * DRM_CAP_PRIME * * Bitfield of supported PRIME sharing capabilities. See &DRM_PRIME_CAP_IMPORT * and &DRM_PRIME_CAP_EXPORT. * * Starting from kernel version 6.6, both &DRM_PRIME_CAP_IMPORT and * &DRM_PRIME_CAP_EXPORT are always advertised. * * PRIME buffers are exposed as dma-buf file descriptors. * See :ref:`prime_buffer_sharing`. */ #define DRM_CAP_PRIME 0x5 /** * DRM_PRIME_CAP_IMPORT * * If this bit is set in &DRM_CAP_PRIME, the driver supports importing PRIME * buffers via the &DRM_IOCTL_PRIME_FD_TO_HANDLE ioctl. * * Starting from kernel version 6.6, this bit is always set in &DRM_CAP_PRIME. */ #define DRM_PRIME_CAP_IMPORT 0x1 /** * DRM_PRIME_CAP_EXPORT * * If this bit is set in &DRM_CAP_PRIME, the driver supports exporting PRIME * buffers via the &DRM_IOCTL_PRIME_HANDLE_TO_FD ioctl. * * Starting from kernel version 6.6, this bit is always set in &DRM_CAP_PRIME. */ #define DRM_PRIME_CAP_EXPORT 0x2 /** * DRM_CAP_TIMESTAMP_MONOTONIC * * If set to 0, the kernel will report timestamps with ``CLOCK_REALTIME`` in * struct drm_event_vblank. If set to 1, the kernel will report timestamps with * ``CLOCK_MONOTONIC``. See ``clock_gettime(2)`` for the definition of these * clocks. * * Starting from kernel version 2.6.39, the default value for this capability * is 1. Starting kernel version 4.15, this capability is always set to 1. */ #define DRM_CAP_TIMESTAMP_MONOTONIC 0x6 /** * DRM_CAP_ASYNC_PAGE_FLIP * * If set to 1, the driver supports &DRM_MODE_PAGE_FLIP_ASYNC. */ #define DRM_CAP_ASYNC_PAGE_FLIP 0x7 /** * DRM_CAP_CURSOR_WIDTH * * The ``CURSOR_WIDTH`` and ``CURSOR_HEIGHT`` capabilities return a valid * width x height combination for the hardware cursor. The intention is that a * hardware agnostic userspace can query a cursor plane size to use. * * Note that the cross-driver contract is to merely return a valid size; * drivers are free to attach another meaning on top, eg. i915 returns the * maximum plane size. */ #define DRM_CAP_CURSOR_WIDTH 0x8 /** * DRM_CAP_CURSOR_HEIGHT * * See &DRM_CAP_CURSOR_WIDTH. */ #define DRM_CAP_CURSOR_HEIGHT 0x9 /** * DRM_CAP_ADDFB2_MODIFIERS * * If set to 1, the driver supports supplying modifiers in the * &DRM_IOCTL_MODE_ADDFB2 ioctl. */ #define DRM_CAP_ADDFB2_MODIFIERS 0x10 /** * DRM_CAP_PAGE_FLIP_TARGET * * If set to 1, the driver supports the &DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE and * &DRM_MODE_PAGE_FLIP_TARGET_RELATIVE flags in * &drm_mode_crtc_page_flip_target.flags for the &DRM_IOCTL_MODE_PAGE_FLIP * ioctl. */ #define DRM_CAP_PAGE_FLIP_TARGET 0x11 /** * DRM_CAP_CRTC_IN_VBLANK_EVENT * * If set to 1, the kernel supports reporting the CRTC ID in * &drm_event_vblank.crtc_id for the &DRM_EVENT_VBLANK and * &DRM_EVENT_FLIP_COMPLETE events. * * Starting kernel version 4.12, this capability is always set to 1. */ #define DRM_CAP_CRTC_IN_VBLANK_EVENT 0x12 /** * DRM_CAP_SYNCOBJ * * If set to 1, the driver supports sync objects. See :ref:`drm_sync_objects`. */ #define DRM_CAP_SYNCOBJ 0x13 /** * DRM_CAP_SYNCOBJ_TIMELINE * * If set to 1, the driver supports timeline operations on sync objects. See * :ref:`drm_sync_objects`. */ #define DRM_CAP_SYNCOBJ_TIMELINE 0x14 /* DRM_IOCTL_GET_CAP ioctl argument type */ struct drm_get_cap { __u64 capability; __u64 value; }; /** * DRM_CLIENT_CAP_STEREO_3D * * If set to 1, the DRM core will expose the stereo 3D capabilities of the * monitor by advertising the supported 3D layouts in the flags of struct * drm_mode_modeinfo. See ``DRM_MODE_FLAG_3D_*``. * * This capability is always supported for all drivers starting from kernel * version 3.13. */ #define DRM_CLIENT_CAP_STEREO_3D 1 /** * DRM_CLIENT_CAP_UNIVERSAL_PLANES * * If set to 1, the DRM core will expose all planes (overlay, primary, and * cursor) to userspace. * * This capability has been introduced in kernel version 3.15. Starting from * kernel version 3.17, this capability is always supported for all drivers. */ #define DRM_CLIENT_CAP_UNIVERSAL_PLANES 2 /** * DRM_CLIENT_CAP_ATOMIC * * If set to 1, the DRM core will expose atomic properties to userspace. This * implicitly enables &DRM_CLIENT_CAP_UNIVERSAL_PLANES and * &DRM_CLIENT_CAP_ASPECT_RATIO. * * If the driver doesn't support atomic mode-setting, enabling this capability * will fail with -EOPNOTSUPP. * * This capability has been introduced in kernel version 4.0. Starting from * kernel version 4.2, this capability is always supported for atomic-capable * drivers. */ #define DRM_CLIENT_CAP_ATOMIC 3 /** * DRM_CLIENT_CAP_ASPECT_RATIO * * If set to 1, the DRM core will provide aspect ratio information in modes. * See ``DRM_MODE_FLAG_PIC_AR_*``. * * This capability is always supported for all drivers starting from kernel * version 4.18. */ #define DRM_CLIENT_CAP_ASPECT_RATIO 4 /** * DRM_CLIENT_CAP_WRITEBACK_CONNECTORS * * If set to 1, the DRM core will expose special connectors to be used for * writing back to memory the scene setup in the commit. The client must enable * &DRM_CLIENT_CAP_ATOMIC first. * * This capability is always supported for atomic-capable drivers starting from * kernel version 4.19. */ #define DRM_CLIENT_CAP_WRITEBACK_CONNECTORS 5 /* DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */ struct drm_set_client_cap { __u64 capability; __u64 value; }; #define DRM_RDWR O_RDWR #define DRM_CLOEXEC O_CLOEXEC struct drm_prime_handle { __u32 handle; /** Flags.. only applicable for handle->fd */ __u32 flags; /** Returned dmabuf file descriptor */ __s32 fd; }; struct drm_syncobj_create { __u32 handle; #define DRM_SYNCOBJ_CREATE_SIGNALED (1 << 0) __u32 flags; }; struct drm_syncobj_destroy { __u32 handle; __u32 pad; }; #define DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE (1 << 0) #define DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE (1 << 0) struct drm_syncobj_handle { __u32 handle; __u32 flags; __s32 fd; __u32 pad; }; struct drm_syncobj_transfer { __u32 src_handle; __u32 dst_handle; __u64 src_point; __u64 dst_point; __u32 flags; __u32 pad; }; #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL (1 << 0) #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT (1 << 1) #define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE (1 << 2) /* wait for time point to become available */ struct drm_syncobj_wait { __u64 handles; /* absolute timeout */ __s64 timeout_nsec; __u32 count_handles; __u32 flags; __u32 first_signaled; /* only valid when not waiting all */ __u32 pad; }; struct drm_syncobj_timeline_wait { __u64 handles; /* wait on specific timeline point for every handles*/ __u64 points; /* absolute timeout */ __s64 timeout_nsec; __u32 count_handles; __u32 flags; __u32 first_signaled; /* only valid when not waiting all */ __u32 pad; }; /** * struct drm_syncobj_eventfd * @handle: syncobj handle. * @flags: Zero to wait for the point to be signalled, or * &DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE to wait for a fence to be * available for the point. * @point: syncobj timeline point (set to zero for binary syncobjs). * @fd: Existing eventfd to sent events to. * @pad: Must be zero. * * Register an eventfd to be signalled by a syncobj. The eventfd counter will * be incremented by one. */ struct drm_syncobj_eventfd { __u32 handle; __u32 flags; __u64 point; __s32 fd; __u32 pad; }; struct drm_syncobj_array { __u64 handles; __u32 count_handles; __u32 pad; }; #define DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED (1 << 0) /* last available point on timeline syncobj */ struct drm_syncobj_timeline_array { __u64 handles; __u64 points; __u32 count_handles; __u32 flags; }; /* Query current scanout sequence number */ struct drm_crtc_get_sequence { __u32 crtc_id; /* requested crtc_id */ __u32 active; /* return: crtc output is active */ __u64 sequence; /* return: most recent vblank sequence */ __s64 sequence_ns; /* return: most recent time of first pixel out */ }; /* Queue event to be delivered at specified sequence. Time stamp marks * when the first pixel of the refresh cycle leaves the display engine * for the display */ #define DRM_CRTC_SEQUENCE_RELATIVE 0x00000001 /* sequence is relative to current */ #define DRM_CRTC_SEQUENCE_NEXT_ON_MISS 0x00000002 /* Use next sequence if we've missed */ struct drm_crtc_queue_sequence { __u32 crtc_id; __u32 flags; __u64 sequence; /* on input, target sequence. on output, actual sequence */ __u64 user_data; /* user data passed to event */ }; #if defined(__cplusplus) } #endif #include "drm_mode.h" #if defined(__cplusplus) extern "C" { #endif #define DRM_IOCTL_BASE 'd' #define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr) #define DRM_IOR(nr,type) _IOR(DRM_IOCTL_BASE,nr,type) #define DRM_IOW(nr,type) _IOW(DRM_IOCTL_BASE,nr,type) #define DRM_IOWR(nr,type) _IOWR(DRM_IOCTL_BASE,nr,type) #define DRM_IOCTL_VERSION DRM_IOWR(0x00, struct drm_version) #define DRM_IOCTL_GET_UNIQUE DRM_IOWR(0x01, struct drm_unique) #define DRM_IOCTL_GET_MAGIC DRM_IOR( 0x02, struct drm_auth) #define DRM_IOCTL_IRQ_BUSID DRM_IOWR(0x03, struct drm_irq_busid) #define DRM_IOCTL_GET_MAP DRM_IOWR(0x04, struct drm_map) #define DRM_IOCTL_GET_CLIENT DRM_IOWR(0x05, struct drm_client) #define DRM_IOCTL_GET_STATS DRM_IOR( 0x06, struct drm_stats) #define DRM_IOCTL_SET_VERSION DRM_IOWR(0x07, struct drm_set_version) #define DRM_IOCTL_MODESET_CTL DRM_IOW(0x08, struct drm_modeset_ctl) /** * DRM_IOCTL_GEM_CLOSE - Close a GEM handle. * * GEM handles are not reference-counted by the kernel. User-space is * responsible for managing their lifetime. For example, if user-space imports * the same memory object twice on the same DRM file description, the same GEM * handle is returned by both imports, and user-space needs to ensure * &DRM_IOCTL_GEM_CLOSE is performed once only. The same situation can happen * when a memory object is allocated, then exported and imported again on the * same DRM file description. The &DRM_IOCTL_MODE_GETFB2 IOCTL is an exception * and always returns fresh new GEM handles even if an existing GEM handle * already refers to the same memory object before the IOCTL is performed. */ #define DRM_IOCTL_GEM_CLOSE DRM_IOW (0x09, struct drm_gem_close) #define DRM_IOCTL_GEM_FLINK DRM_IOWR(0x0a, struct drm_gem_flink) #define DRM_IOCTL_GEM_OPEN DRM_IOWR(0x0b, struct drm_gem_open) #define DRM_IOCTL_GET_CAP DRM_IOWR(0x0c, struct drm_get_cap) #define DRM_IOCTL_SET_CLIENT_CAP DRM_IOW( 0x0d, struct drm_set_client_cap) #define DRM_IOCTL_SET_UNIQUE DRM_IOW( 0x10, struct drm_unique) #define DRM_IOCTL_AUTH_MAGIC DRM_IOW( 0x11, struct drm_auth) #define DRM_IOCTL_BLOCK DRM_IOWR(0x12, struct drm_block) #define DRM_IOCTL_UNBLOCK DRM_IOWR(0x13, struct drm_block) #define DRM_IOCTL_CONTROL DRM_IOW( 0x14, struct drm_control) #define DRM_IOCTL_ADD_MAP DRM_IOWR(0x15, struct drm_map) #define DRM_IOCTL_ADD_BUFS DRM_IOWR(0x16, struct drm_buf_desc) #define DRM_IOCTL_MARK_BUFS DRM_IOW( 0x17, struct drm_buf_desc) #define DRM_IOCTL_INFO_BUFS DRM_IOWR(0x18, struct drm_buf_info) #define DRM_IOCTL_MAP_BUFS DRM_IOWR(0x19, struct drm_buf_map) #define DRM_IOCTL_FREE_BUFS DRM_IOW( 0x1a, struct drm_buf_free) #define DRM_IOCTL_RM_MAP DRM_IOW( 0x1b, struct drm_map) #define DRM_IOCTL_SET_SAREA_CTX DRM_IOW( 0x1c, struct drm_ctx_priv_map) #define DRM_IOCTL_GET_SAREA_CTX DRM_IOWR(0x1d, struct drm_ctx_priv_map) #define DRM_IOCTL_SET_MASTER DRM_IO(0x1e) #define DRM_IOCTL_DROP_MASTER DRM_IO(0x1f) #define DRM_IOCTL_ADD_CTX DRM_IOWR(0x20, struct drm_ctx) #define DRM_IOCTL_RM_CTX DRM_IOWR(0x21, struct drm_ctx) #define DRM_IOCTL_MOD_CTX DRM_IOW( 0x22, struct drm_ctx) #define DRM_IOCTL_GET_CTX DRM_IOWR(0x23, struct drm_ctx) #define DRM_IOCTL_SWITCH_CTX DRM_IOW( 0x24, struct drm_ctx) #define DRM_IOCTL_NEW_CTX DRM_IOW( 0x25, struct drm_ctx) #define DRM_IOCTL_RES_CTX DRM_IOWR(0x26, struct drm_ctx_res) #define DRM_IOCTL_ADD_DRAW DRM_IOWR(0x27, struct drm_draw) #define DRM_IOCTL_RM_DRAW DRM_IOWR(0x28, struct drm_draw) #define DRM_IOCTL_DMA DRM_IOWR(0x29, struct drm_dma) #define DRM_IOCTL_LOCK DRM_IOW( 0x2a, struct drm_lock) #define DRM_IOCTL_UNLOCK DRM_IOW( 0x2b, struct drm_lock) #define DRM_IOCTL_FINISH DRM_IOW( 0x2c, struct drm_lock) /** * DRM_IOCTL_PRIME_HANDLE_TO_FD - Convert a GEM handle to a DMA-BUF FD. * * User-space sets &drm_prime_handle.handle with the GEM handle to export and * &drm_prime_handle.flags, and gets back a DMA-BUF file descriptor in * &drm_prime_handle.fd. * * The export can fail for any driver-specific reason, e.g. because export is * not supported for this specific GEM handle (but might be for others). * * Support for exporting DMA-BUFs is advertised via &DRM_PRIME_CAP_EXPORT. */ #define DRM_IOCTL_PRIME_HANDLE_TO_FD DRM_IOWR(0x2d, struct drm_prime_handle) /** * DRM_IOCTL_PRIME_FD_TO_HANDLE - Convert a DMA-BUF FD to a GEM handle. * * User-space sets &drm_prime_handle.fd with a DMA-BUF file descriptor to * import, and gets back a GEM handle in &drm_prime_handle.handle. * &drm_prime_handle.flags is unused. * * If an existing GEM handle refers to the memory object backing the DMA-BUF, * that GEM handle is returned. Therefore user-space which needs to handle * arbitrary DMA-BUFs must have a user-space lookup data structure to manually * reference-count duplicated GEM handles. For more information see * &DRM_IOCTL_GEM_CLOSE. * * The import can fail for any driver-specific reason, e.g. because import is * only supported for DMA-BUFs allocated on this DRM device. * * Support for importing DMA-BUFs is advertised via &DRM_PRIME_CAP_IMPORT. */ #define DRM_IOCTL_PRIME_FD_TO_HANDLE DRM_IOWR(0x2e, struct drm_prime_handle) #define DRM_IOCTL_AGP_ACQUIRE DRM_IO( 0x30) #define DRM_IOCTL_AGP_RELEASE DRM_IO( 0x31) #define DRM_IOCTL_AGP_ENABLE DRM_IOW( 0x32, struct drm_agp_mode) #define DRM_IOCTL_AGP_INFO DRM_IOR( 0x33, struct drm_agp_info) #define DRM_IOCTL_AGP_ALLOC DRM_IOWR(0x34, struct drm_agp_buffer) #define DRM_IOCTL_AGP_FREE DRM_IOW( 0x35, struct drm_agp_buffer) #define DRM_IOCTL_AGP_BIND DRM_IOW( 0x36, struct drm_agp_binding) #define DRM_IOCTL_AGP_UNBIND DRM_IOW( 0x37, struct drm_agp_binding) #define DRM_IOCTL_SG_ALLOC DRM_IOWR(0x38, struct drm_scatter_gather) #define DRM_IOCTL_SG_FREE DRM_IOW( 0x39, struct drm_scatter_gather) #define DRM_IOCTL_WAIT_VBLANK DRM_IOWR(0x3a, union drm_wait_vblank) #define DRM_IOCTL_CRTC_GET_SEQUENCE DRM_IOWR(0x3b, struct drm_crtc_get_sequence) #define DRM_IOCTL_CRTC_QUEUE_SEQUENCE DRM_IOWR(0x3c, struct drm_crtc_queue_sequence) #define DRM_IOCTL_UPDATE_DRAW DRM_IOW(0x3f, struct drm_update_draw) #define DRM_IOCTL_MODE_GETRESOURCES DRM_IOWR(0xA0, struct drm_mode_card_res) #define DRM_IOCTL_MODE_GETCRTC DRM_IOWR(0xA1, struct drm_mode_crtc) #define DRM_IOCTL_MODE_SETCRTC DRM_IOWR(0xA2, struct drm_mode_crtc) #define DRM_IOCTL_MODE_CURSOR DRM_IOWR(0xA3, struct drm_mode_cursor) #define DRM_IOCTL_MODE_GETGAMMA DRM_IOWR(0xA4, struct drm_mode_crtc_lut) #define DRM_IOCTL_MODE_SETGAMMA DRM_IOWR(0xA5, struct drm_mode_crtc_lut) #define DRM_IOCTL_MODE_GETENCODER DRM_IOWR(0xA6, struct drm_mode_get_encoder) #define DRM_IOCTL_MODE_GETCONNECTOR DRM_IOWR(0xA7, struct drm_mode_get_connector) #define DRM_IOCTL_MODE_ATTACHMODE DRM_IOWR(0xA8, struct drm_mode_mode_cmd) /* deprecated (never worked) */ #define DRM_IOCTL_MODE_DETACHMODE DRM_IOWR(0xA9, struct drm_mode_mode_cmd) /* deprecated (never worked) */ #define DRM_IOCTL_MODE_GETPROPERTY DRM_IOWR(0xAA, struct drm_mode_get_property) #define DRM_IOCTL_MODE_SETPROPERTY DRM_IOWR(0xAB, struct drm_mode_connector_set_property) #define DRM_IOCTL_MODE_GETPROPBLOB DRM_IOWR(0xAC, struct drm_mode_get_blob) #define DRM_IOCTL_MODE_GETFB DRM_IOWR(0xAD, struct drm_mode_fb_cmd) #define DRM_IOCTL_MODE_ADDFB DRM_IOWR(0xAE, struct drm_mode_fb_cmd) /** * DRM_IOCTL_MODE_RMFB - Remove a framebuffer. * * This removes a framebuffer previously added via ADDFB/ADDFB2. The IOCTL * argument is a framebuffer object ID. * * Warning: removing a framebuffer currently in-use on an enabled plane will * disable that plane. The CRTC the plane is linked to may also be disabled * (depending on driver capabilities). */ #define DRM_IOCTL_MODE_RMFB DRM_IOWR(0xAF, unsigned int) #define DRM_IOCTL_MODE_PAGE_FLIP DRM_IOWR(0xB0, struct drm_mode_crtc_page_flip) #define DRM_IOCTL_MODE_DIRTYFB DRM_IOWR(0xB1, struct drm_mode_fb_dirty_cmd) #define DRM_IOCTL_MODE_CREATE_DUMB DRM_IOWR(0xB2, struct drm_mode_create_dumb) #define DRM_IOCTL_MODE_MAP_DUMB DRM_IOWR(0xB3, struct drm_mode_map_dumb) #define DRM_IOCTL_MODE_DESTROY_DUMB DRM_IOWR(0xB4, struct drm_mode_destroy_dumb) #define DRM_IOCTL_MODE_GETPLANERESOURCES DRM_IOWR(0xB5, struct drm_mode_get_plane_res) #define DRM_IOCTL_MODE_GETPLANE DRM_IOWR(0xB6, struct drm_mode_get_plane) #define DRM_IOCTL_MODE_SETPLANE DRM_IOWR(0xB7, struct drm_mode_set_plane) #define DRM_IOCTL_MODE_ADDFB2 DRM_IOWR(0xB8, struct drm_mode_fb_cmd2) #define DRM_IOCTL_MODE_OBJ_GETPROPERTIES DRM_IOWR(0xB9, struct drm_mode_obj_get_properties) #define DRM_IOCTL_MODE_OBJ_SETPROPERTY DRM_IOWR(0xBA, struct drm_mode_obj_set_property) #define DRM_IOCTL_MODE_CURSOR2 DRM_IOWR(0xBB, struct drm_mode_cursor2) #define DRM_IOCTL_MODE_ATOMIC DRM_IOWR(0xBC, struct drm_mode_atomic) #define DRM_IOCTL_MODE_CREATEPROPBLOB DRM_IOWR(0xBD, struct drm_mode_create_blob) #define DRM_IOCTL_MODE_DESTROYPROPBLOB DRM_IOWR(0xBE, struct drm_mode_destroy_blob) #define DRM_IOCTL_SYNCOBJ_CREATE DRM_IOWR(0xBF, struct drm_syncobj_create) #define DRM_IOCTL_SYNCOBJ_DESTROY DRM_IOWR(0xC0, struct drm_syncobj_destroy) #define DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD DRM_IOWR(0xC1, struct drm_syncobj_handle) #define DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE DRM_IOWR(0xC2, struct drm_syncobj_handle) #define DRM_IOCTL_SYNCOBJ_WAIT DRM_IOWR(0xC3, struct drm_syncobj_wait) #define DRM_IOCTL_SYNCOBJ_RESET DRM_IOWR(0xC4, struct drm_syncobj_array) #define DRM_IOCTL_SYNCOBJ_SIGNAL DRM_IOWR(0xC5, struct drm_syncobj_array) #define DRM_IOCTL_MODE_CREATE_LEASE DRM_IOWR(0xC6, struct drm_mode_create_lease) #define DRM_IOCTL_MODE_LIST_LESSEES DRM_IOWR(0xC7, struct drm_mode_list_lessees) #define DRM_IOCTL_MODE_GET_LEASE DRM_IOWR(0xC8, struct drm_mode_get_lease) #define DRM_IOCTL_MODE_REVOKE_LEASE DRM_IOWR(0xC9, struct drm_mode_revoke_lease) #define DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT DRM_IOWR(0xCA, struct drm_syncobj_timeline_wait) #define DRM_IOCTL_SYNCOBJ_QUERY DRM_IOWR(0xCB, struct drm_syncobj_timeline_array) #define DRM_IOCTL_SYNCOBJ_TRANSFER DRM_IOWR(0xCC, struct drm_syncobj_transfer) #define DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL DRM_IOWR(0xCD, struct drm_syncobj_timeline_array) /** * DRM_IOCTL_MODE_GETFB2 - Get framebuffer metadata. * * This queries metadata about a framebuffer. User-space fills * &drm_mode_fb_cmd2.fb_id as the input, and the kernels fills the rest of the * struct as the output. * * If the client is DRM master or has &CAP_SYS_ADMIN, &drm_mode_fb_cmd2.handles * will be filled with GEM buffer handles. Fresh new GEM handles are always * returned, even if another GEM handle referring to the same memory object * already exists on the DRM file description. The caller is responsible for * removing the new handles, e.g. via the &DRM_IOCTL_GEM_CLOSE IOCTL. The same * new handle will be returned for multiple planes in case they use the same * memory object. Planes are valid until one has a zero handle -- this can be * used to compute the number of planes. * * Otherwise, &drm_mode_fb_cmd2.handles will be zeroed and planes are valid * until one has a zero &drm_mode_fb_cmd2.pitches. * * If the framebuffer has a format modifier, &DRM_MODE_FB_MODIFIERS will be set * in &drm_mode_fb_cmd2.flags and &drm_mode_fb_cmd2.modifier will contain the * modifier. Otherwise, user-space must ignore &drm_mode_fb_cmd2.modifier. * * To obtain DMA-BUF FDs for each plane without leaking GEM handles, user-space * can export each handle via &DRM_IOCTL_PRIME_HANDLE_TO_FD, then immediately * close each unique handle via &DRM_IOCTL_GEM_CLOSE, making sure to not * double-close handles which are specified multiple times in the array. */ #define DRM_IOCTL_MODE_GETFB2 DRM_IOWR(0xCE, struct drm_mode_fb_cmd2) #define DRM_IOCTL_SYNCOBJ_EVENTFD DRM_IOWR(0xCF, struct drm_syncobj_eventfd) /* * Device specific ioctls should only be in their respective headers * The device specific ioctl range is from 0x40 to 0x9f. * Generic IOCTLS restart at 0xA0. * * \sa drmCommandNone(), drmCommandRead(), drmCommandWrite(), and * drmCommandReadWrite(). */ #define DRM_COMMAND_BASE 0x40 #define DRM_COMMAND_END 0xA0 /** * struct drm_event - Header for DRM events * @type: event type. * @length: total number of payload bytes (including header). * * This struct is a header for events written back to user-space on the DRM FD. * A read on the DRM FD will always only return complete events: e.g. if the * read buffer is 100 bytes large and there are two 64 byte events pending, * only one will be returned. * * Event types 0 - 0x7fffffff are generic DRM events, 0x80000000 and * up are chipset specific. Generic DRM events include &DRM_EVENT_VBLANK, * &DRM_EVENT_FLIP_COMPLETE and &DRM_EVENT_CRTC_SEQUENCE. */ struct drm_event { __u32 type; __u32 length; }; /** * DRM_EVENT_VBLANK - vertical blanking event * * This event is sent in response to &DRM_IOCTL_WAIT_VBLANK with the * &_DRM_VBLANK_EVENT flag set. * * The event payload is a struct drm_event_vblank. */ #define DRM_EVENT_VBLANK 0x01 /** * DRM_EVENT_FLIP_COMPLETE - page-flip completion event * * This event is sent in response to an atomic commit or legacy page-flip with * the &DRM_MODE_PAGE_FLIP_EVENT flag set. * * The event payload is a struct drm_event_vblank. */ #define DRM_EVENT_FLIP_COMPLETE 0x02 /** * DRM_EVENT_CRTC_SEQUENCE - CRTC sequence event * * This event is sent in response to &DRM_IOCTL_CRTC_QUEUE_SEQUENCE. * * The event payload is a struct drm_event_crtc_sequence. */ #define DRM_EVENT_CRTC_SEQUENCE 0x03 struct drm_event_vblank { struct drm_event base; __u64 user_data; __u32 tv_sec; __u32 tv_usec; __u32 sequence; __u32 crtc_id; /* 0 on older kernels that do not support this */ }; /* Event delivered at sequence. Time stamp marks when the first pixel * of the refresh cycle leaves the display engine for the display */ struct drm_event_crtc_sequence { struct drm_event base; __u64 user_data; __s64 time_ns; __u64 sequence; }; /* typedef area */ typedef struct drm_clip_rect drm_clip_rect_t; typedef struct drm_drawable_info drm_drawable_info_t; typedef struct drm_tex_region drm_tex_region_t; typedef struct drm_hw_lock drm_hw_lock_t; typedef struct drm_version drm_version_t; typedef struct drm_unique drm_unique_t; typedef struct drm_list drm_list_t; typedef struct drm_block drm_block_t; typedef struct drm_control drm_control_t; typedef enum drm_map_type drm_map_type_t; typedef enum drm_map_flags drm_map_flags_t; typedef struct drm_ctx_priv_map drm_ctx_priv_map_t; typedef struct drm_map drm_map_t; typedef struct drm_client drm_client_t; typedef enum drm_stat_type drm_stat_type_t; typedef struct drm_stats drm_stats_t; typedef enum drm_lock_flags drm_lock_flags_t; typedef struct drm_lock drm_lock_t; typedef enum drm_dma_flags drm_dma_flags_t; typedef struct drm_buf_desc drm_buf_desc_t; typedef struct drm_buf_info drm_buf_info_t; typedef struct drm_buf_free drm_buf_free_t; typedef struct drm_buf_pub drm_buf_pub_t; typedef struct drm_buf_map drm_buf_map_t; typedef struct drm_dma drm_dma_t; typedef union drm_wait_vblank drm_wait_vblank_t; typedef struct drm_agp_mode drm_agp_mode_t; typedef enum drm_ctx_flags drm_ctx_flags_t; typedef struct drm_ctx drm_ctx_t; typedef struct drm_ctx_res drm_ctx_res_t; typedef struct drm_draw drm_draw_t; typedef struct drm_update_draw drm_update_draw_t; typedef struct drm_auth drm_auth_t; typedef struct drm_irq_busid drm_irq_busid_t; typedef enum drm_vblank_seq_type drm_vblank_seq_type_t; typedef struct drm_agp_buffer drm_agp_buffer_t; typedef struct drm_agp_binding drm_agp_binding_t; typedef struct drm_agp_info drm_agp_info_t; typedef struct drm_scatter_gather drm_scatter_gather_t; typedef struct drm_set_version drm_set_version_t; #if defined(__cplusplus) } #endif #endif aristocratos-btop-d43a485/src/linux/intel_gpu_top/drm_mode.h000066400000000000000000001161221517514752700243050ustar00rootroot00000000000000/* * Copyright (c) 2007 Dave Airlie * Copyright (c) 2007 Jakob Bornecrantz * Copyright (c) 2008 Red Hat Inc. * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, TX., USA * Copyright (c) 2007-2008 Intel Corporation * * 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 _DRM_MODE_H #define _DRM_MODE_H #include "drm.h" #if defined(__cplusplus) extern "C" { #endif /** * DOC: overview * * DRM exposes many UAPI and structure definition to have a consistent * and standardized interface with user. * Userspace can refer to these structure definitions and UAPI formats * to communicate to driver */ #define DRM_CONNECTOR_NAME_LEN 32 #define DRM_DISPLAY_MODE_LEN 32 #define DRM_PROP_NAME_LEN 32 #define DRM_MODE_TYPE_BUILTIN (1<<0) /* deprecated */ #define DRM_MODE_TYPE_CLOCK_C ((1<<1) | DRM_MODE_TYPE_BUILTIN) /* deprecated */ #define DRM_MODE_TYPE_CRTC_C ((1<<2) | DRM_MODE_TYPE_BUILTIN) /* deprecated */ #define DRM_MODE_TYPE_PREFERRED (1<<3) #define DRM_MODE_TYPE_DEFAULT (1<<4) /* deprecated */ #define DRM_MODE_TYPE_USERDEF (1<<5) #define DRM_MODE_TYPE_DRIVER (1<<6) #define DRM_MODE_TYPE_ALL (DRM_MODE_TYPE_PREFERRED | \ DRM_MODE_TYPE_USERDEF | \ DRM_MODE_TYPE_DRIVER) /* Video mode flags */ /* bit compatible with the xrandr RR_ definitions (bits 0-13) * * ABI warning: Existing userspace really expects * the mode flags to match the xrandr definitions. Any * changes that don't match the xrandr definitions will * likely need a new client cap or some other mechanism * to avoid breaking existing userspace. This includes * allocating new flags in the previously unused bits! */ #define DRM_MODE_FLAG_PHSYNC (1<<0) #define DRM_MODE_FLAG_NHSYNC (1<<1) #define DRM_MODE_FLAG_PVSYNC (1<<2) #define DRM_MODE_FLAG_NVSYNC (1<<3) #define DRM_MODE_FLAG_INTERLACE (1<<4) #define DRM_MODE_FLAG_DBLSCAN (1<<5) #define DRM_MODE_FLAG_CSYNC (1<<6) #define DRM_MODE_FLAG_PCSYNC (1<<7) #define DRM_MODE_FLAG_NCSYNC (1<<8) #define DRM_MODE_FLAG_HSKEW (1<<9) /* hskew provided */ #define DRM_MODE_FLAG_BCAST (1<<10) /* deprecated */ #define DRM_MODE_FLAG_PIXMUX (1<<11) /* deprecated */ #define DRM_MODE_FLAG_DBLCLK (1<<12) #define DRM_MODE_FLAG_CLKDIV2 (1<<13) /* * When adding a new stereo mode don't forget to adjust DRM_MODE_FLAGS_3D_MAX * (define not exposed to user space). */ #define DRM_MODE_FLAG_3D_MASK (0x1f<<14) #define DRM_MODE_FLAG_3D_NONE (0<<14) #define DRM_MODE_FLAG_3D_FRAME_PACKING (1<<14) #define DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE (2<<14) #define DRM_MODE_FLAG_3D_LINE_ALTERNATIVE (3<<14) #define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL (4<<14) #define DRM_MODE_FLAG_3D_L_DEPTH (5<<14) #define DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH (6<<14) #define DRM_MODE_FLAG_3D_TOP_AND_BOTTOM (7<<14) #define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF (8<<14) /* Picture aspect ratio options */ #define DRM_MODE_PICTURE_ASPECT_NONE 0 #define DRM_MODE_PICTURE_ASPECT_4_3 1 #define DRM_MODE_PICTURE_ASPECT_16_9 2 #define DRM_MODE_PICTURE_ASPECT_64_27 3 #define DRM_MODE_PICTURE_ASPECT_256_135 4 /* Content type options */ #define DRM_MODE_CONTENT_TYPE_NO_DATA 0 #define DRM_MODE_CONTENT_TYPE_GRAPHICS 1 #define DRM_MODE_CONTENT_TYPE_PHOTO 2 #define DRM_MODE_CONTENT_TYPE_CINEMA 3 #define DRM_MODE_CONTENT_TYPE_GAME 4 /* Aspect ratio flag bitmask (4 bits 22:19) */ #define DRM_MODE_FLAG_PIC_AR_MASK (0x0F<<19) #define DRM_MODE_FLAG_PIC_AR_NONE \ (DRM_MODE_PICTURE_ASPECT_NONE<<19) #define DRM_MODE_FLAG_PIC_AR_4_3 \ (DRM_MODE_PICTURE_ASPECT_4_3<<19) #define DRM_MODE_FLAG_PIC_AR_16_9 \ (DRM_MODE_PICTURE_ASPECT_16_9<<19) #define DRM_MODE_FLAG_PIC_AR_64_27 \ (DRM_MODE_PICTURE_ASPECT_64_27<<19) #define DRM_MODE_FLAG_PIC_AR_256_135 \ (DRM_MODE_PICTURE_ASPECT_256_135<<19) #define DRM_MODE_FLAG_ALL (DRM_MODE_FLAG_PHSYNC | \ DRM_MODE_FLAG_NHSYNC | \ DRM_MODE_FLAG_PVSYNC | \ DRM_MODE_FLAG_NVSYNC | \ DRM_MODE_FLAG_INTERLACE | \ DRM_MODE_FLAG_DBLSCAN | \ DRM_MODE_FLAG_CSYNC | \ DRM_MODE_FLAG_PCSYNC | \ DRM_MODE_FLAG_NCSYNC | \ DRM_MODE_FLAG_HSKEW | \ DRM_MODE_FLAG_DBLCLK | \ DRM_MODE_FLAG_CLKDIV2 | \ DRM_MODE_FLAG_3D_MASK) /* DPMS flags */ /* bit compatible with the xorg definitions. */ #define DRM_MODE_DPMS_ON 0 #define DRM_MODE_DPMS_STANDBY 1 #define DRM_MODE_DPMS_SUSPEND 2 #define DRM_MODE_DPMS_OFF 3 /* Scaling mode options */ #define DRM_MODE_SCALE_NONE 0 /* Unmodified timing (display or software can still scale) */ #define DRM_MODE_SCALE_FULLSCREEN 1 /* Full screen, ignore aspect */ #define DRM_MODE_SCALE_CENTER 2 /* Centered, no scaling */ #define DRM_MODE_SCALE_ASPECT 3 /* Full screen, preserve aspect */ /* Dithering mode options */ #define DRM_MODE_DITHERING_OFF 0 #define DRM_MODE_DITHERING_ON 1 #define DRM_MODE_DITHERING_AUTO 2 /* Dirty info options */ #define DRM_MODE_DIRTY_OFF 0 #define DRM_MODE_DIRTY_ON 1 #define DRM_MODE_DIRTY_ANNOTATE 2 /* Link Status options */ #define DRM_MODE_LINK_STATUS_GOOD 0 #define DRM_MODE_LINK_STATUS_BAD 1 /* * DRM_MODE_ROTATE_ * * Signals that a drm plane is been rotated degrees in counter * clockwise direction. * * This define is provided as a convenience, looking up the property id * using the name->prop id lookup is the preferred method. */ #define DRM_MODE_ROTATE_0 (1<<0) #define DRM_MODE_ROTATE_90 (1<<1) #define DRM_MODE_ROTATE_180 (1<<2) #define DRM_MODE_ROTATE_270 (1<<3) /* * DRM_MODE_ROTATE_MASK * * Bitmask used to look for drm plane rotations. */ #define DRM_MODE_ROTATE_MASK (\ DRM_MODE_ROTATE_0 | \ DRM_MODE_ROTATE_90 | \ DRM_MODE_ROTATE_180 | \ DRM_MODE_ROTATE_270) /* * DRM_MODE_REFLECT_ * * Signals that the contents of a drm plane is reflected along the axis, * in the same way as mirroring. * See kerneldoc chapter "Plane Composition Properties" for more details. * * This define is provided as a convenience, looking up the property id * using the name->prop id lookup is the preferred method. */ #define DRM_MODE_REFLECT_X (1<<4) #define DRM_MODE_REFLECT_Y (1<<5) /* * DRM_MODE_REFLECT_MASK * * Bitmask used to look for drm plane reflections. */ #define DRM_MODE_REFLECT_MASK (\ DRM_MODE_REFLECT_X | \ DRM_MODE_REFLECT_Y) /* Content Protection Flags */ #define DRM_MODE_CONTENT_PROTECTION_UNDESIRED 0 #define DRM_MODE_CONTENT_PROTECTION_DESIRED 1 #define DRM_MODE_CONTENT_PROTECTION_ENABLED 2 /** * struct drm_mode_modeinfo - Display mode information. * @clock: pixel clock in kHz * @hdisplay: horizontal display size * @hsync_start: horizontal sync start * @hsync_end: horizontal sync end * @htotal: horizontal total size * @hskew: horizontal skew * @vdisplay: vertical display size * @vsync_start: vertical sync start * @vsync_end: vertical sync end * @vtotal: vertical total size * @vscan: vertical scan * @vrefresh: approximate vertical refresh rate in Hz * @flags: bitmask of misc. flags, see DRM_MODE_FLAG_* defines * @type: bitmask of type flags, see DRM_MODE_TYPE_* defines * @name: string describing the mode resolution * * This is the user-space API display mode information structure. For the * kernel version see struct drm_display_mode. */ struct drm_mode_modeinfo { __u32 clock; __u16 hdisplay; __u16 hsync_start; __u16 hsync_end; __u16 htotal; __u16 hskew; __u16 vdisplay; __u16 vsync_start; __u16 vsync_end; __u16 vtotal; __u16 vscan; __u32 vrefresh; __u32 flags; __u32 type; char name[DRM_DISPLAY_MODE_LEN]; }; struct drm_mode_card_res { __u64 fb_id_ptr; __u64 crtc_id_ptr; __u64 connector_id_ptr; __u64 encoder_id_ptr; __u32 count_fbs; __u32 count_crtcs; __u32 count_connectors; __u32 count_encoders; __u32 min_width; __u32 max_width; __u32 min_height; __u32 max_height; }; struct drm_mode_crtc { __u64 set_connectors_ptr; __u32 count_connectors; __u32 crtc_id; /**< Id */ __u32 fb_id; /**< Id of framebuffer */ __u32 x; /**< x Position on the framebuffer */ __u32 y; /**< y Position on the framebuffer */ __u32 gamma_size; __u32 mode_valid; struct drm_mode_modeinfo mode; }; #define DRM_MODE_PRESENT_TOP_FIELD (1<<0) #define DRM_MODE_PRESENT_BOTTOM_FIELD (1<<1) /* Planes blend with or override other bits on the CRTC */ struct drm_mode_set_plane { __u32 plane_id; __u32 crtc_id; __u32 fb_id; /* fb object contains surface format type */ __u32 flags; /* see above flags */ /* Signed dest location allows it to be partially off screen */ __s32 crtc_x; __s32 crtc_y; __u32 crtc_w; __u32 crtc_h; /* Source values are 16.16 fixed point */ __u32 src_x; __u32 src_y; __u32 src_h; __u32 src_w; }; /** * struct drm_mode_get_plane - Get plane metadata. * * Userspace can perform a GETPLANE ioctl to retrieve information about a * plane. * * To retrieve the number of formats supported, set @count_format_types to zero * and call the ioctl. @count_format_types will be updated with the value. * * To retrieve these formats, allocate an array with the memory needed to store * @count_format_types formats. Point @format_type_ptr to this array and call * the ioctl again (with @count_format_types still set to the value returned in * the first ioctl call). */ struct drm_mode_get_plane { /** * @plane_id: Object ID of the plane whose information should be * retrieved. Set by caller. */ __u32 plane_id; /** @crtc_id: Object ID of the current CRTC. */ __u32 crtc_id; /** @fb_id: Object ID of the current fb. */ __u32 fb_id; /** * @possible_crtcs: Bitmask of CRTC's compatible with the plane. CRTC's * are created and they receive an index, which corresponds to their * position in the bitmask. Bit N corresponds to * :ref:`CRTC index` N. */ __u32 possible_crtcs; /** @gamma_size: Never used. */ __u32 gamma_size; /** @count_format_types: Number of formats. */ __u32 count_format_types; /** * @format_type_ptr: Pointer to ``__u32`` array of formats that are * supported by the plane. These formats do not require modifiers. */ __u64 format_type_ptr; }; struct drm_mode_get_plane_res { __u64 plane_id_ptr; __u32 count_planes; }; #define DRM_MODE_ENCODER_NONE 0 #define DRM_MODE_ENCODER_DAC 1 #define DRM_MODE_ENCODER_TMDS 2 #define DRM_MODE_ENCODER_LVDS 3 #define DRM_MODE_ENCODER_TVDAC 4 #define DRM_MODE_ENCODER_VIRTUAL 5 #define DRM_MODE_ENCODER_DSI 6 #define DRM_MODE_ENCODER_DPMST 7 #define DRM_MODE_ENCODER_DPI 8 struct drm_mode_get_encoder { __u32 encoder_id; __u32 encoder_type; __u32 crtc_id; /**< Id of crtc */ __u32 possible_crtcs; __u32 possible_clones; }; /* This is for connectors with multiple signal types. */ /* Try to match DRM_MODE_CONNECTOR_X as closely as possible. */ enum drm_mode_subconnector { DRM_MODE_SUBCONNECTOR_Automatic = 0, /* DVI-I, TV */ DRM_MODE_SUBCONNECTOR_Unknown = 0, /* DVI-I, TV, DP */ DRM_MODE_SUBCONNECTOR_VGA = 1, /* DP */ DRM_MODE_SUBCONNECTOR_DVID = 3, /* DVI-I DP */ DRM_MODE_SUBCONNECTOR_DVIA = 4, /* DVI-I */ DRM_MODE_SUBCONNECTOR_Composite = 5, /* TV */ DRM_MODE_SUBCONNECTOR_SVIDEO = 6, /* TV */ DRM_MODE_SUBCONNECTOR_Component = 8, /* TV */ DRM_MODE_SUBCONNECTOR_SCART = 9, /* TV */ DRM_MODE_SUBCONNECTOR_DisplayPort = 10, /* DP */ DRM_MODE_SUBCONNECTOR_HDMIA = 11, /* DP */ DRM_MODE_SUBCONNECTOR_Native = 15, /* DP */ DRM_MODE_SUBCONNECTOR_Wireless = 18, /* DP */ }; #define DRM_MODE_CONNECTOR_Unknown 0 #define DRM_MODE_CONNECTOR_VGA 1 #define DRM_MODE_CONNECTOR_DVII 2 #define DRM_MODE_CONNECTOR_DVID 3 #define DRM_MODE_CONNECTOR_DVIA 4 #define DRM_MODE_CONNECTOR_Composite 5 #define DRM_MODE_CONNECTOR_SVIDEO 6 #define DRM_MODE_CONNECTOR_LVDS 7 #define DRM_MODE_CONNECTOR_Component 8 #define DRM_MODE_CONNECTOR_9PinDIN 9 #define DRM_MODE_CONNECTOR_DisplayPort 10 #define DRM_MODE_CONNECTOR_HDMIA 11 #define DRM_MODE_CONNECTOR_HDMIB 12 #define DRM_MODE_CONNECTOR_TV 13 #define DRM_MODE_CONNECTOR_eDP 14 #define DRM_MODE_CONNECTOR_VIRTUAL 15 #define DRM_MODE_CONNECTOR_DSI 16 #define DRM_MODE_CONNECTOR_DPI 17 #define DRM_MODE_CONNECTOR_WRITEBACK 18 #define DRM_MODE_CONNECTOR_SPI 19 #define DRM_MODE_CONNECTOR_USB 20 /** * struct drm_mode_get_connector - Get connector metadata. * * User-space can perform a GETCONNECTOR ioctl to retrieve information about a * connector. User-space is expected to retrieve encoders, modes and properties * by performing this ioctl at least twice: the first time to retrieve the * number of elements, the second time to retrieve the elements themselves. * * To retrieve the number of elements, set @count_props and @count_encoders to * zero, set @count_modes to 1, and set @modes_ptr to a temporary struct * drm_mode_modeinfo element. * * To retrieve the elements, allocate arrays for @encoders_ptr, @modes_ptr, * @props_ptr and @prop_values_ptr, then set @count_modes, @count_props and * @count_encoders to their capacity. * * Performing the ioctl only twice may be racy: the number of elements may have * changed with a hotplug event in-between the two ioctls. User-space is * expected to retry the last ioctl until the number of elements stabilizes. * The kernel won't fill any array which doesn't have the expected length. * * **Force-probing a connector** * * If the @count_modes field is set to zero and the DRM client is the current * DRM master, the kernel will perform a forced probe on the connector to * refresh the connector status, modes and EDID. A forced-probe can be slow, * might cause flickering and the ioctl will block. * * User-space needs to force-probe connectors to ensure their metadata is * up-to-date at startup and after receiving a hot-plug event. User-space * may perform a forced-probe when the user explicitly requests it. User-space * shouldn't perform a forced-probe in other situations. */ struct drm_mode_get_connector { /** @encoders_ptr: Pointer to ``__u32`` array of object IDs. */ __u64 encoders_ptr; /** @modes_ptr: Pointer to struct drm_mode_modeinfo array. */ __u64 modes_ptr; /** @props_ptr: Pointer to ``__u32`` array of property IDs. */ __u64 props_ptr; /** @prop_values_ptr: Pointer to ``__u64`` array of property values. */ __u64 prop_values_ptr; /** @count_modes: Number of modes. */ __u32 count_modes; /** @count_props: Number of properties. */ __u32 count_props; /** @count_encoders: Number of encoders. */ __u32 count_encoders; /** @encoder_id: Object ID of the current encoder. */ __u32 encoder_id; /** @connector_id: Object ID of the connector. */ __u32 connector_id; /** * @connector_type: Type of the connector. * * See DRM_MODE_CONNECTOR_* defines. */ __u32 connector_type; /** * @connector_type_id: Type-specific connector number. * * This is not an object ID. This is a per-type connector number. Each * (type, type_id) combination is unique across all connectors of a DRM * device. * * The (type, type_id) combination is not a stable identifier: the * type_id can change depending on the driver probe order. */ __u32 connector_type_id; /** * @connection: Status of the connector. * * See enum drm_connector_status. */ __u32 connection; /** @mm_width: Width of the connected sink in millimeters. */ __u32 mm_width; /** @mm_height: Height of the connected sink in millimeters. */ __u32 mm_height; /** * @subpixel: Subpixel order of the connected sink. * * See enum subpixel_order. */ __u32 subpixel; /** @pad: Padding, must be zero. */ __u32 pad; }; #define DRM_MODE_PROP_PENDING (1<<0) /* deprecated, do not use */ #define DRM_MODE_PROP_RANGE (1<<1) #define DRM_MODE_PROP_IMMUTABLE (1<<2) #define DRM_MODE_PROP_ENUM (1<<3) /* enumerated type with text strings */ #define DRM_MODE_PROP_BLOB (1<<4) #define DRM_MODE_PROP_BITMASK (1<<5) /* bitmask of enumerated types */ /* non-extended types: legacy bitmask, one bit per type: */ #define DRM_MODE_PROP_LEGACY_TYPE ( \ DRM_MODE_PROP_RANGE | \ DRM_MODE_PROP_ENUM | \ DRM_MODE_PROP_BLOB | \ DRM_MODE_PROP_BITMASK) /* extended-types: rather than continue to consume a bit per type, * grab a chunk of the bits to use as integer type id. */ #define DRM_MODE_PROP_EXTENDED_TYPE 0x0000ffc0 #define DRM_MODE_PROP_TYPE(n) ((n) << 6) #define DRM_MODE_PROP_OBJECT DRM_MODE_PROP_TYPE(1) #define DRM_MODE_PROP_SIGNED_RANGE DRM_MODE_PROP_TYPE(2) /* the PROP_ATOMIC flag is used to hide properties from userspace that * is not aware of atomic properties. This is mostly to work around * older userspace (DDX drivers) that read/write each prop they find, * witout being aware that this could be triggering a lengthy modeset. */ #define DRM_MODE_PROP_ATOMIC 0x80000000 /** * struct drm_mode_property_enum - Description for an enum/bitfield entry. * @value: numeric value for this enum entry. * @name: symbolic name for this enum entry. * * See struct drm_property_enum for details. */ struct drm_mode_property_enum { __u64 value; char name[DRM_PROP_NAME_LEN]; }; /** * struct drm_mode_get_property - Get property metadata. * * User-space can perform a GETPROPERTY ioctl to retrieve information about a * property. The same property may be attached to multiple objects, see * "Modeset Base Object Abstraction". * * The meaning of the @values_ptr field changes depending on the property type. * See &drm_property.flags for more details. * * The @enum_blob_ptr and @count_enum_blobs fields are only meaningful when the * property has the type &DRM_MODE_PROP_ENUM or &DRM_MODE_PROP_BITMASK. For * backwards compatibility, the kernel will always set @count_enum_blobs to * zero when the property has the type &DRM_MODE_PROP_BLOB. User-space must * ignore these two fields if the property has a different type. * * User-space is expected to retrieve values and enums by performing this ioctl * at least twice: the first time to retrieve the number of elements, the * second time to retrieve the elements themselves. * * To retrieve the number of elements, set @count_values and @count_enum_blobs * to zero, then call the ioctl. @count_values will be updated with the number * of elements. If the property has the type &DRM_MODE_PROP_ENUM or * &DRM_MODE_PROP_BITMASK, @count_enum_blobs will be updated as well. * * To retrieve the elements themselves, allocate an array for @values_ptr and * set @count_values to its capacity. If the property has the type * &DRM_MODE_PROP_ENUM or &DRM_MODE_PROP_BITMASK, allocate an array for * @enum_blob_ptr and set @count_enum_blobs to its capacity. Calling the ioctl * again will fill the arrays. */ struct drm_mode_get_property { /** @values_ptr: Pointer to a ``__u64`` array. */ __u64 values_ptr; /** @enum_blob_ptr: Pointer to a struct drm_mode_property_enum array. */ __u64 enum_blob_ptr; /** * @prop_id: Object ID of the property which should be retrieved. Set * by the caller. */ __u32 prop_id; /** * @flags: ``DRM_MODE_PROP_*`` bitfield. See &drm_property.flags for * a definition of the flags. */ __u32 flags; /** * @name: Symbolic property name. User-space should use this field to * recognize properties. */ char name[DRM_PROP_NAME_LEN]; /** @count_values: Number of elements in @values_ptr. */ __u32 count_values; /** @count_enum_blobs: Number of elements in @enum_blob_ptr. */ __u32 count_enum_blobs; }; struct drm_mode_connector_set_property { __u64 value; __u32 prop_id; __u32 connector_id; }; #define DRM_MODE_OBJECT_CRTC 0xcccccccc #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0 #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0 #define DRM_MODE_OBJECT_MODE 0xdededede #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee #define DRM_MODE_OBJECT_ANY 0 struct drm_mode_obj_get_properties { __u64 props_ptr; __u64 prop_values_ptr; __u32 count_props; __u32 obj_id; __u32 obj_type; }; struct drm_mode_obj_set_property { __u64 value; __u32 prop_id; __u32 obj_id; __u32 obj_type; }; struct drm_mode_get_blob { __u32 blob_id; __u32 length; __u64 data; }; struct drm_mode_fb_cmd { __u32 fb_id; __u32 width; __u32 height; __u32 pitch; __u32 bpp; __u32 depth; /* driver specific handle */ __u32 handle; }; #define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */ #define DRM_MODE_FB_MODIFIERS (1<<1) /* enables ->modifer[] */ /** * struct drm_mode_fb_cmd2 - Frame-buffer metadata. * * This struct holds frame-buffer metadata. There are two ways to use it: * * - User-space can fill this struct and perform a &DRM_IOCTL_MODE_ADDFB2 * ioctl to register a new frame-buffer. The new frame-buffer object ID will * be set by the kernel in @fb_id. * - User-space can set @fb_id and perform a &DRM_IOCTL_MODE_GETFB2 ioctl to * fetch metadata about an existing frame-buffer. * * In case of planar formats, this struct allows up to 4 buffer objects with * offsets and pitches per plane. The pitch and offset order are dictated by * the format FourCC as defined by ``drm_fourcc.h``, e.g. NV12 is described as: * * YUV 4:2:0 image with a plane of 8-bit Y samples followed by an * interleaved U/V plane containing 8-bit 2x2 subsampled colour difference * samples. * * So it would consist of a Y plane at ``offsets[0]`` and a UV plane at * ``offsets[1]``. * * To accommodate tiled, compressed, etc formats, a modifier can be specified. * For more information see the "Format Modifiers" section. Note that even * though it looks like we have a modifier per-plane, we in fact do not. The * modifier for each plane must be identical. Thus all combinations of * different data layouts for multi-plane formats must be enumerated as * separate modifiers. * * All of the entries in @handles, @pitches, @offsets and @modifier must be * zero when unused. Warning, for @offsets and @modifier zero can't be used to * figure out whether the entry is used or not since it's a valid value (a zero * offset is common, and a zero modifier is &DRM_FORMAT_MOD_LINEAR). */ struct drm_mode_fb_cmd2 { /** @fb_id: Object ID of the frame-buffer. */ __u32 fb_id; /** @width: Width of the frame-buffer. */ __u32 width; /** @height: Height of the frame-buffer. */ __u32 height; /** * @pixel_format: FourCC format code, see ``DRM_FORMAT_*`` constants in * ``drm_fourcc.h``. */ __u32 pixel_format; /** * @flags: Frame-buffer flags (see &DRM_MODE_FB_INTERLACED and * &DRM_MODE_FB_MODIFIERS). */ __u32 flags; /** * @handles: GEM buffer handle, one per plane. Set to 0 if the plane is * unused. The same handle can be used for multiple planes. */ __u32 handles[4]; /** @pitches: Pitch (aka. stride) in bytes, one per plane. */ __u32 pitches[4]; /** @offsets: Offset into the buffer in bytes, one per plane. */ __u32 offsets[4]; /** * @modifier: Format modifier, one per plane. See ``DRM_FORMAT_MOD_*`` * constants in ``drm_fourcc.h``. All planes must use the same * modifier. Ignored unless &DRM_MODE_FB_MODIFIERS is set in @flags. */ __u64 modifier[4]; }; #define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01 #define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02 #define DRM_MODE_FB_DIRTY_FLAGS 0x03 #define DRM_MODE_FB_DIRTY_MAX_CLIPS 256 /* * Mark a region of a framebuffer as dirty. * * Some hardware does not automatically update display contents * as a hardware or software draw to a framebuffer. This ioctl * allows userspace to tell the kernel and the hardware what * regions of the framebuffer have changed. * * The kernel or hardware is free to update more then just the * region specified by the clip rects. The kernel or hardware * may also delay and/or coalesce several calls to dirty into a * single update. * * Userspace may annotate the updates, the annotates are a * promise made by the caller that the change is either a copy * of pixels or a fill of a single color in the region specified. * * If the DRM_MODE_FB_DIRTY_ANNOTATE_COPY flag is given then * the number of updated regions are half of num_clips given, * where the clip rects are paired in src and dst. The width and * height of each one of the pairs must match. * * If the DRM_MODE_FB_DIRTY_ANNOTATE_FILL flag is given the caller * promises that the region specified of the clip rects is filled * completely with a single color as given in the color argument. */ struct drm_mode_fb_dirty_cmd { __u32 fb_id; __u32 flags; __u32 color; __u32 num_clips; __u64 clips_ptr; }; struct drm_mode_mode_cmd { __u32 connector_id; struct drm_mode_modeinfo mode; }; #define DRM_MODE_CURSOR_BO 0x01 #define DRM_MODE_CURSOR_MOVE 0x02 #define DRM_MODE_CURSOR_FLAGS 0x03 /* * depending on the value in flags different members are used. * * CURSOR_BO uses * crtc_id * width * height * handle - if 0 turns the cursor off * * CURSOR_MOVE uses * crtc_id * x * y */ struct drm_mode_cursor { __u32 flags; __u32 crtc_id; __s32 x; __s32 y; __u32 width; __u32 height; /* driver specific handle */ __u32 handle; }; struct drm_mode_cursor2 { __u32 flags; __u32 crtc_id; __s32 x; __s32 y; __u32 width; __u32 height; /* driver specific handle */ __u32 handle; __s32 hot_x; __s32 hot_y; }; struct drm_mode_crtc_lut { __u32 crtc_id; __u32 gamma_size; /* pointers to arrays */ __u64 red; __u64 green; __u64 blue; }; struct drm_color_ctm { /* * Conversion matrix in S31.32 sign-magnitude * (not two's complement!) format. * * out matrix in * |R| |0 1 2| |R| * |G| = |3 4 5| x |G| * |B| |6 7 8| |B| */ __u64 matrix[9]; }; struct drm_color_lut { /* * Values are mapped linearly to 0.0 - 1.0 range, with 0x0 == 0.0 and * 0xffff == 1.0. */ __u16 red; __u16 green; __u16 blue; __u16 reserved; }; /** * struct hdr_metadata_infoframe - HDR Metadata Infoframe Data. * * HDR Metadata Infoframe as per CTA 861.G spec. This is expected * to match exactly with the spec. * * Userspace is expected to pass the metadata information as per * the format described in this structure. */ struct hdr_metadata_infoframe { /** * @eotf: Electro-Optical Transfer Function (EOTF) * used in the stream. */ __u8 eotf; /** * @metadata_type: Static_Metadata_Descriptor_ID. */ __u8 metadata_type; /** * @display_primaries: Color Primaries of the Data. * These are coded as unsigned 16-bit values in units of * 0.00002, where 0x0000 represents zero and 0xC350 * represents 1.0000. * @display_primaries.x: X cordinate of color primary. * @display_primaries.y: Y cordinate of color primary. */ struct { __u16 x, y; } display_primaries[3]; /** * @white_point: White Point of Colorspace Data. * These are coded as unsigned 16-bit values in units of * 0.00002, where 0x0000 represents zero and 0xC350 * represents 1.0000. * @white_point.x: X cordinate of whitepoint of color primary. * @white_point.y: Y cordinate of whitepoint of color primary. */ struct { __u16 x, y; } white_point; /** * @max_display_mastering_luminance: Max Mastering Display Luminance. * This value is coded as an unsigned 16-bit value in units of 1 cd/m2, * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2. */ __u16 max_display_mastering_luminance; /** * @min_display_mastering_luminance: Min Mastering Display Luminance. * This value is coded as an unsigned 16-bit value in units of * 0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF * represents 6.5535 cd/m2. */ __u16 min_display_mastering_luminance; /** * @max_cll: Max Content Light Level. * This value is coded as an unsigned 16-bit value in units of 1 cd/m2, * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2. */ __u16 max_cll; /** * @max_fall: Max Frame Average Light Level. * This value is coded as an unsigned 16-bit value in units of 1 cd/m2, * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2. */ __u16 max_fall; }; /** * struct hdr_output_metadata - HDR output metadata * * Metadata Information to be passed from userspace */ struct hdr_output_metadata { /** * @metadata_type: Static_Metadata_Descriptor_ID. */ __u32 metadata_type; /** * @hdmi_metadata_type1: HDR Metadata Infoframe. */ union { struct hdr_metadata_infoframe hdmi_metadata_type1; }; }; /** * DRM_MODE_PAGE_FLIP_EVENT * * Request that the kernel sends back a vblank event (see * struct drm_event_vblank) with the &DRM_EVENT_FLIP_COMPLETE type when the * page-flip is done. */ #define DRM_MODE_PAGE_FLIP_EVENT 0x01 /** * DRM_MODE_PAGE_FLIP_ASYNC * * Request that the page-flip is performed as soon as possible, ie. with no * delay due to waiting for vblank. This may cause tearing to be visible on * the screen. */ #define DRM_MODE_PAGE_FLIP_ASYNC 0x02 #define DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE 0x4 #define DRM_MODE_PAGE_FLIP_TARGET_RELATIVE 0x8 #define DRM_MODE_PAGE_FLIP_TARGET (DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE | \ DRM_MODE_PAGE_FLIP_TARGET_RELATIVE) /** * DRM_MODE_PAGE_FLIP_FLAGS * * Bitmask of flags suitable for &drm_mode_crtc_page_flip_target.flags. */ #define DRM_MODE_PAGE_FLIP_FLAGS (DRM_MODE_PAGE_FLIP_EVENT | \ DRM_MODE_PAGE_FLIP_ASYNC | \ DRM_MODE_PAGE_FLIP_TARGET) /* * Request a page flip on the specified crtc. * * This ioctl will ask KMS to schedule a page flip for the specified * crtc. Once any pending rendering targeting the specified fb (as of * ioctl time) has completed, the crtc will be reprogrammed to display * that fb after the next vertical refresh. The ioctl returns * immediately, but subsequent rendering to the current fb will block * in the execbuffer ioctl until the page flip happens. If a page * flip is already pending as the ioctl is called, EBUSY will be * returned. * * Flag DRM_MODE_PAGE_FLIP_EVENT requests that drm sends back a vblank * event (see drm.h: struct drm_event_vblank) when the page flip is * done. The user_data field passed in with this ioctl will be * returned as the user_data field in the vblank event struct. * * Flag DRM_MODE_PAGE_FLIP_ASYNC requests that the flip happen * 'as soon as possible', meaning that it not delay waiting for vblank. * This may cause tearing on the screen. * * The reserved field must be zero. */ struct drm_mode_crtc_page_flip { __u32 crtc_id; __u32 fb_id; __u32 flags; __u32 reserved; __u64 user_data; }; /* * Request a page flip on the specified crtc. * * Same as struct drm_mode_crtc_page_flip, but supports new flags and * re-purposes the reserved field: * * The sequence field must be zero unless either of the * DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags is specified. When * the ABSOLUTE flag is specified, the sequence field denotes the absolute * vblank sequence when the flip should take effect. When the RELATIVE * flag is specified, the sequence field denotes the relative (to the * current one when the ioctl is called) vblank sequence when the flip * should take effect. NOTE: DRM_IOCTL_WAIT_VBLANK must still be used to * make sure the vblank sequence before the target one has passed before * calling this ioctl. The purpose of the * DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags is merely to clarify * the target for when code dealing with a page flip runs during a * vertical blank period. */ struct drm_mode_crtc_page_flip_target { __u32 crtc_id; __u32 fb_id; __u32 flags; __u32 sequence; __u64 user_data; }; /* create a dumb scanout buffer */ struct drm_mode_create_dumb { __u32 height; __u32 width; __u32 bpp; __u32 flags; /* handle, pitch, size will be returned */ __u32 handle; __u32 pitch; __u64 size; }; /* set up for mmap of a dumb scanout buffer */ struct drm_mode_map_dumb { /** Handle for the object being mapped. */ __u32 handle; __u32 pad; /** * Fake offset to use for subsequent mmap call * * This is a fixed-size type for 32/64 compatibility. */ __u64 offset; }; struct drm_mode_destroy_dumb { __u32 handle; }; /** * DRM_MODE_ATOMIC_TEST_ONLY * * Do not apply the atomic commit, instead check whether the hardware supports * this configuration. * * See &drm_mode_config_funcs.atomic_check for more details on test-only * commits. */ #define DRM_MODE_ATOMIC_TEST_ONLY 0x0100 /** * DRM_MODE_ATOMIC_NONBLOCK * * Do not block while applying the atomic commit. The &DRM_IOCTL_MODE_ATOMIC * IOCTL returns immediately instead of waiting for the changes to be applied * in hardware. Note, the driver will still check that the update can be * applied before retuning. */ #define DRM_MODE_ATOMIC_NONBLOCK 0x0200 /** * DRM_MODE_ATOMIC_ALLOW_MODESET * * Allow the update to result in temporary or transient visible artifacts while * the update is being applied. Applying the update may also take significantly * more time than a page flip. All visual artifacts will disappear by the time * the update is completed, as signalled through the vblank event's timestamp * (see struct drm_event_vblank). * * This flag must be set when the KMS update might cause visible artifacts. * Without this flag such KMS update will return a EINVAL error. What kind of * update may cause visible artifacts depends on the driver and the hardware. * User-space that needs to know beforehand if an update might cause visible * artifacts can use &DRM_MODE_ATOMIC_TEST_ONLY without * &DRM_MODE_ATOMIC_ALLOW_MODESET to see if it fails. * * To the best of the driver's knowledge, visual artifacts are guaranteed to * not appear when this flag is not set. Some sinks might display visual * artifacts outside of the driver's control. */ #define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400 /** * DRM_MODE_ATOMIC_FLAGS * * Bitfield of flags accepted by the &DRM_IOCTL_MODE_ATOMIC IOCTL in * &drm_mode_atomic.flags. */ #define DRM_MODE_ATOMIC_FLAGS (\ DRM_MODE_PAGE_FLIP_EVENT |\ DRM_MODE_PAGE_FLIP_ASYNC |\ DRM_MODE_ATOMIC_TEST_ONLY |\ DRM_MODE_ATOMIC_NONBLOCK |\ DRM_MODE_ATOMIC_ALLOW_MODESET) struct drm_mode_atomic { __u32 flags; __u32 count_objs; __u64 objs_ptr; __u64 count_props_ptr; __u64 props_ptr; __u64 prop_values_ptr; __u64 reserved; __u64 user_data; }; struct drm_format_modifier_blob { #define FORMAT_BLOB_CURRENT 1 /* Version of this blob format */ __u32 version; /* Flags */ __u32 flags; /* Number of fourcc formats supported */ __u32 count_formats; /* Where in this blob the formats exist (in bytes) */ __u32 formats_offset; /* Number of drm_format_modifiers */ __u32 count_modifiers; /* Where in this blob the modifiers exist (in bytes) */ __u32 modifiers_offset; /* __u32 formats[] */ /* struct drm_format_modifier modifiers[] */ }; struct drm_format_modifier { /* Bitmask of formats in get_plane format list this info applies to. The * offset allows a sliding window of which 64 formats (bits). * * Some examples: * In today's world with < 65 formats, and formats 0, and 2 are * supported * 0x0000000000000005 * ^-offset = 0, formats = 5 * * If the number formats grew to 128, and formats 98-102 are * supported with the modifier: * * 0x0000007c00000000 0000000000000000 * ^ * |__offset = 64, formats = 0x7c00000000 * */ __u64 formats; __u32 offset; __u32 pad; /* The modifier that applies to the >get_plane format list bitmask. */ __u64 modifier; }; /** * struct drm_mode_create_blob - Create New blob property * * Create a new 'blob' data property, copying length bytes from data pointer, * and returning new blob ID. */ struct drm_mode_create_blob { /** @data: Pointer to data to copy. */ __u64 data; /** @length: Length of data to copy. */ __u32 length; /** @blob_id: Return: new property ID. */ __u32 blob_id; }; /** * struct drm_mode_destroy_blob - Destroy user blob * @blob_id: blob_id to destroy * * Destroy a user-created blob property. * * User-space can release blobs as soon as they do not need to refer to them by * their blob object ID. For instance, if you are using a MODE_ID blob in an * atomic commit and you will not make another commit re-using the same ID, you * can destroy the blob as soon as the commit has been issued, without waiting * for it to complete. */ struct drm_mode_destroy_blob { __u32 blob_id; }; /** * struct drm_mode_create_lease - Create lease * * Lease mode resources, creating another drm_master. * * The @object_ids array must reference at least one CRTC, one connector and * one plane if &DRM_CLIENT_CAP_UNIVERSAL_PLANES is enabled. Alternatively, * the lease can be completely empty. */ struct drm_mode_create_lease { /** @object_ids: Pointer to array of object ids (__u32) */ __u64 object_ids; /** @object_count: Number of object ids */ __u32 object_count; /** @flags: flags for new FD (O_CLOEXEC, etc) */ __u32 flags; /** @lessee_id: Return: unique identifier for lessee. */ __u32 lessee_id; /** @fd: Return: file descriptor to new drm_master file */ __u32 fd; }; /** * struct drm_mode_list_lessees - List lessees * * List lesses from a drm_master. */ struct drm_mode_list_lessees { /** * @count_lessees: Number of lessees. * * On input, provides length of the array. * On output, provides total number. No * more than the input number will be written * back, so two calls can be used to get * the size and then the data. */ __u32 count_lessees; /** @pad: Padding. */ __u32 pad; /** * @lessees_ptr: Pointer to lessees. * * Pointer to __u64 array of lessee ids */ __u64 lessees_ptr; }; /** * struct drm_mode_get_lease - Get Lease * * Get leased objects. */ struct drm_mode_get_lease { /** * @count_objects: Number of leased objects. * * On input, provides length of the array. * On output, provides total number. No * more than the input number will be written * back, so two calls can be used to get * the size and then the data. */ __u32 count_objects; /** @pad: Padding. */ __u32 pad; /** * @objects_ptr: Pointer to objects. * * Pointer to __u32 array of object ids. */ __u64 objects_ptr; }; /** * struct drm_mode_revoke_lease - Revoke lease */ struct drm_mode_revoke_lease { /** @lessee_id: Unique ID of lessee */ __u32 lessee_id; }; /** * struct drm_mode_rect - Two dimensional rectangle. * @x1: Horizontal starting coordinate (inclusive). * @y1: Vertical starting coordinate (inclusive). * @x2: Horizontal ending coordinate (exclusive). * @y2: Vertical ending coordinate (exclusive). * * With drm subsystem using struct drm_rect to manage rectangular area this * export it to user-space. * * Currently used by drm_mode_atomic blob property FB_DAMAGE_CLIPS. */ struct drm_mode_rect { __s32 x1; __s32 y1; __s32 x2; __s32 y2; }; #if defined(__cplusplus) } #endif #endif aristocratos-btop-d43a485/src/linux/intel_gpu_top/i915_drm.h000066400000000000000000003757671517514752700240760ustar00rootroot00000000000000/* * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas. * All Rights Reserved. * * 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, sub license, 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 (including the * next paragraph) 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 NON-INFRINGEMENT. * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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 _I915_DRM_H_ #define _I915_DRM_H_ #include "drm.h" #if defined(__cplusplus) extern "C" { #endif /* Please note that modifications to all structs defined here are * subject to backwards-compatibility constraints. */ /** * DOC: uevents generated by i915 on its device node * * I915_L3_PARITY_UEVENT - Generated when the driver receives a parity mismatch * event from the GPU L3 cache. Additional information supplied is ROW, * BANK, SUBBANK, SLICE of the affected cacheline. Userspace should keep * track of these events, and if a specific cache-line seems to have a * persistent error, remap it with the L3 remapping tool supplied in * intel-gpu-tools. The value supplied with the event is always 1. * * I915_ERROR_UEVENT - Generated upon error detection, currently only via * hangcheck. The error detection event is a good indicator of when things * began to go badly. The value supplied with the event is a 1 upon error * detection, and a 0 upon reset completion, signifying no more error * exists. NOTE: Disabling hangcheck or reset via module parameter will * cause the related events to not be seen. * * I915_RESET_UEVENT - Event is generated just before an attempt to reset the * GPU. The value supplied with the event is always 1. NOTE: Disable * reset via module parameter will cause this event to not be seen. */ #define I915_L3_PARITY_UEVENT "L3_PARITY_ERROR" #define I915_ERROR_UEVENT "ERROR" #define I915_RESET_UEVENT "RESET" /** * struct i915_user_extension - Base class for defining a chain of extensions * * Many interfaces need to grow over time. In most cases we can simply * extend the struct and have userspace pass in more data. Another option, * as demonstrated by Vulkan's approach to providing extensions for forward * and backward compatibility, is to use a list of optional structs to * provide those extra details. * * The key advantage to using an extension chain is that it allows us to * redefine the interface more easily than an ever growing struct of * increasing complexity, and for large parts of that interface to be * entirely optional. The downside is more pointer chasing; chasing across * the boundary with pointers encapsulated inside u64. * * Example chaining: * * .. code-block:: C * * struct i915_user_extension ext3 { * .next_extension = 0, // end * .name = ..., * }; * struct i915_user_extension ext2 { * .next_extension = (uintptr_t)&ext3, * .name = ..., * }; * struct i915_user_extension ext1 { * .next_extension = (uintptr_t)&ext2, * .name = ..., * }; * * Typically the struct i915_user_extension would be embedded in some uAPI * struct, and in this case we would feed it the head of the chain(i.e ext1), * which would then apply all of the above extensions. * */ struct i915_user_extension { /** * @next_extension: * * Pointer to the next struct i915_user_extension, or zero if the end. */ __u64 next_extension; /** * @name: Name of the extension. * * Note that the name here is just some integer. * * Also note that the name space for this is not global for the whole * driver, but rather its scope/meaning is limited to the specific piece * of uAPI which has embedded the struct i915_user_extension. */ __u32 name; /** * @flags: MBZ * * All undefined bits must be zero. */ __u32 flags; /** * @rsvd: MBZ * * Reserved for future use; must be zero. */ __u32 rsvd[4]; }; /* * MOCS indexes used for GPU surfaces, defining the cacheability of the * surface data and the coherency for this data wrt. CPU vs. GPU accesses. */ enum i915_mocs_table_index { /* * Not cached anywhere, coherency between CPU and GPU accesses is * guaranteed. */ I915_MOCS_UNCACHED, /* * Cacheability and coherency controlled by the kernel automatically * based on the DRM_I915_GEM_SET_CACHING IOCTL setting and the current * usage of the surface (used for display scanout or not). */ I915_MOCS_PTE, /* * Cached in all GPU caches available on the platform. * Coherency between CPU and GPU accesses to the surface is not * guaranteed without extra synchronization. */ I915_MOCS_CACHED, }; /** * enum drm_i915_gem_engine_class - uapi engine type enumeration * * Different engines serve different roles, and there may be more than one * engine serving each role. This enum provides a classification of the role * of the engine, which may be used when requesting operations to be performed * on a certain subset of engines, or for providing information about that * group. */ enum drm_i915_gem_engine_class { /** * @I915_ENGINE_CLASS_RENDER: * * Render engines support instructions used for 3D, Compute (GPGPU), * and programmable media workloads. These instructions fetch data and * dispatch individual work items to threads that operate in parallel. * The threads run small programs (called "kernels" or "shaders") on * the GPU's execution units (EUs). */ I915_ENGINE_CLASS_RENDER = 0, /** * @I915_ENGINE_CLASS_COPY: * * Copy engines (also referred to as "blitters") support instructions * that move blocks of data from one location in memory to another, * or that fill a specified location of memory with fixed data. * Copy engines can perform pre-defined logical or bitwise operations * on the source, destination, or pattern data. */ I915_ENGINE_CLASS_COPY = 1, /** * @I915_ENGINE_CLASS_VIDEO: * * Video engines (also referred to as "bit stream decode" (BSD) or * "vdbox") support instructions that perform fixed-function media * decode and encode. */ I915_ENGINE_CLASS_VIDEO = 2, /** * @I915_ENGINE_CLASS_VIDEO_ENHANCE: * * Video enhancement engines (also referred to as "vebox") support * instructions related to image enhancement. */ I915_ENGINE_CLASS_VIDEO_ENHANCE = 3, /** * @I915_ENGINE_CLASS_COMPUTE: * * Compute engines support a subset of the instructions available * on render engines: compute engines support Compute (GPGPU) and * programmable media workloads, but do not support the 3D pipeline. */ I915_ENGINE_CLASS_COMPUTE = 4, /* Values in this enum should be kept compact. */ /** * @I915_ENGINE_CLASS_INVALID: * * Placeholder value to represent an invalid engine class assignment. */ I915_ENGINE_CLASS_INVALID = -1 }; /** * struct i915_engine_class_instance - Engine class/instance identifier * * There may be more than one engine fulfilling any role within the system. * Each engine of a class is given a unique instance number and therefore * any engine can be specified by its class:instance tuplet. APIs that allow * access to any engine in the system will use struct i915_engine_class_instance * for this identification. */ struct i915_engine_class_instance { /** * @engine_class: * * Engine class from enum drm_i915_gem_engine_class */ __u16 engine_class; #define I915_ENGINE_CLASS_INVALID_NONE -1 #define I915_ENGINE_CLASS_INVALID_VIRTUAL -2 /** * @engine_instance: * * Engine instance. */ __u16 engine_instance; }; /** * DOC: perf_events exposed by i915 through /sys/bus/event_sources/drivers/i915 * */ enum drm_i915_pmu_engine_sample { I915_SAMPLE_BUSY = 0, I915_SAMPLE_WAIT = 1, I915_SAMPLE_SEMA = 2 }; #define I915_PMU_SAMPLE_BITS (4) #define I915_PMU_SAMPLE_MASK (0xf) #define I915_PMU_SAMPLE_INSTANCE_BITS (8) #define I915_PMU_CLASS_SHIFT \ (I915_PMU_SAMPLE_BITS + I915_PMU_SAMPLE_INSTANCE_BITS) #define __I915_PMU_ENGINE(class, instance, sample) \ ((class) << I915_PMU_CLASS_SHIFT | \ (instance) << I915_PMU_SAMPLE_BITS | \ (sample)) #define I915_PMU_ENGINE_BUSY(class, instance) \ __I915_PMU_ENGINE(class, instance, I915_SAMPLE_BUSY) #define I915_PMU_ENGINE_WAIT(class, instance) \ __I915_PMU_ENGINE(class, instance, I915_SAMPLE_WAIT) #define I915_PMU_ENGINE_SEMA(class, instance) \ __I915_PMU_ENGINE(class, instance, I915_SAMPLE_SEMA) /* * Top 4 bits of every non-engine counter are GT id. */ #define __I915_PMU_GT_SHIFT (60) #define ___I915_PMU_OTHER(gt, x) \ (((__u64)__I915_PMU_ENGINE(0xff, 0xff, 0xf) + 1 + (x)) | \ ((__u64)(gt) << __I915_PMU_GT_SHIFT)) #define __I915_PMU_OTHER(x) ___I915_PMU_OTHER(0, x) #define I915_PMU_ACTUAL_FREQUENCY __I915_PMU_OTHER(0) #define I915_PMU_REQUESTED_FREQUENCY __I915_PMU_OTHER(1) #define I915_PMU_INTERRUPTS __I915_PMU_OTHER(2) #define I915_PMU_RC6_RESIDENCY __I915_PMU_OTHER(3) #define I915_PMU_SOFTWARE_GT_AWAKE_TIME __I915_PMU_OTHER(4) #define I915_PMU_LAST /* Deprecated - do not use */ I915_PMU_RC6_RESIDENCY #define __I915_PMU_ACTUAL_FREQUENCY(gt) ___I915_PMU_OTHER(gt, 0) #define __I915_PMU_REQUESTED_FREQUENCY(gt) ___I915_PMU_OTHER(gt, 1) #define __I915_PMU_INTERRUPTS(gt) ___I915_PMU_OTHER(gt, 2) #define __I915_PMU_RC6_RESIDENCY(gt) ___I915_PMU_OTHER(gt, 3) #define __I915_PMU_SOFTWARE_GT_AWAKE_TIME(gt) ___I915_PMU_OTHER(gt, 4) /* Each region is a minimum of 16k, and there are at most 255 of them. */ #define I915_NR_TEX_REGIONS 255 /* table size 2k - maximum due to use * of chars for next/prev indices */ #define I915_LOG_MIN_TEX_REGION_SIZE 14 typedef struct _drm_i915_init { enum { I915_INIT_DMA = 0x01, I915_CLEANUP_DMA = 0x02, I915_RESUME_DMA = 0x03 } func; unsigned int mmio_offset; int sarea_priv_offset; unsigned int ring_start; unsigned int ring_end; unsigned int ring_size; unsigned int front_offset; unsigned int back_offset; unsigned int depth_offset; unsigned int w; unsigned int h; unsigned int pitch; unsigned int pitch_bits; unsigned int back_pitch; unsigned int depth_pitch; unsigned int cpp; unsigned int chipset; } drm_i915_init_t; typedef struct _drm_i915_sarea { struct drm_tex_region texList[I915_NR_TEX_REGIONS + 1]; int last_upload; /* last time texture was uploaded */ int last_enqueue; /* last time a buffer was enqueued */ int last_dispatch; /* age of the most recently dispatched buffer */ int ctxOwner; /* last context to upload state */ int texAge; int pf_enabled; /* is pageflipping allowed? */ int pf_active; int pf_current_page; /* which buffer is being displayed? */ int perf_boxes; /* performance boxes to be displayed */ int width, height; /* screen size in pixels */ drm_handle_t front_handle; int front_offset; int front_size; drm_handle_t back_handle; int back_offset; int back_size; drm_handle_t depth_handle; int depth_offset; int depth_size; drm_handle_t tex_handle; int tex_offset; int tex_size; int log_tex_granularity; int pitch; int rotation; /* 0, 90, 180 or 270 */ int rotated_offset; int rotated_size; int rotated_pitch; int virtualX, virtualY; unsigned int front_tiled; unsigned int back_tiled; unsigned int depth_tiled; unsigned int rotated_tiled; unsigned int rotated2_tiled; int pipeA_x; int pipeA_y; int pipeA_w; int pipeA_h; int pipeB_x; int pipeB_y; int pipeB_w; int pipeB_h; /* fill out some space for old userspace triple buffer */ drm_handle_t unused_handle; __u32 unused1, unused2, unused3; /* buffer object handles for static buffers. May change * over the lifetime of the client. */ __u32 front_bo_handle; __u32 back_bo_handle; __u32 unused_bo_handle; __u32 depth_bo_handle; } drm_i915_sarea_t; /* due to userspace building against these headers we need some compat here */ #define planeA_x pipeA_x #define planeA_y pipeA_y #define planeA_w pipeA_w #define planeA_h pipeA_h #define planeB_x pipeB_x #define planeB_y pipeB_y #define planeB_w pipeB_w #define planeB_h pipeB_h /* Flags for perf_boxes */ #define I915_BOX_RING_EMPTY 0x1 #define I915_BOX_FLIP 0x2 #define I915_BOX_WAIT 0x4 #define I915_BOX_TEXTURE_LOAD 0x8 #define I915_BOX_LOST_CONTEXT 0x10 /* * i915 specific ioctls. * * The device specific ioctl range is [DRM_COMMAND_BASE, DRM_COMMAND_END) ie * [0x40, 0xa0) (a0 is excluded). The numbers below are defined as offset * against DRM_COMMAND_BASE and should be between [0x0, 0x60). */ #define DRM_I915_INIT 0x00 #define DRM_I915_FLUSH 0x01 #define DRM_I915_FLIP 0x02 #define DRM_I915_BATCHBUFFER 0x03 #define DRM_I915_IRQ_EMIT 0x04 #define DRM_I915_IRQ_WAIT 0x05 #define DRM_I915_GETPARAM 0x06 #define DRM_I915_SETPARAM 0x07 #define DRM_I915_ALLOC 0x08 #define DRM_I915_FREE 0x09 #define DRM_I915_INIT_HEAP 0x0a #define DRM_I915_CMDBUFFER 0x0b #define DRM_I915_DESTROY_HEAP 0x0c #define DRM_I915_SET_VBLANK_PIPE 0x0d #define DRM_I915_GET_VBLANK_PIPE 0x0e #define DRM_I915_VBLANK_SWAP 0x0f #define DRM_I915_HWS_ADDR 0x11 #define DRM_I915_GEM_INIT 0x13 #define DRM_I915_GEM_EXECBUFFER 0x14 #define DRM_I915_GEM_PIN 0x15 #define DRM_I915_GEM_UNPIN 0x16 #define DRM_I915_GEM_BUSY 0x17 #define DRM_I915_GEM_THROTTLE 0x18 #define DRM_I915_GEM_ENTERVT 0x19 #define DRM_I915_GEM_LEAVEVT 0x1a #define DRM_I915_GEM_CREATE 0x1b #define DRM_I915_GEM_PREAD 0x1c #define DRM_I915_GEM_PWRITE 0x1d #define DRM_I915_GEM_MMAP 0x1e #define DRM_I915_GEM_SET_DOMAIN 0x1f #define DRM_I915_GEM_SW_FINISH 0x20 #define DRM_I915_GEM_SET_TILING 0x21 #define DRM_I915_GEM_GET_TILING 0x22 #define DRM_I915_GEM_GET_APERTURE 0x23 #define DRM_I915_GEM_MMAP_GTT 0x24 #define DRM_I915_GET_PIPE_FROM_CRTC_ID 0x25 #define DRM_I915_GEM_MADVISE 0x26 #define DRM_I915_OVERLAY_PUT_IMAGE 0x27 #define DRM_I915_OVERLAY_ATTRS 0x28 #define DRM_I915_GEM_EXECBUFFER2 0x29 #define DRM_I915_GEM_EXECBUFFER2_WR DRM_I915_GEM_EXECBUFFER2 #define DRM_I915_GET_SPRITE_COLORKEY 0x2a #define DRM_I915_SET_SPRITE_COLORKEY 0x2b #define DRM_I915_GEM_WAIT 0x2c #define DRM_I915_GEM_CONTEXT_CREATE 0x2d #define DRM_I915_GEM_CONTEXT_DESTROY 0x2e #define DRM_I915_GEM_SET_CACHING 0x2f #define DRM_I915_GEM_GET_CACHING 0x30 #define DRM_I915_REG_READ 0x31 #define DRM_I915_GET_RESET_STATS 0x32 #define DRM_I915_GEM_USERPTR 0x33 #define DRM_I915_GEM_CONTEXT_GETPARAM 0x34 #define DRM_I915_GEM_CONTEXT_SETPARAM 0x35 #define DRM_I915_PERF_OPEN 0x36 #define DRM_I915_PERF_ADD_CONFIG 0x37 #define DRM_I915_PERF_REMOVE_CONFIG 0x38 #define DRM_I915_QUERY 0x39 #define DRM_I915_GEM_VM_CREATE 0x3a #define DRM_I915_GEM_VM_DESTROY 0x3b #define DRM_I915_GEM_CREATE_EXT 0x3c /* Must be kept compact -- no holes */ #define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t) #define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH) #define DRM_IOCTL_I915_FLIP DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLIP) #define DRM_IOCTL_I915_BATCHBUFFER DRM_IOW( DRM_COMMAND_BASE + DRM_I915_BATCHBUFFER, drm_i915_batchbuffer_t) #define DRM_IOCTL_I915_IRQ_EMIT DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_IRQ_EMIT, drm_i915_irq_emit_t) #define DRM_IOCTL_I915_IRQ_WAIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_IRQ_WAIT, drm_i915_irq_wait_t) #define DRM_IOCTL_I915_GETPARAM DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GETPARAM, drm_i915_getparam_t) #define DRM_IOCTL_I915_SETPARAM DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SETPARAM, drm_i915_setparam_t) #define DRM_IOCTL_I915_ALLOC DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_ALLOC, drm_i915_mem_alloc_t) #define DRM_IOCTL_I915_FREE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_FREE, drm_i915_mem_free_t) #define DRM_IOCTL_I915_INIT_HEAP DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT_HEAP, drm_i915_mem_init_heap_t) #define DRM_IOCTL_I915_CMDBUFFER DRM_IOW( DRM_COMMAND_BASE + DRM_I915_CMDBUFFER, drm_i915_cmdbuffer_t) #define DRM_IOCTL_I915_DESTROY_HEAP DRM_IOW( DRM_COMMAND_BASE + DRM_I915_DESTROY_HEAP, drm_i915_mem_destroy_heap_t) #define DRM_IOCTL_I915_SET_VBLANK_PIPE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t) #define DRM_IOCTL_I915_GET_VBLANK_PIPE DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t) #define DRM_IOCTL_I915_VBLANK_SWAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t) #define DRM_IOCTL_I915_HWS_ADDR DRM_IOW(DRM_COMMAND_BASE + DRM_I915_HWS_ADDR, struct drm_i915_gem_init) #define DRM_IOCTL_I915_GEM_INIT DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_INIT, struct drm_i915_gem_init) #define DRM_IOCTL_I915_GEM_EXECBUFFER DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_EXECBUFFER, struct drm_i915_gem_execbuffer) #define DRM_IOCTL_I915_GEM_EXECBUFFER2 DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_EXECBUFFER2, struct drm_i915_gem_execbuffer2) #define DRM_IOCTL_I915_GEM_EXECBUFFER2_WR DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_EXECBUFFER2_WR, struct drm_i915_gem_execbuffer2) #define DRM_IOCTL_I915_GEM_PIN DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_PIN, struct drm_i915_gem_pin) #define DRM_IOCTL_I915_GEM_UNPIN DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_UNPIN, struct drm_i915_gem_unpin) #define DRM_IOCTL_I915_GEM_BUSY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_BUSY, struct drm_i915_gem_busy) #define DRM_IOCTL_I915_GEM_SET_CACHING DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_SET_CACHING, struct drm_i915_gem_caching) #define DRM_IOCTL_I915_GEM_GET_CACHING DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_GET_CACHING, struct drm_i915_gem_caching) #define DRM_IOCTL_I915_GEM_THROTTLE DRM_IO ( DRM_COMMAND_BASE + DRM_I915_GEM_THROTTLE) #define DRM_IOCTL_I915_GEM_ENTERVT DRM_IO(DRM_COMMAND_BASE + DRM_I915_GEM_ENTERVT) #define DRM_IOCTL_I915_GEM_LEAVEVT DRM_IO(DRM_COMMAND_BASE + DRM_I915_GEM_LEAVEVT) #define DRM_IOCTL_I915_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_CREATE, struct drm_i915_gem_create) #define DRM_IOCTL_I915_GEM_CREATE_EXT DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_CREATE_EXT, struct drm_i915_gem_create_ext) #define DRM_IOCTL_I915_GEM_PREAD DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_PREAD, struct drm_i915_gem_pread) #define DRM_IOCTL_I915_GEM_PWRITE DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_PWRITE, struct drm_i915_gem_pwrite) #define DRM_IOCTL_I915_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP, struct drm_i915_gem_mmap) #define DRM_IOCTL_I915_GEM_MMAP_GTT DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP_GTT, struct drm_i915_gem_mmap_gtt) #define DRM_IOCTL_I915_GEM_MMAP_OFFSET DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP_GTT, struct drm_i915_gem_mmap_offset) #define DRM_IOCTL_I915_GEM_SET_DOMAIN DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_SET_DOMAIN, struct drm_i915_gem_set_domain) #define DRM_IOCTL_I915_GEM_SW_FINISH DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_SW_FINISH, struct drm_i915_gem_sw_finish) #define DRM_IOCTL_I915_GEM_SET_TILING DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_SET_TILING, struct drm_i915_gem_set_tiling) #define DRM_IOCTL_I915_GEM_GET_TILING DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_GET_TILING, struct drm_i915_gem_get_tiling) #define DRM_IOCTL_I915_GEM_GET_APERTURE DRM_IOR (DRM_COMMAND_BASE + DRM_I915_GEM_GET_APERTURE, struct drm_i915_gem_get_aperture) #define DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GET_PIPE_FROM_CRTC_ID, struct drm_i915_get_pipe_from_crtc_id) #define DRM_IOCTL_I915_GEM_MADVISE DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MADVISE, struct drm_i915_gem_madvise) #define DRM_IOCTL_I915_OVERLAY_PUT_IMAGE DRM_IOW(DRM_COMMAND_BASE + DRM_I915_OVERLAY_PUT_IMAGE, struct drm_intel_overlay_put_image) #define DRM_IOCTL_I915_OVERLAY_ATTRS DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_OVERLAY_ATTRS, struct drm_intel_overlay_attrs) #define DRM_IOCTL_I915_SET_SPRITE_COLORKEY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_SET_SPRITE_COLORKEY, struct drm_intel_sprite_colorkey) #define DRM_IOCTL_I915_GET_SPRITE_COLORKEY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GET_SPRITE_COLORKEY, struct drm_intel_sprite_colorkey) #define DRM_IOCTL_I915_GEM_WAIT DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_WAIT, struct drm_i915_gem_wait) #define DRM_IOCTL_I915_GEM_CONTEXT_CREATE DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_CREATE, struct drm_i915_gem_context_create) #define DRM_IOCTL_I915_GEM_CONTEXT_CREATE_EXT DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_CREATE, struct drm_i915_gem_context_create_ext) #define DRM_IOCTL_I915_GEM_CONTEXT_DESTROY DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_DESTROY, struct drm_i915_gem_context_destroy) #define DRM_IOCTL_I915_REG_READ DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_REG_READ, struct drm_i915_reg_read) #define DRM_IOCTL_I915_GET_RESET_STATS DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GET_RESET_STATS, struct drm_i915_reset_stats) #define DRM_IOCTL_I915_GEM_USERPTR DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_USERPTR, struct drm_i915_gem_userptr) #define DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_GETPARAM, struct drm_i915_gem_context_param) #define DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_SETPARAM, struct drm_i915_gem_context_param) #define DRM_IOCTL_I915_PERF_OPEN DRM_IOW(DRM_COMMAND_BASE + DRM_I915_PERF_OPEN, struct drm_i915_perf_open_param) #define DRM_IOCTL_I915_PERF_ADD_CONFIG DRM_IOW(DRM_COMMAND_BASE + DRM_I915_PERF_ADD_CONFIG, struct drm_i915_perf_oa_config) #define DRM_IOCTL_I915_PERF_REMOVE_CONFIG DRM_IOW(DRM_COMMAND_BASE + DRM_I915_PERF_REMOVE_CONFIG, __u64) #define DRM_IOCTL_I915_QUERY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_QUERY, struct drm_i915_query) #define DRM_IOCTL_I915_GEM_VM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_VM_CREATE, struct drm_i915_gem_vm_control) #define DRM_IOCTL_I915_GEM_VM_DESTROY DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_VM_DESTROY, struct drm_i915_gem_vm_control) /* Allow drivers to submit batchbuffers directly to hardware, relying * on the security mechanisms provided by hardware. */ typedef struct drm_i915_batchbuffer { int start; /* agp offset */ int used; /* nr bytes in use */ int DR1; /* hw flags for GFX_OP_DRAWRECT_INFO */ int DR4; /* window origin for GFX_OP_DRAWRECT_INFO */ int num_cliprects; /* mulitpass with multiple cliprects? */ struct drm_clip_rect *cliprects; /* pointer to userspace cliprects */ } drm_i915_batchbuffer_t; /* As above, but pass a pointer to userspace buffer which can be * validated by the kernel prior to sending to hardware. */ typedef struct _drm_i915_cmdbuffer { char *buf; /* pointer to userspace command buffer */ int sz; /* nr bytes in buf */ int DR1; /* hw flags for GFX_OP_DRAWRECT_INFO */ int DR4; /* window origin for GFX_OP_DRAWRECT_INFO */ int num_cliprects; /* mulitpass with multiple cliprects? */ struct drm_clip_rect *cliprects; /* pointer to userspace cliprects */ } drm_i915_cmdbuffer_t; /* Userspace can request & wait on irq's: */ typedef struct drm_i915_irq_emit { int *irq_seq; } drm_i915_irq_emit_t; typedef struct drm_i915_irq_wait { int irq_seq; } drm_i915_irq_wait_t; /* * Different modes of per-process Graphics Translation Table, * see I915_PARAM_HAS_ALIASING_PPGTT */ #define I915_GEM_PPGTT_NONE 0 #define I915_GEM_PPGTT_ALIASING 1 #define I915_GEM_PPGTT_FULL 2 /* Ioctl to query kernel params: */ #define I915_PARAM_IRQ_ACTIVE 1 #define I915_PARAM_ALLOW_BATCHBUFFER 2 #define I915_PARAM_LAST_DISPATCH 3 #define I915_PARAM_CHIPSET_ID 4 #define I915_PARAM_HAS_GEM 5 #define I915_PARAM_NUM_FENCES_AVAIL 6 #define I915_PARAM_HAS_OVERLAY 7 #define I915_PARAM_HAS_PAGEFLIPPING 8 #define I915_PARAM_HAS_EXECBUF2 9 #define I915_PARAM_HAS_BSD 10 #define I915_PARAM_HAS_BLT 11 #define I915_PARAM_HAS_RELAXED_FENCING 12 #define I915_PARAM_HAS_COHERENT_RINGS 13 #define I915_PARAM_HAS_EXEC_CONSTANTS 14 #define I915_PARAM_HAS_RELAXED_DELTA 15 #define I915_PARAM_HAS_GEN7_SOL_RESET 16 #define I915_PARAM_HAS_LLC 17 #define I915_PARAM_HAS_ALIASING_PPGTT 18 #define I915_PARAM_HAS_WAIT_TIMEOUT 19 #define I915_PARAM_HAS_SEMAPHORES 20 #define I915_PARAM_HAS_PRIME_VMAP_FLUSH 21 #define I915_PARAM_HAS_VEBOX 22 #define I915_PARAM_HAS_SECURE_BATCHES 23 #define I915_PARAM_HAS_PINNED_BATCHES 24 #define I915_PARAM_HAS_EXEC_NO_RELOC 25 #define I915_PARAM_HAS_EXEC_HANDLE_LUT 26 #define I915_PARAM_HAS_WT 27 #define I915_PARAM_CMD_PARSER_VERSION 28 #define I915_PARAM_HAS_COHERENT_PHYS_GTT 29 #define I915_PARAM_MMAP_VERSION 30 #define I915_PARAM_HAS_BSD2 31 #define I915_PARAM_REVISION 32 #define I915_PARAM_SUBSLICE_TOTAL 33 #define I915_PARAM_EU_TOTAL 34 #define I915_PARAM_HAS_GPU_RESET 35 #define I915_PARAM_HAS_RESOURCE_STREAMER 36 #define I915_PARAM_HAS_EXEC_SOFTPIN 37 #define I915_PARAM_HAS_POOLED_EU 38 #define I915_PARAM_MIN_EU_IN_POOL 39 #define I915_PARAM_MMAP_GTT_VERSION 40 /* * Query whether DRM_I915_GEM_EXECBUFFER2 supports user defined execution * priorities and the driver will attempt to execute batches in priority order. * The param returns a capability bitmask, nonzero implies that the scheduler * is enabled, with different features present according to the mask. * * The initial priority for each batch is supplied by the context and is * controlled via I915_CONTEXT_PARAM_PRIORITY. */ #define I915_PARAM_HAS_SCHEDULER 41 #define I915_SCHEDULER_CAP_ENABLED (1ul << 0) #define I915_SCHEDULER_CAP_PRIORITY (1ul << 1) #define I915_SCHEDULER_CAP_PREEMPTION (1ul << 2) #define I915_SCHEDULER_CAP_SEMAPHORES (1ul << 3) #define I915_SCHEDULER_CAP_ENGINE_BUSY_STATS (1ul << 4) /* * Indicates the 2k user priority levels are statically mapped into 3 buckets as * follows: * * -1k to -1 Low priority * 0 Normal priority * 1 to 1k Highest priority */ #define I915_SCHEDULER_CAP_STATIC_PRIORITY_MAP (1ul << 5) /* * Query the status of HuC load. * * The query can fail in the following scenarios with the listed error codes: * -ENODEV if HuC is not present on this platform, * -EOPNOTSUPP if HuC firmware usage is disabled, * -ENOPKG if HuC firmware fetch failed, * -ENOEXEC if HuC firmware is invalid or mismatched, * -ENOMEM if i915 failed to prepare the FW objects for transfer to the uC, * -EIO if the FW transfer or the FW authentication failed. * * If the IOCTL is successful, the returned parameter will be set to one of the * following values: * * 0 if HuC firmware load is not complete, * * 1 if HuC firmware is loaded and fully authenticated, * * 2 if HuC firmware is loaded and authenticated for clear media only */ #define I915_PARAM_HUC_STATUS 42 /* Query whether DRM_I915_GEM_EXECBUFFER2 supports the ability to opt-out of * synchronisation with implicit fencing on individual objects. * See EXEC_OBJECT_ASYNC. */ #define I915_PARAM_HAS_EXEC_ASYNC 43 /* Query whether DRM_I915_GEM_EXECBUFFER2 supports explicit fence support - * both being able to pass in a sync_file fd to wait upon before executing, * and being able to return a new sync_file fd that is signaled when the * current request is complete. See I915_EXEC_FENCE_IN and I915_EXEC_FENCE_OUT. */ #define I915_PARAM_HAS_EXEC_FENCE 44 /* Query whether DRM_I915_GEM_EXECBUFFER2 supports the ability to capture * user-specified buffers for post-mortem debugging of GPU hangs. See * EXEC_OBJECT_CAPTURE. */ #define I915_PARAM_HAS_EXEC_CAPTURE 45 #define I915_PARAM_SLICE_MASK 46 /* Assuming it's uniform for each slice, this queries the mask of subslices * per-slice for this system. */ #define I915_PARAM_SUBSLICE_MASK 47 /* * Query whether DRM_I915_GEM_EXECBUFFER2 supports supplying the batch buffer * as the first execobject as opposed to the last. See I915_EXEC_BATCH_FIRST. */ #define I915_PARAM_HAS_EXEC_BATCH_FIRST 48 /* Query whether DRM_I915_GEM_EXECBUFFER2 supports supplying an array of * drm_i915_gem_exec_fence structures. See I915_EXEC_FENCE_ARRAY. */ #define I915_PARAM_HAS_EXEC_FENCE_ARRAY 49 /* * Query whether every context (both per-file default and user created) is * isolated (insofar as HW supports). If this parameter is not true, then * freshly created contexts may inherit values from an existing context, * rather than default HW values. If true, it also ensures (insofar as HW * supports) that all state set by this context will not leak to any other * context. * * As not every engine across every gen support contexts, the returned * value reports the support of context isolation for individual engines by * returning a bitmask of each engine class set to true if that class supports * isolation. */ #define I915_PARAM_HAS_CONTEXT_ISOLATION 50 /* Frequency of the command streamer timestamps given by the *_TIMESTAMP * registers. This used to be fixed per platform but from CNL onwards, this * might vary depending on the parts. */ #define I915_PARAM_CS_TIMESTAMP_FREQUENCY 51 /* * Once upon a time we supposed that writes through the GGTT would be * immediately in physical memory (once flushed out of the CPU path). However, * on a few different processors and chipsets, this is not necessarily the case * as the writes appear to be buffered internally. Thus a read of the backing * storage (physical memory) via a different path (with different physical tags * to the indirect write via the GGTT) will see stale values from before * the GGTT write. Inside the kernel, we can for the most part keep track of * the different read/write domains in use (e.g. set-domain), but the assumption * of coherency is baked into the ABI, hence reporting its true state in this * parameter. * * Reports true when writes via mmap_gtt are immediately visible following an * lfence to flush the WCB. * * Reports false when writes via mmap_gtt are indeterminately delayed in an in * internal buffer and are _not_ immediately visible to third parties accessing * directly via mmap_cpu/mmap_wc. Use of mmap_gtt as part of an IPC * communications channel when reporting false is strongly disadvised. */ #define I915_PARAM_MMAP_GTT_COHERENT 52 /* * Query whether DRM_I915_GEM_EXECBUFFER2 supports coordination of parallel * execution through use of explicit fence support. * See I915_EXEC_FENCE_OUT and I915_EXEC_FENCE_SUBMIT. */ #define I915_PARAM_HAS_EXEC_SUBMIT_FENCE 53 /* * Revision of the i915-perf uAPI. The value returned helps determine what * i915-perf features are available. See drm_i915_perf_property_id. */ #define I915_PARAM_PERF_REVISION 54 /* Query whether DRM_I915_GEM_EXECBUFFER2 supports supplying an array of * timeline syncobj through drm_i915_gem_execbuffer_ext_timeline_fences. See * I915_EXEC_USE_EXTENSIONS. */ #define I915_PARAM_HAS_EXEC_TIMELINE_FENCES 55 /* Query if the kernel supports the I915_USERPTR_PROBE flag. */ #define I915_PARAM_HAS_USERPTR_PROBE 56 /* * Frequency of the timestamps in OA reports. This used to be the same as the CS * timestamp frequency, but differs on some platforms. */ #define I915_PARAM_OA_TIMESTAMP_FREQUENCY 57 /* * Query the status of PXP support in i915. * * The query can fail in the following scenarios with the listed error codes: * -ENODEV = PXP support is not available on the GPU device or in the * kernel due to missing component drivers or kernel configs. * * If the IOCTL is successful, the returned parameter will be set to one of * the following values: * 1 = PXP feature is supported and is ready for use. * 2 = PXP feature is supported but should be ready soon (pending * initialization of non-i915 system dependencies). * * NOTE: When param is supported (positive return values), user space should * still refer to the GEM PXP context-creation UAPI header specs to be * aware of possible failure due to system state machine at the time. */ #define I915_PARAM_PXP_STATUS 58 /* Must be kept compact -- no holes and well documented */ /** * struct drm_i915_getparam - Driver parameter query structure. */ struct drm_i915_getparam { /** @param: Driver parameter to query. */ __s32 param; /** * @value: Address of memory where queried value should be put. * * WARNING: Using pointers instead of fixed-size u64 means we need to write * compat32 code. Don't repeat this mistake. */ int *value; }; /** * typedef drm_i915_getparam_t - Driver parameter query structure. * See struct drm_i915_getparam. */ typedef struct drm_i915_getparam drm_i915_getparam_t; /* Ioctl to set kernel params: */ #define I915_SETPARAM_USE_MI_BATCHBUFFER_START 1 #define I915_SETPARAM_TEX_LRU_LOG_GRANULARITY 2 #define I915_SETPARAM_ALLOW_BATCHBUFFER 3 #define I915_SETPARAM_NUM_USED_FENCES 4 /* Must be kept compact -- no holes */ typedef struct drm_i915_setparam { int param; int value; } drm_i915_setparam_t; /* A memory manager for regions of shared memory: */ #define I915_MEM_REGION_AGP 1 typedef struct drm_i915_mem_alloc { int region; int alignment; int size; int *region_offset; /* offset from start of fb or agp */ } drm_i915_mem_alloc_t; typedef struct drm_i915_mem_free { int region; int region_offset; } drm_i915_mem_free_t; typedef struct drm_i915_mem_init_heap { int region; int size; int start; } drm_i915_mem_init_heap_t; /* Allow memory manager to be torn down and re-initialized (eg on * rotate): */ typedef struct drm_i915_mem_destroy_heap { int region; } drm_i915_mem_destroy_heap_t; /* Allow X server to configure which pipes to monitor for vblank signals */ #define DRM_I915_VBLANK_PIPE_A 1 #define DRM_I915_VBLANK_PIPE_B 2 typedef struct drm_i915_vblank_pipe { int pipe; } drm_i915_vblank_pipe_t; /* Schedule buffer swap at given vertical blank: */ typedef struct drm_i915_vblank_swap { drm_drawable_t drawable; enum drm_vblank_seq_type seqtype; unsigned int sequence; } drm_i915_vblank_swap_t; typedef struct drm_i915_hws_addr { __u64 addr; } drm_i915_hws_addr_t; struct drm_i915_gem_init { /** * Beginning offset in the GTT to be managed by the DRM memory * manager. */ __u64 gtt_start; /** * Ending offset in the GTT to be managed by the DRM memory * manager. */ __u64 gtt_end; }; struct drm_i915_gem_create { /** * Requested size for the object. * * The (page-aligned) allocated size for the object will be returned. */ __u64 size; /** * Returned handle for the object. * * Object handles are nonzero. */ __u32 handle; __u32 pad; }; struct drm_i915_gem_pread { /** Handle for the object being read. */ __u32 handle; __u32 pad; /** Offset into the object to read from */ __u64 offset; /** Length of data to read */ __u64 size; /** * Pointer to write the data into. * * This is a fixed-size type for 32/64 compatibility. */ __u64 data_ptr; }; struct drm_i915_gem_pwrite { /** Handle for the object being written to. */ __u32 handle; __u32 pad; /** Offset into the object to write to */ __u64 offset; /** Length of data to write */ __u64 size; /** * Pointer to read the data from. * * This is a fixed-size type for 32/64 compatibility. */ __u64 data_ptr; }; struct drm_i915_gem_mmap { /** Handle for the object being mapped. */ __u32 handle; __u32 pad; /** Offset in the object to map. */ __u64 offset; /** * Length of data to map. * * The value will be page-aligned. */ __u64 size; /** * Returned pointer the data was mapped at. * * This is a fixed-size type for 32/64 compatibility. */ __u64 addr_ptr; /** * Flags for extended behaviour. * * Added in version 2. */ __u64 flags; #define I915_MMAP_WC 0x1 }; struct drm_i915_gem_mmap_gtt { /** Handle for the object being mapped. */ __u32 handle; __u32 pad; /** * Fake offset to use for subsequent mmap call * * This is a fixed-size type for 32/64 compatibility. */ __u64 offset; }; /** * struct drm_i915_gem_mmap_offset - Retrieve an offset so we can mmap this buffer object. * * This struct is passed as argument to the `DRM_IOCTL_I915_GEM_MMAP_OFFSET` ioctl, * and is used to retrieve the fake offset to mmap an object specified by &handle. * * The legacy way of using `DRM_IOCTL_I915_GEM_MMAP` is removed on gen12+. * `DRM_IOCTL_I915_GEM_MMAP_GTT` is an older supported alias to this struct, but will behave * as setting the &extensions to 0, and &flags to `I915_MMAP_OFFSET_GTT`. */ struct drm_i915_gem_mmap_offset { /** @handle: Handle for the object being mapped. */ __u32 handle; /** @pad: Must be zero */ __u32 pad; /** * @offset: The fake offset to use for subsequent mmap call * * This is a fixed-size type for 32/64 compatibility. */ __u64 offset; /** * @flags: Flags for extended behaviour. * * It is mandatory that one of the `MMAP_OFFSET` types * should be included: * * - `I915_MMAP_OFFSET_GTT`: Use mmap with the object bound to GTT. (Write-Combined) * - `I915_MMAP_OFFSET_WC`: Use Write-Combined caching. * - `I915_MMAP_OFFSET_WB`: Use Write-Back caching. * - `I915_MMAP_OFFSET_FIXED`: Use object placement to determine caching. * * On devices with local memory `I915_MMAP_OFFSET_FIXED` is the only valid * type. On devices without local memory, this caching mode is invalid. * * As caching mode when specifying `I915_MMAP_OFFSET_FIXED`, WC or WB will * be used, depending on the object placement on creation. WB will be used * when the object can only exist in system memory, WC otherwise. */ __u64 flags; #define I915_MMAP_OFFSET_GTT 0 #define I915_MMAP_OFFSET_WC 1 #define I915_MMAP_OFFSET_WB 2 #define I915_MMAP_OFFSET_UC 3 #define I915_MMAP_OFFSET_FIXED 4 /** * @extensions: Zero-terminated chain of extensions. * * No current extensions defined; mbz. */ __u64 extensions; }; /** * struct drm_i915_gem_set_domain - Adjust the objects write or read domain, in * preparation for accessing the pages via some CPU domain. * * Specifying a new write or read domain will flush the object out of the * previous domain(if required), before then updating the objects domain * tracking with the new domain. * * Note this might involve waiting for the object first if it is still active on * the GPU. * * Supported values for @read_domains and @write_domain: * * - I915_GEM_DOMAIN_WC: Uncached write-combined domain * - I915_GEM_DOMAIN_CPU: CPU cache domain * - I915_GEM_DOMAIN_GTT: Mappable aperture domain * * All other domains are rejected. * * Note that for discrete, starting from DG1, this is no longer supported, and * is instead rejected. On such platforms the CPU domain is effectively static, * where we also only support a single &drm_i915_gem_mmap_offset cache mode, * which can't be set explicitly and instead depends on the object placements, * as per the below. * * Implicit caching rules, starting from DG1: * * - If any of the object placements (see &drm_i915_gem_create_ext_memory_regions) * contain I915_MEMORY_CLASS_DEVICE then the object will be allocated and * mapped as write-combined only. * * - Everything else is always allocated and mapped as write-back, with the * guarantee that everything is also coherent with the GPU. * * Note that this is likely to change in the future again, where we might need * more flexibility on future devices, so making this all explicit as part of a * new &drm_i915_gem_create_ext extension is probable. */ struct drm_i915_gem_set_domain { /** @handle: Handle for the object. */ __u32 handle; /** @read_domains: New read domains. */ __u32 read_domains; /** * @write_domain: New write domain. * * Note that having something in the write domain implies it's in the * read domain, and only that read domain. */ __u32 write_domain; }; struct drm_i915_gem_sw_finish { /** Handle for the object */ __u32 handle; }; struct drm_i915_gem_relocation_entry { /** * Handle of the buffer being pointed to by this relocation entry. * * It's appealing to make this be an index into the mm_validate_entry * list to refer to the buffer, but this allows the driver to create * a relocation list for state buffers and not re-write it per * exec using the buffer. */ __u32 target_handle; /** * Value to be added to the offset of the target buffer to make up * the relocation entry. */ __u32 delta; /** Offset in the buffer the relocation entry will be written into */ __u64 offset; /** * Offset value of the target buffer that the relocation entry was last * written as. * * If the buffer has the same offset as last time, we can skip syncing * and writing the relocation. This value is written back out by * the execbuffer ioctl when the relocation is written. */ __u64 presumed_offset; /** * Target memory domains read by this operation. */ __u32 read_domains; /** * Target memory domains written by this operation. * * Note that only one domain may be written by the whole * execbuffer operation, so that where there are conflicts, * the application will get -EINVAL back. */ __u32 write_domain; }; /** @{ * Intel memory domains * * Most of these just align with the various caches in * the system and are used to flush and invalidate as * objects end up cached in different domains. */ /** CPU cache */ #define I915_GEM_DOMAIN_CPU 0x00000001 /** Render cache, used by 2D and 3D drawing */ #define I915_GEM_DOMAIN_RENDER 0x00000002 /** Sampler cache, used by texture engine */ #define I915_GEM_DOMAIN_SAMPLER 0x00000004 /** Command queue, used to load batch buffers */ #define I915_GEM_DOMAIN_COMMAND 0x00000008 /** Instruction cache, used by shader programs */ #define I915_GEM_DOMAIN_INSTRUCTION 0x00000010 /** Vertex address cache */ #define I915_GEM_DOMAIN_VERTEX 0x00000020 /** GTT domain - aperture and scanout */ #define I915_GEM_DOMAIN_GTT 0x00000040 /** WC domain - uncached access */ #define I915_GEM_DOMAIN_WC 0x00000080 /** @} */ struct drm_i915_gem_exec_object { /** * User's handle for a buffer to be bound into the GTT for this * operation. */ __u32 handle; /** Number of relocations to be performed on this buffer */ __u32 relocation_count; /** * Pointer to array of struct drm_i915_gem_relocation_entry containing * the relocations to be performed in this buffer. */ __u64 relocs_ptr; /** Required alignment in graphics aperture */ __u64 alignment; /** * Returned value of the updated offset of the object, for future * presumed_offset writes. */ __u64 offset; }; /* DRM_IOCTL_I915_GEM_EXECBUFFER was removed in Linux 5.13 */ struct drm_i915_gem_execbuffer { /** * List of buffers to be validated with their relocations to be * performend on them. * * This is a pointer to an array of struct drm_i915_gem_validate_entry. * * These buffers must be listed in an order such that all relocations * a buffer is performing refer to buffers that have already appeared * in the validate list. */ __u64 buffers_ptr; __u32 buffer_count; /** Offset in the batchbuffer to start execution from. */ __u32 batch_start_offset; /** Bytes used in batchbuffer from batch_start_offset */ __u32 batch_len; __u32 DR1; __u32 DR4; __u32 num_cliprects; /** This is a struct drm_clip_rect *cliprects */ __u64 cliprects_ptr; }; struct drm_i915_gem_exec_object2 { /** * User's handle for a buffer to be bound into the GTT for this * operation. */ __u32 handle; /** Number of relocations to be performed on this buffer */ __u32 relocation_count; /** * Pointer to array of struct drm_i915_gem_relocation_entry containing * the relocations to be performed in this buffer. */ __u64 relocs_ptr; /** Required alignment in graphics aperture */ __u64 alignment; /** * When the EXEC_OBJECT_PINNED flag is specified this is populated by * the user with the GTT offset at which this object will be pinned. * * When the I915_EXEC_NO_RELOC flag is specified this must contain the * presumed_offset of the object. * * During execbuffer2 the kernel populates it with the value of the * current GTT offset of the object, for future presumed_offset writes. * * See struct drm_i915_gem_create_ext for the rules when dealing with * alignment restrictions with I915_MEMORY_CLASS_DEVICE, on devices with * minimum page sizes, like DG2. */ __u64 offset; #define EXEC_OBJECT_NEEDS_FENCE (1<<0) #define EXEC_OBJECT_NEEDS_GTT (1<<1) #define EXEC_OBJECT_WRITE (1<<2) #define EXEC_OBJECT_SUPPORTS_48B_ADDRESS (1<<3) #define EXEC_OBJECT_PINNED (1<<4) #define EXEC_OBJECT_PAD_TO_SIZE (1<<5) /* The kernel implicitly tracks GPU activity on all GEM objects, and * synchronises operations with outstanding rendering. This includes * rendering on other devices if exported via dma-buf. However, sometimes * this tracking is too coarse and the user knows better. For example, * if the object is split into non-overlapping ranges shared between different * clients or engines (i.e. suballocating objects), the implicit tracking * by kernel assumes that each operation affects the whole object rather * than an individual range, causing needless synchronisation between clients. * The kernel will also forgo any CPU cache flushes prior to rendering from * the object as the client is expected to be also handling such domain * tracking. * * The kernel maintains the implicit tracking in order to manage resources * used by the GPU - this flag only disables the synchronisation prior to * rendering with this object in this execbuf. * * Opting out of implicit synhronisation requires the user to do its own * explicit tracking to avoid rendering corruption. See, for example, * I915_PARAM_HAS_EXEC_FENCE to order execbufs and execute them asynchronously. */ #define EXEC_OBJECT_ASYNC (1<<6) /* Request that the contents of this execobject be copied into the error * state upon a GPU hang involving this batch for post-mortem debugging. * These buffers are recorded in no particular order as "user" in * /sys/class/drm/cardN/error. Query I915_PARAM_HAS_EXEC_CAPTURE to see * if the kernel supports this flag. */ #define EXEC_OBJECT_CAPTURE (1<<7) /* All remaining bits are MBZ and RESERVED FOR FUTURE USE */ #define __EXEC_OBJECT_UNKNOWN_FLAGS -(EXEC_OBJECT_CAPTURE<<1) __u64 flags; union { __u64 rsvd1; __u64 pad_to_size; }; __u64 rsvd2; }; /** * struct drm_i915_gem_exec_fence - An input or output fence for the execbuf * ioctl. * * The request will wait for input fence to signal before submission. * * The returned output fence will be signaled after the completion of the * request. */ struct drm_i915_gem_exec_fence { /** @handle: User's handle for a drm_syncobj to wait on or signal. */ __u32 handle; /** * @flags: Supported flags are: * * I915_EXEC_FENCE_WAIT: * Wait for the input fence before request submission. * * I915_EXEC_FENCE_SIGNAL: * Return request completion fence as output */ __u32 flags; #define I915_EXEC_FENCE_WAIT (1<<0) #define I915_EXEC_FENCE_SIGNAL (1<<1) #define __I915_EXEC_FENCE_UNKNOWN_FLAGS (-(I915_EXEC_FENCE_SIGNAL << 1)) }; /** * struct drm_i915_gem_execbuffer_ext_timeline_fences - Timeline fences * for execbuf ioctl. * * This structure describes an array of drm_syncobj and associated points for * timeline variants of drm_syncobj. It is invalid to append this structure to * the execbuf if I915_EXEC_FENCE_ARRAY is set. */ struct drm_i915_gem_execbuffer_ext_timeline_fences { #define DRM_I915_GEM_EXECBUFFER_EXT_TIMELINE_FENCES 0 /** @base: Extension link. See struct i915_user_extension. */ struct i915_user_extension base; /** * @fence_count: Number of elements in the @handles_ptr & @value_ptr * arrays. */ __u64 fence_count; /** * @handles_ptr: Pointer to an array of struct drm_i915_gem_exec_fence * of length @fence_count. */ __u64 handles_ptr; /** * @values_ptr: Pointer to an array of u64 values of length * @fence_count. * Values must be 0 for a binary drm_syncobj. A Value of 0 for a * timeline drm_syncobj is invalid as it turns a drm_syncobj into a * binary one. */ __u64 values_ptr; }; /** * struct drm_i915_gem_execbuffer2 - Structure for DRM_I915_GEM_EXECBUFFER2 * ioctl. */ struct drm_i915_gem_execbuffer2 { /** @buffers_ptr: Pointer to a list of gem_exec_object2 structs */ __u64 buffers_ptr; /** @buffer_count: Number of elements in @buffers_ptr array */ __u32 buffer_count; /** * @batch_start_offset: Offset in the batchbuffer to start execution * from. */ __u32 batch_start_offset; /** * @batch_len: Length in bytes of the batch buffer, starting from the * @batch_start_offset. If 0, length is assumed to be the batch buffer * object size. */ __u32 batch_len; /** @DR1: deprecated */ __u32 DR1; /** @DR4: deprecated */ __u32 DR4; /** @num_cliprects: See @cliprects_ptr */ __u32 num_cliprects; /** * @cliprects_ptr: Kernel clipping was a DRI1 misfeature. * * It is invalid to use this field if I915_EXEC_FENCE_ARRAY or * I915_EXEC_USE_EXTENSIONS flags are not set. * * If I915_EXEC_FENCE_ARRAY is set, then this is a pointer to an array * of &drm_i915_gem_exec_fence and @num_cliprects is the length of the * array. * * If I915_EXEC_USE_EXTENSIONS is set, then this is a pointer to a * single &i915_user_extension and num_cliprects is 0. */ __u64 cliprects_ptr; /** @flags: Execbuf flags */ __u64 flags; #define I915_EXEC_RING_MASK (0x3f) #define I915_EXEC_DEFAULT (0<<0) #define I915_EXEC_RENDER (1<<0) #define I915_EXEC_BSD (2<<0) #define I915_EXEC_BLT (3<<0) #define I915_EXEC_VEBOX (4<<0) /* Used for switching the constants addressing mode on gen4+ RENDER ring. * Gen6+ only supports relative addressing to dynamic state (default) and * absolute addressing. * * These flags are ignored for the BSD and BLT rings. */ #define I915_EXEC_CONSTANTS_MASK (3<<6) #define I915_EXEC_CONSTANTS_REL_GENERAL (0<<6) /* default */ #define I915_EXEC_CONSTANTS_ABSOLUTE (1<<6) #define I915_EXEC_CONSTANTS_REL_SURFACE (2<<6) /* gen4/5 only */ /** Resets the SO write offset registers for transform feedback on gen7. */ #define I915_EXEC_GEN7_SOL_RESET (1<<8) /** Request a privileged ("secure") batch buffer. Note only available for * DRM_ROOT_ONLY | DRM_MASTER processes. */ #define I915_EXEC_SECURE (1<<9) /** Inform the kernel that the batch is and will always be pinned. This * negates the requirement for a workaround to be performed to avoid * an incoherent CS (such as can be found on 830/845). If this flag is * not passed, the kernel will endeavour to make sure the batch is * coherent with the CS before execution. If this flag is passed, * userspace assumes the responsibility for ensuring the same. */ #define I915_EXEC_IS_PINNED (1<<10) /** Provide a hint to the kernel that the command stream and auxiliary * state buffers already holds the correct presumed addresses and so the * relocation process may be skipped if no buffers need to be moved in * preparation for the execbuffer. */ #define I915_EXEC_NO_RELOC (1<<11) /** Use the reloc.handle as an index into the exec object array rather * than as the per-file handle. */ #define I915_EXEC_HANDLE_LUT (1<<12) /** Used for switching BSD rings on the platforms with two BSD rings */ #define I915_EXEC_BSD_SHIFT (13) #define I915_EXEC_BSD_MASK (3 << I915_EXEC_BSD_SHIFT) /* default ping-pong mode */ #define I915_EXEC_BSD_DEFAULT (0 << I915_EXEC_BSD_SHIFT) #define I915_EXEC_BSD_RING1 (1 << I915_EXEC_BSD_SHIFT) #define I915_EXEC_BSD_RING2 (2 << I915_EXEC_BSD_SHIFT) /** Tell the kernel that the batchbuffer is processed by * the resource streamer. */ #define I915_EXEC_RESOURCE_STREAMER (1<<15) /* Setting I915_EXEC_FENCE_IN implies that lower_32_bits(rsvd2) represent * a sync_file fd to wait upon (in a nonblocking manner) prior to executing * the batch. * * Returns -EINVAL if the sync_file fd cannot be found. */ #define I915_EXEC_FENCE_IN (1<<16) /* Setting I915_EXEC_FENCE_OUT causes the ioctl to return a sync_file fd * in the upper_32_bits(rsvd2) upon success. Ownership of the fd is given * to the caller, and it should be close() after use. (The fd is a regular * file descriptor and will be cleaned up on process termination. It holds * a reference to the request, but nothing else.) * * The sync_file fd can be combined with other sync_file and passed either * to execbuf using I915_EXEC_FENCE_IN, to atomic KMS ioctls (so that a flip * will only occur after this request completes), or to other devices. * * Using I915_EXEC_FENCE_OUT requires use of * DRM_IOCTL_I915_GEM_EXECBUFFER2_WR ioctl so that the result is written * back to userspace. Failure to do so will cause the out-fence to always * be reported as zero, and the real fence fd to be leaked. */ #define I915_EXEC_FENCE_OUT (1<<17) /* * Traditionally the execbuf ioctl has only considered the final element in * the execobject[] to be the executable batch. Often though, the client * will known the batch object prior to construction and being able to place * it into the execobject[] array first can simplify the relocation tracking. * Setting I915_EXEC_BATCH_FIRST tells execbuf to use element 0 of the * execobject[] as the * batch instead (the default is to use the last * element). */ #define I915_EXEC_BATCH_FIRST (1<<18) /* Setting I915_FENCE_ARRAY implies that num_cliprects and cliprects_ptr * define an array of i915_gem_exec_fence structures which specify a set of * dma fences to wait upon or signal. */ #define I915_EXEC_FENCE_ARRAY (1<<19) /* * Setting I915_EXEC_FENCE_SUBMIT implies that lower_32_bits(rsvd2) represent * a sync_file fd to wait upon (in a nonblocking manner) prior to executing * the batch. * * Returns -EINVAL if the sync_file fd cannot be found. */ #define I915_EXEC_FENCE_SUBMIT (1 << 20) /* * Setting I915_EXEC_USE_EXTENSIONS implies that * drm_i915_gem_execbuffer2.cliprects_ptr is treated as a pointer to an linked * list of i915_user_extension. Each i915_user_extension node is the base of a * larger structure. The list of supported structures are listed in the * drm_i915_gem_execbuffer_ext enum. */ #define I915_EXEC_USE_EXTENSIONS (1 << 21) #define __I915_EXEC_UNKNOWN_FLAGS (-(I915_EXEC_USE_EXTENSIONS << 1)) /** @rsvd1: Context id */ __u64 rsvd1; /** * @rsvd2: in and out sync_file file descriptors. * * When I915_EXEC_FENCE_IN or I915_EXEC_FENCE_SUBMIT flag is set, the * lower 32 bits of this field will have the in sync_file fd (input). * * When I915_EXEC_FENCE_OUT flag is set, the upper 32 bits of this * field will have the out sync_file fd (output). */ __u64 rsvd2; }; #define I915_EXEC_CONTEXT_ID_MASK (0xffffffff) #define i915_execbuffer2_set_context_id(eb2, context) \ (eb2).rsvd1 = context & I915_EXEC_CONTEXT_ID_MASK #define i915_execbuffer2_get_context_id(eb2) \ ((eb2).rsvd1 & I915_EXEC_CONTEXT_ID_MASK) struct drm_i915_gem_pin { /** Handle of the buffer to be pinned. */ __u32 handle; __u32 pad; /** alignment required within the aperture */ __u64 alignment; /** Returned GTT offset of the buffer. */ __u64 offset; }; struct drm_i915_gem_unpin { /** Handle of the buffer to be unpinned. */ __u32 handle; __u32 pad; }; struct drm_i915_gem_busy { /** Handle of the buffer to check for busy */ __u32 handle; /** Return busy status * * A return of 0 implies that the object is idle (after * having flushed any pending activity), and a non-zero return that * the object is still in-flight on the GPU. (The GPU has not yet * signaled completion for all pending requests that reference the * object.) An object is guaranteed to become idle eventually (so * long as no new GPU commands are executed upon it). Due to the * asynchronous nature of the hardware, an object reported * as busy may become idle before the ioctl is completed. * * Furthermore, if the object is busy, which engine is busy is only * provided as a guide and only indirectly by reporting its class * (there may be more than one engine in each class). There are race * conditions which prevent the report of which engines are busy from * being always accurate. However, the converse is not true. If the * object is idle, the result of the ioctl, that all engines are idle, * is accurate. * * The returned dword is split into two fields to indicate both * the engine classes on which the object is being read, and the * engine class on which it is currently being written (if any). * * The low word (bits 0:15) indicate if the object is being written * to by any engine (there can only be one, as the GEM implicit * synchronisation rules force writes to be serialised). Only the * engine class (offset by 1, I915_ENGINE_CLASS_RENDER is reported as * 1 not 0 etc) for the last write is reported. * * The high word (bits 16:31) are a bitmask of which engines classes * are currently reading from the object. Multiple engines may be * reading from the object simultaneously. * * The value of each engine class is the same as specified in the * I915_CONTEXT_PARAM_ENGINES context parameter and via perf, i.e. * I915_ENGINE_CLASS_RENDER, I915_ENGINE_CLASS_COPY, etc. * Some hardware may have parallel execution engines, e.g. multiple * media engines, which are mapped to the same class identifier and so * are not separately reported for busyness. * * Caveat emptor: * Only the boolean result of this query is reliable; that is whether * the object is idle or busy. The report of which engines are busy * should be only used as a heuristic. */ __u32 busy; }; /** * struct drm_i915_gem_caching - Set or get the caching for given object * handle. * * Allow userspace to control the GTT caching bits for a given object when the * object is later mapped through the ppGTT(or GGTT on older platforms lacking * ppGTT support, or if the object is used for scanout). Note that this might * require unbinding the object from the GTT first, if its current caching value * doesn't match. * * Note that this all changes on discrete platforms, starting from DG1, the * set/get caching is no longer supported, and is now rejected. Instead the CPU * caching attributes(WB vs WC) will become an immutable creation time property * for the object, along with the GTT caching level. For now we don't expose any * new uAPI for this, instead on DG1 this is all implicit, although this largely * shouldn't matter since DG1 is coherent by default(without any way of * controlling it). * * Implicit caching rules, starting from DG1: * * - If any of the object placements (see &drm_i915_gem_create_ext_memory_regions) * contain I915_MEMORY_CLASS_DEVICE then the object will be allocated and * mapped as write-combined only. * * - Everything else is always allocated and mapped as write-back, with the * guarantee that everything is also coherent with the GPU. * * Note that this is likely to change in the future again, where we might need * more flexibility on future devices, so making this all explicit as part of a * new &drm_i915_gem_create_ext extension is probable. * * Side note: Part of the reason for this is that changing the at-allocation-time CPU * caching attributes for the pages might be required(and is expensive) if we * need to then CPU map the pages later with different caching attributes. This * inconsistent caching behaviour, while supported on x86, is not universally * supported on other architectures. So for simplicity we opt for setting * everything at creation time, whilst also making it immutable, on discrete * platforms. */ struct drm_i915_gem_caching { /** * @handle: Handle of the buffer to set/get the caching level. */ __u32 handle; /** * @caching: The GTT caching level to apply or possible return value. * * The supported @caching values: * * I915_CACHING_NONE: * * GPU access is not coherent with CPU caches. Default for machines * without an LLC. This means manual flushing might be needed, if we * want GPU access to be coherent. * * I915_CACHING_CACHED: * * GPU access is coherent with CPU caches and furthermore the data is * cached in last-level caches shared between CPU cores and the GPU GT. * * I915_CACHING_DISPLAY: * * Special GPU caching mode which is coherent with the scanout engines. * Transparently falls back to I915_CACHING_NONE on platforms where no * special cache mode (like write-through or gfdt flushing) is * available. The kernel automatically sets this mode when using a * buffer as a scanout target. Userspace can manually set this mode to * avoid a costly stall and clflush in the hotpath of drawing the first * frame. */ #define I915_CACHING_NONE 0 #define I915_CACHING_CACHED 1 #define I915_CACHING_DISPLAY 2 __u32 caching; }; #define I915_TILING_NONE 0 #define I915_TILING_X 1 #define I915_TILING_Y 2 /* * Do not add new tiling types here. The I915_TILING_* values are for * de-tiling fence registers that no longer exist on modern platforms. Although * the hardware may support new types of tiling in general (e.g., Tile4), we * do not need to add them to the uapi that is specific to now-defunct ioctls. */ #define I915_TILING_LAST I915_TILING_Y #define I915_BIT_6_SWIZZLE_NONE 0 #define I915_BIT_6_SWIZZLE_9 1 #define I915_BIT_6_SWIZZLE_9_10 2 #define I915_BIT_6_SWIZZLE_9_11 3 #define I915_BIT_6_SWIZZLE_9_10_11 4 /* Not seen by userland */ #define I915_BIT_6_SWIZZLE_UNKNOWN 5 /* Seen by userland. */ #define I915_BIT_6_SWIZZLE_9_17 6 #define I915_BIT_6_SWIZZLE_9_10_17 7 struct drm_i915_gem_set_tiling { /** Handle of the buffer to have its tiling state updated */ __u32 handle; /** * Tiling mode for the object (I915_TILING_NONE, I915_TILING_X, * I915_TILING_Y). * * This value is to be set on request, and will be updated by the * kernel on successful return with the actual chosen tiling layout. * * The tiling mode may be demoted to I915_TILING_NONE when the system * has bit 6 swizzling that can't be managed correctly by GEM. * * Buffer contents become undefined when changing tiling_mode. */ __u32 tiling_mode; /** * Stride in bytes for the object when in I915_TILING_X or * I915_TILING_Y. */ __u32 stride; /** * Returned address bit 6 swizzling required for CPU access through * mmap mapping. */ __u32 swizzle_mode; }; struct drm_i915_gem_get_tiling { /** Handle of the buffer to get tiling state for. */ __u32 handle; /** * Current tiling mode for the object (I915_TILING_NONE, I915_TILING_X, * I915_TILING_Y). */ __u32 tiling_mode; /** * Returned address bit 6 swizzling required for CPU access through * mmap mapping. */ __u32 swizzle_mode; /** * Returned address bit 6 swizzling required for CPU access through * mmap mapping whilst bound. */ __u32 phys_swizzle_mode; }; struct drm_i915_gem_get_aperture { /** Total size of the aperture used by i915_gem_execbuffer, in bytes */ __u64 aper_size; /** * Available space in the aperture used by i915_gem_execbuffer, in * bytes */ __u64 aper_available_size; }; struct drm_i915_get_pipe_from_crtc_id { /** ID of CRTC being requested **/ __u32 crtc_id; /** pipe of requested CRTC **/ __u32 pipe; }; #define I915_MADV_WILLNEED 0 #define I915_MADV_DONTNEED 1 #define __I915_MADV_PURGED 2 /* internal state */ struct drm_i915_gem_madvise { /** Handle of the buffer to change the backing store advice */ __u32 handle; /* Advice: either the buffer will be needed again in the near future, * or won't be and could be discarded under memory pressure. */ __u32 madv; /** Whether the backing store still exists. */ __u32 retained; }; /* flags */ #define I915_OVERLAY_TYPE_MASK 0xff #define I915_OVERLAY_YUV_PLANAR 0x01 #define I915_OVERLAY_YUV_PACKED 0x02 #define I915_OVERLAY_RGB 0x03 #define I915_OVERLAY_DEPTH_MASK 0xff00 #define I915_OVERLAY_RGB24 0x1000 #define I915_OVERLAY_RGB16 0x2000 #define I915_OVERLAY_RGB15 0x3000 #define I915_OVERLAY_YUV422 0x0100 #define I915_OVERLAY_YUV411 0x0200 #define I915_OVERLAY_YUV420 0x0300 #define I915_OVERLAY_YUV410 0x0400 #define I915_OVERLAY_SWAP_MASK 0xff0000 #define I915_OVERLAY_NO_SWAP 0x000000 #define I915_OVERLAY_UV_SWAP 0x010000 #define I915_OVERLAY_Y_SWAP 0x020000 #define I915_OVERLAY_Y_AND_UV_SWAP 0x030000 #define I915_OVERLAY_FLAGS_MASK 0xff000000 #define I915_OVERLAY_ENABLE 0x01000000 struct drm_intel_overlay_put_image { /* various flags and src format description */ __u32 flags; /* source picture description */ __u32 bo_handle; /* stride values and offsets are in bytes, buffer relative */ __u16 stride_Y; /* stride for packed formats */ __u16 stride_UV; __u32 offset_Y; /* offset for packet formats */ __u32 offset_U; __u32 offset_V; /* in pixels */ __u16 src_width; __u16 src_height; /* to compensate the scaling factors for partially covered surfaces */ __u16 src_scan_width; __u16 src_scan_height; /* output crtc description */ __u32 crtc_id; __u16 dst_x; __u16 dst_y; __u16 dst_width; __u16 dst_height; }; /* flags */ #define I915_OVERLAY_UPDATE_ATTRS (1<<0) #define I915_OVERLAY_UPDATE_GAMMA (1<<1) #define I915_OVERLAY_DISABLE_DEST_COLORKEY (1<<2) struct drm_intel_overlay_attrs { __u32 flags; __u32 color_key; __s32 brightness; __u32 contrast; __u32 saturation; __u32 gamma0; __u32 gamma1; __u32 gamma2; __u32 gamma3; __u32 gamma4; __u32 gamma5; }; /* * Intel sprite handling * * Color keying works with a min/mask/max tuple. Both source and destination * color keying is allowed. * * Source keying: * Sprite pixels within the min & max values, masked against the color channels * specified in the mask field, will be transparent. All other pixels will * be displayed on top of the primary plane. For RGB surfaces, only the min * and mask fields will be used; ranged compares are not allowed. * * Destination keying: * Primary plane pixels that match the min value, masked against the color * channels specified in the mask field, will be replaced by corresponding * pixels from the sprite plane. * * Note that source & destination keying are exclusive; only one can be * active on a given plane. */ #define I915_SET_COLORKEY_NONE (1<<0) /* Deprecated. Instead set * flags==0 to disable colorkeying. */ #define I915_SET_COLORKEY_DESTINATION (1<<1) #define I915_SET_COLORKEY_SOURCE (1<<2) struct drm_intel_sprite_colorkey { __u32 plane_id; __u32 min_value; __u32 channel_mask; __u32 max_value; __u32 flags; }; struct drm_i915_gem_wait { /** Handle of BO we shall wait on */ __u32 bo_handle; __u32 flags; /** Number of nanoseconds to wait, Returns time remaining. */ __s64 timeout_ns; }; struct drm_i915_gem_context_create { __u32 ctx_id; /* output: id of new context*/ __u32 pad; }; /** * struct drm_i915_gem_context_create_ext - Structure for creating contexts. */ struct drm_i915_gem_context_create_ext { /** @ctx_id: Id of the created context (output) */ __u32 ctx_id; /** * @flags: Supported flags are: * * I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS: * * Extensions may be appended to this structure and driver must check * for those. See @extensions. * * I915_CONTEXT_CREATE_FLAGS_SINGLE_TIMELINE * * Created context will have single timeline. */ __u32 flags; #define I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS (1u << 0) #define I915_CONTEXT_CREATE_FLAGS_SINGLE_TIMELINE (1u << 1) #define I915_CONTEXT_CREATE_FLAGS_UNKNOWN \ (-(I915_CONTEXT_CREATE_FLAGS_SINGLE_TIMELINE << 1)) /** * @extensions: Zero-terminated chain of extensions. * * I915_CONTEXT_CREATE_EXT_SETPARAM: * Context parameter to set or query during context creation. * See struct drm_i915_gem_context_create_ext_setparam. * * I915_CONTEXT_CREATE_EXT_CLONE: * This extension has been removed. On the off chance someone somewhere * has attempted to use it, never re-use this extension number. */ __u64 extensions; #define I915_CONTEXT_CREATE_EXT_SETPARAM 0 #define I915_CONTEXT_CREATE_EXT_CLONE 1 }; /** * struct drm_i915_gem_context_param - Context parameter to set or query. */ struct drm_i915_gem_context_param { /** @ctx_id: Context id */ __u32 ctx_id; /** @size: Size of the parameter @value */ __u32 size; /** @param: Parameter to set or query */ __u64 param; #define I915_CONTEXT_PARAM_BAN_PERIOD 0x1 /* I915_CONTEXT_PARAM_NO_ZEROMAP has been removed. On the off chance * someone somewhere has attempted to use it, never re-use this context * param number. */ #define I915_CONTEXT_PARAM_NO_ZEROMAP 0x2 #define I915_CONTEXT_PARAM_GTT_SIZE 0x3 #define I915_CONTEXT_PARAM_NO_ERROR_CAPTURE 0x4 #define I915_CONTEXT_PARAM_BANNABLE 0x5 #define I915_CONTEXT_PARAM_PRIORITY 0x6 #define I915_CONTEXT_MAX_USER_PRIORITY 1023 /* inclusive */ #define I915_CONTEXT_DEFAULT_PRIORITY 0 #define I915_CONTEXT_MIN_USER_PRIORITY -1023 /* inclusive */ /* * When using the following param, value should be a pointer to * drm_i915_gem_context_param_sseu. */ #define I915_CONTEXT_PARAM_SSEU 0x7 /* * Not all clients may want to attempt automatic recover of a context after * a hang (for example, some clients may only submit very small incremental * batches relying on known logical state of previous batches which will never * recover correctly and each attempt will hang), and so would prefer that * the context is forever banned instead. * * If set to false (0), after a reset, subsequent (and in flight) rendering * from this context is discarded, and the client will need to create a new * context to use instead. * * If set to true (1), the kernel will automatically attempt to recover the * context by skipping the hanging batch and executing the next batch starting * from the default context state (discarding the incomplete logical context * state lost due to the reset). * * On creation, all new contexts are marked as recoverable. */ #define I915_CONTEXT_PARAM_RECOVERABLE 0x8 /* * The id of the associated virtual memory address space (ppGTT) of * this context. Can be retrieved and passed to another context * (on the same fd) for both to use the same ppGTT and so share * address layouts, and avoid reloading the page tables on context * switches between themselves. * * See DRM_I915_GEM_VM_CREATE and DRM_I915_GEM_VM_DESTROY. */ #define I915_CONTEXT_PARAM_VM 0x9 /* * I915_CONTEXT_PARAM_ENGINES: * * Bind this context to operate on this subset of available engines. Henceforth, * the I915_EXEC_RING selector for DRM_IOCTL_I915_GEM_EXECBUFFER2 operates as * an index into this array of engines; I915_EXEC_DEFAULT selecting engine[0] * and upwards. Slots 0...N are filled in using the specified (class, instance). * Use * engine_class: I915_ENGINE_CLASS_INVALID, * engine_instance: I915_ENGINE_CLASS_INVALID_NONE * to specify a gap in the array that can be filled in later, e.g. by a * virtual engine used for load balancing. * * Setting the number of engines bound to the context to 0, by passing a zero * sized argument, will revert back to default settings. * * See struct i915_context_param_engines. * * Extensions: * i915_context_engines_load_balance (I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE) * i915_context_engines_bond (I915_CONTEXT_ENGINES_EXT_BOND) * i915_context_engines_parallel_submit (I915_CONTEXT_ENGINES_EXT_PARALLEL_SUBMIT) */ #define I915_CONTEXT_PARAM_ENGINES 0xa /* * I915_CONTEXT_PARAM_PERSISTENCE: * * Allow the context and active rendering to survive the process until * completion. Persistence allows fire-and-forget clients to queue up a * bunch of work, hand the output over to a display server and then quit. * If the context is marked as not persistent, upon closing (either via * an explicit DRM_I915_GEM_CONTEXT_DESTROY or implicitly from file closure * or process termination), the context and any outstanding requests will be * cancelled (and exported fences for cancelled requests marked as -EIO). * * By default, new contexts allow persistence. */ #define I915_CONTEXT_PARAM_PERSISTENCE 0xb /* This API has been removed. On the off chance someone somewhere has * attempted to use it, never re-use this context param number. */ #define I915_CONTEXT_PARAM_RINGSIZE 0xc /* * I915_CONTEXT_PARAM_PROTECTED_CONTENT: * * Mark that the context makes use of protected content, which will result * in the context being invalidated when the protected content session is. * Given that the protected content session is killed on suspend, the device * is kept awake for the lifetime of a protected context, so the user should * make sure to dispose of them once done. * This flag can only be set at context creation time and, when set to true, * must be preceded by an explicit setting of I915_CONTEXT_PARAM_RECOVERABLE * to false. This flag can't be set to true in conjunction with setting the * I915_CONTEXT_PARAM_BANNABLE flag to false. Creation example: * * .. code-block:: C * * struct drm_i915_gem_context_create_ext_setparam p_protected = { * .base = { * .name = I915_CONTEXT_CREATE_EXT_SETPARAM, * }, * .param = { * .param = I915_CONTEXT_PARAM_PROTECTED_CONTENT, * .value = 1, * } * }; * struct drm_i915_gem_context_create_ext_setparam p_norecover = { * .base = { * .name = I915_CONTEXT_CREATE_EXT_SETPARAM, * .next_extension = to_user_pointer(&p_protected), * }, * .param = { * .param = I915_CONTEXT_PARAM_RECOVERABLE, * .value = 0, * } * }; * struct drm_i915_gem_context_create_ext create = { * .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, * .extensions = to_user_pointer(&p_norecover); * }; * * ctx_id = gem_context_create_ext(drm_fd, &create); * * In addition to the normal failure cases, setting this flag during context * creation can result in the following errors: * * -ENODEV: feature not available * -EPERM: trying to mark a recoverable or not bannable context as protected * -ENXIO: A dependency such as a component driver or firmware is not yet * loaded so user space may need to attempt again. Depending on the * device, this error may be reported if protected context creation is * attempted very early after kernel start because the internal timeout * waiting for such dependencies is not guaranteed to be larger than * required (numbers differ depending on system and kernel config): * - ADL/RPL: dependencies may take up to 3 seconds from kernel start * while context creation internal timeout is 250 milisecs * - MTL: dependencies may take up to 8 seconds from kernel start * while context creation internal timeout is 250 milisecs * NOTE: such dependencies happen once, so a subsequent call to create a * protected context after a prior successful call will not experience * such timeouts and will not return -ENXIO (unless the driver is reloaded, * or, depending on the device, resumes from a suspended state). * -EIO: The firmware did not succeed in creating the protected context. */ #define I915_CONTEXT_PARAM_PROTECTED_CONTENT 0xd /* Must be kept compact -- no holes and well documented */ /** @value: Context parameter value to be set or queried */ __u64 value; }; /* * Context SSEU programming * * It may be necessary for either functional or performance reason to configure * a context to run with a reduced number of SSEU (where SSEU stands for Slice/ * Sub-slice/EU). * * This is done by configuring SSEU configuration using the below * @struct drm_i915_gem_context_param_sseu for every supported engine which * userspace intends to use. * * Not all GPUs or engines support this functionality in which case an error * code -ENODEV will be returned. * * Also, flexibility of possible SSEU configuration permutations varies between * GPU generations and software imposed limitations. Requesting such a * combination will return an error code of -EINVAL. * * NOTE: When perf/OA is active the context's SSEU configuration is ignored in * favour of a single global setting. */ struct drm_i915_gem_context_param_sseu { /* * Engine class & instance to be configured or queried. */ struct i915_engine_class_instance engine; /* * Unknown flags must be cleared to zero. */ __u32 flags; #define I915_CONTEXT_SSEU_FLAG_ENGINE_INDEX (1u << 0) /* * Mask of slices to enable for the context. Valid values are a subset * of the bitmask value returned for I915_PARAM_SLICE_MASK. */ __u64 slice_mask; /* * Mask of subslices to enable for the context. Valid values are a * subset of the bitmask value return by I915_PARAM_SUBSLICE_MASK. */ __u64 subslice_mask; /* * Minimum/Maximum number of EUs to enable per subslice for the * context. min_eus_per_subslice must be inferior or equal to * max_eus_per_subslice. */ __u16 min_eus_per_subslice; __u16 max_eus_per_subslice; /* * Unused for now. Must be cleared to zero. */ __u32 rsvd; }; /** * DOC: Virtual Engine uAPI * * Virtual engine is a concept where userspace is able to configure a set of * physical engines, submit a batch buffer, and let the driver execute it on any * engine from the set as it sees fit. * * This is primarily useful on parts which have multiple instances of a same * class engine, like for example GT3+ Skylake parts with their two VCS engines. * * For instance userspace can enumerate all engines of a certain class using the * previously described `Engine Discovery uAPI`_. After that userspace can * create a GEM context with a placeholder slot for the virtual engine (using * `I915_ENGINE_CLASS_INVALID` and `I915_ENGINE_CLASS_INVALID_NONE` for class * and instance respectively) and finally using the * `I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE` extension place a virtual engine in * the same reserved slot. * * Example of creating a virtual engine and submitting a batch buffer to it: * * .. code-block:: C * * I915_DEFINE_CONTEXT_ENGINES_LOAD_BALANCE(virtual, 2) = { * .base.name = I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE, * .engine_index = 0, // Place this virtual engine into engine map slot 0 * .num_siblings = 2, * .engines = { { I915_ENGINE_CLASS_VIDEO, 0 }, * { I915_ENGINE_CLASS_VIDEO, 1 }, }, * }; * I915_DEFINE_CONTEXT_PARAM_ENGINES(engines, 1) = { * .engines = { { I915_ENGINE_CLASS_INVALID, * I915_ENGINE_CLASS_INVALID_NONE } }, * .extensions = to_user_pointer(&virtual), // Chains after load_balance extension * }; * struct drm_i915_gem_context_create_ext_setparam p_engines = { * .base = { * .name = I915_CONTEXT_CREATE_EXT_SETPARAM, * }, * .param = { * .param = I915_CONTEXT_PARAM_ENGINES, * .value = to_user_pointer(&engines), * .size = sizeof(engines), * }, * }; * struct drm_i915_gem_context_create_ext create = { * .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, * .extensions = to_user_pointer(&p_engines); * }; * * ctx_id = gem_context_create_ext(drm_fd, &create); * * // Now we have created a GEM context with its engine map containing a * // single virtual engine. Submissions to this slot can go either to * // vcs0 or vcs1, depending on the load balancing algorithm used inside * // the driver. The load balancing is dynamic from one batch buffer to * // another and transparent to userspace. * * ... * execbuf.rsvd1 = ctx_id; * execbuf.flags = 0; // Submits to index 0 which is the virtual engine * gem_execbuf(drm_fd, &execbuf); */ /* * i915_context_engines_load_balance: * * Enable load balancing across this set of engines. * * Into the I915_EXEC_DEFAULT slot [0], a virtual engine is created that when * used will proxy the execbuffer request onto one of the set of engines * in such a way as to distribute the load evenly across the set. * * The set of engines must be compatible (e.g. the same HW class) as they * will share the same logical GPU context and ring. * * To intermix rendering with the virtual engine and direct rendering onto * the backing engines (bypassing the load balancing proxy), the context must * be defined to use a single timeline for all engines. */ struct i915_context_engines_load_balance { struct i915_user_extension base; __u16 engine_index; __u16 num_siblings; __u32 flags; /* all undefined flags must be zero */ __u64 mbz64; /* reserved for future use; must be zero */ struct i915_engine_class_instance engines[]; } __attribute__((packed)); #define I915_DEFINE_CONTEXT_ENGINES_LOAD_BALANCE(name__, N__) struct { \ struct i915_user_extension base; \ __u16 engine_index; \ __u16 num_siblings; \ __u32 flags; \ __u64 mbz64; \ struct i915_engine_class_instance engines[N__]; \ } __attribute__((packed)) name__ /* * i915_context_engines_bond: * * Constructed bonded pairs for execution within a virtual engine. * * All engines are equal, but some are more equal than others. Given * the distribution of resources in the HW, it may be preferable to run * a request on a given subset of engines in parallel to a request on a * specific engine. We enable this selection of engines within a virtual * engine by specifying bonding pairs, for any given master engine we will * only execute on one of the corresponding siblings within the virtual engine. * * To execute a request in parallel on the master engine and a sibling requires * coordination with a I915_EXEC_FENCE_SUBMIT. */ struct i915_context_engines_bond { struct i915_user_extension base; struct i915_engine_class_instance master; __u16 virtual_index; /* index of virtual engine in ctx->engines[] */ __u16 num_bonds; __u64 flags; /* all undefined flags must be zero */ __u64 mbz64[4]; /* reserved for future use; must be zero */ struct i915_engine_class_instance engines[]; } __attribute__((packed)); #define I915_DEFINE_CONTEXT_ENGINES_BOND(name__, N__) struct { \ struct i915_user_extension base; \ struct i915_engine_class_instance master; \ __u16 virtual_index; \ __u16 num_bonds; \ __u64 flags; \ __u64 mbz64[4]; \ struct i915_engine_class_instance engines[N__]; \ } __attribute__((packed)) name__ /** * struct i915_context_engines_parallel_submit - Configure engine for * parallel submission. * * Setup a slot in the context engine map to allow multiple BBs to be submitted * in a single execbuf IOCTL. Those BBs will then be scheduled to run on the GPU * in parallel. Multiple hardware contexts are created internally in the i915 to * run these BBs. Once a slot is configured for N BBs only N BBs can be * submitted in each execbuf IOCTL and this is implicit behavior e.g. The user * doesn't tell the execbuf IOCTL there are N BBs, the execbuf IOCTL knows how * many BBs there are based on the slot's configuration. The N BBs are the last * N buffer objects or first N if I915_EXEC_BATCH_FIRST is set. * * The default placement behavior is to create implicit bonds between each * context if each context maps to more than 1 physical engine (e.g. context is * a virtual engine). Also we only allow contexts of same engine class and these * contexts must be in logically contiguous order. Examples of the placement * behavior are described below. Lastly, the default is to not allow BBs to be * preempted mid-batch. Rather insert coordinated preemption points on all * hardware contexts between each set of BBs. Flags could be added in the future * to change both of these default behaviors. * * Returns -EINVAL if hardware context placement configuration is invalid or if * the placement configuration isn't supported on the platform / submission * interface. * Returns -ENODEV if extension isn't supported on the platform / submission * interface. * * .. code-block:: none * * Examples syntax: * CS[X] = generic engine of same class, logical instance X * INVALID = I915_ENGINE_CLASS_INVALID, I915_ENGINE_CLASS_INVALID_NONE * * Example 1 pseudo code: * set_engines(INVALID) * set_parallel(engine_index=0, width=2, num_siblings=1, * engines=CS[0],CS[1]) * * Results in the following valid placement: * CS[0], CS[1] * * Example 2 pseudo code: * set_engines(INVALID) * set_parallel(engine_index=0, width=2, num_siblings=2, * engines=CS[0],CS[2],CS[1],CS[3]) * * Results in the following valid placements: * CS[0], CS[1] * CS[2], CS[3] * * This can be thought of as two virtual engines, each containing two * engines thereby making a 2D array. However, there are bonds tying the * entries together and placing restrictions on how they can be scheduled. * Specifically, the scheduler can choose only vertical columns from the 2D * array. That is, CS[0] is bonded to CS[1] and CS[2] to CS[3]. So if the * scheduler wants to submit to CS[0], it must also choose CS[1] and vice * versa. Same for CS[2] requires also using CS[3]. * VE[0] = CS[0], CS[2] * VE[1] = CS[1], CS[3] * * Example 3 pseudo code: * set_engines(INVALID) * set_parallel(engine_index=0, width=2, num_siblings=2, * engines=CS[0],CS[1],CS[1],CS[3]) * * Results in the following valid and invalid placements: * CS[0], CS[1] * CS[1], CS[3] - Not logically contiguous, return -EINVAL */ struct i915_context_engines_parallel_submit { /** * @base: base user extension. */ struct i915_user_extension base; /** * @engine_index: slot for parallel engine */ __u16 engine_index; /** * @width: number of contexts per parallel engine or in other words the * number of batches in each submission */ __u16 width; /** * @num_siblings: number of siblings per context or in other words the * number of possible placements for each submission */ __u16 num_siblings; /** * @mbz16: reserved for future use; must be zero */ __u16 mbz16; /** * @flags: all undefined flags must be zero, currently not defined flags */ __u64 flags; /** * @mbz64: reserved for future use; must be zero */ __u64 mbz64[3]; /** * @engines: 2-d array of engine instances to configure parallel engine * * length = width (i) * num_siblings (j) * index = j + i * num_siblings */ struct i915_engine_class_instance engines[]; } __attribute__((packed)); #define I915_DEFINE_CONTEXT_ENGINES_PARALLEL_SUBMIT(name__, N__) struct { \ struct i915_user_extension base; \ __u16 engine_index; \ __u16 width; \ __u16 num_siblings; \ __u16 mbz16; \ __u64 flags; \ __u64 mbz64[3]; \ struct i915_engine_class_instance engines[N__]; \ } __attribute__((packed)) name__ /** * DOC: Context Engine Map uAPI * * Context engine map is a new way of addressing engines when submitting batch- * buffers, replacing the existing way of using identifiers like `I915_EXEC_BLT` * inside the flags field of `struct drm_i915_gem_execbuffer2`. * * To use it created GEM contexts need to be configured with a list of engines * the user is intending to submit to. This is accomplished using the * `I915_CONTEXT_PARAM_ENGINES` parameter and `struct * i915_context_param_engines`. * * For such contexts the `I915_EXEC_RING_MASK` field becomes an index into the * configured map. * * Example of creating such context and submitting against it: * * .. code-block:: C * * I915_DEFINE_CONTEXT_PARAM_ENGINES(engines, 2) = { * .engines = { { I915_ENGINE_CLASS_RENDER, 0 }, * { I915_ENGINE_CLASS_COPY, 0 } } * }; * struct drm_i915_gem_context_create_ext_setparam p_engines = { * .base = { * .name = I915_CONTEXT_CREATE_EXT_SETPARAM, * }, * .param = { * .param = I915_CONTEXT_PARAM_ENGINES, * .value = to_user_pointer(&engines), * .size = sizeof(engines), * }, * }; * struct drm_i915_gem_context_create_ext create = { * .flags = I915_CONTEXT_CREATE_FLAGS_USE_EXTENSIONS, * .extensions = to_user_pointer(&p_engines); * }; * * ctx_id = gem_context_create_ext(drm_fd, &create); * * // We have now created a GEM context with two engines in the map: * // Index 0 points to rcs0 while index 1 points to bcs0. Other engines * // will not be accessible from this context. * * ... * execbuf.rsvd1 = ctx_id; * execbuf.flags = 0; // Submits to index 0, which is rcs0 for this context * gem_execbuf(drm_fd, &execbuf); * * ... * execbuf.rsvd1 = ctx_id; * execbuf.flags = 1; // Submits to index 0, which is bcs0 for this context * gem_execbuf(drm_fd, &execbuf); */ struct i915_context_param_engines { __u64 extensions; /* linked chain of extension blocks, 0 terminates */ #define I915_CONTEXT_ENGINES_EXT_LOAD_BALANCE 0 /* see i915_context_engines_load_balance */ #define I915_CONTEXT_ENGINES_EXT_BOND 1 /* see i915_context_engines_bond */ #define I915_CONTEXT_ENGINES_EXT_PARALLEL_SUBMIT 2 /* see i915_context_engines_parallel_submit */ struct i915_engine_class_instance engines[]; } __attribute__((packed)); #define I915_DEFINE_CONTEXT_PARAM_ENGINES(name__, N__) struct { \ __u64 extensions; \ struct i915_engine_class_instance engines[N__]; \ } __attribute__((packed)) name__ /** * struct drm_i915_gem_context_create_ext_setparam - Context parameter * to set or query during context creation. */ struct drm_i915_gem_context_create_ext_setparam { /** @base: Extension link. See struct i915_user_extension. */ struct i915_user_extension base; /** * @param: Context parameter to set or query. * See struct drm_i915_gem_context_param. */ struct drm_i915_gem_context_param param; }; struct drm_i915_gem_context_destroy { __u32 ctx_id; __u32 pad; }; /** * struct drm_i915_gem_vm_control - Structure to create or destroy VM. * * DRM_I915_GEM_VM_CREATE - * * Create a new virtual memory address space (ppGTT) for use within a context * on the same file. Extensions can be provided to configure exactly how the * address space is setup upon creation. * * The id of new VM (bound to the fd) for use with I915_CONTEXT_PARAM_VM is * returned in the outparam @id. * * An extension chain maybe provided, starting with @extensions, and terminated * by the @next_extension being 0. Currently, no extensions are defined. * * DRM_I915_GEM_VM_DESTROY - * * Destroys a previously created VM id, specified in @vm_id. * * No extensions or flags are allowed currently, and so must be zero. */ struct drm_i915_gem_vm_control { /** @extensions: Zero-terminated chain of extensions. */ __u64 extensions; /** @flags: reserved for future usage, currently MBZ */ __u32 flags; /** @vm_id: Id of the VM created or to be destroyed */ __u32 vm_id; }; struct drm_i915_reg_read { /* * Register offset. * For 64bit wide registers where the upper 32bits don't immediately * follow the lower 32bits, the offset of the lower 32bits must * be specified */ __u64 offset; #define I915_REG_READ_8B_WA (1ul << 0) __u64 val; /* Return value */ }; /* Known registers: * * Render engine timestamp - 0x2358 + 64bit - gen7+ * - Note this register returns an invalid value if using the default * single instruction 8byte read, in order to workaround that pass * flag I915_REG_READ_8B_WA in offset field. * */ struct drm_i915_reset_stats { __u32 ctx_id; __u32 flags; /* All resets since boot/module reload, for all contexts */ __u32 reset_count; /* Number of batches lost when active in GPU, for this context */ __u32 batch_active; /* Number of batches lost pending for execution, for this context */ __u32 batch_pending; __u32 pad; }; /** * struct drm_i915_gem_userptr - Create GEM object from user allocated memory. * * Userptr objects have several restrictions on what ioctls can be used with the * object handle. */ struct drm_i915_gem_userptr { /** * @user_ptr: The pointer to the allocated memory. * * Needs to be aligned to PAGE_SIZE. */ __u64 user_ptr; /** * @user_size: * * The size in bytes for the allocated memory. This will also become the * object size. * * Needs to be aligned to PAGE_SIZE, and should be at least PAGE_SIZE, * or larger. */ __u64 user_size; /** * @flags: * * Supported flags: * * I915_USERPTR_READ_ONLY: * * Mark the object as readonly, this also means GPU access can only be * readonly. This is only supported on HW which supports readonly access * through the GTT. If the HW can't support readonly access, an error is * returned. * * I915_USERPTR_PROBE: * * Probe the provided @user_ptr range and validate that the @user_ptr is * indeed pointing to normal memory and that the range is also valid. * For example if some garbage address is given to the kernel, then this * should complain. * * Returns -EFAULT if the probe failed. * * Note that this doesn't populate the backing pages, and also doesn't * guarantee that the object will remain valid when the object is * eventually used. * * The kernel supports this feature if I915_PARAM_HAS_USERPTR_PROBE * returns a non-zero value. * * I915_USERPTR_UNSYNCHRONIZED: * * NOT USED. Setting this flag will result in an error. */ __u32 flags; #define I915_USERPTR_READ_ONLY 0x1 #define I915_USERPTR_PROBE 0x2 #define I915_USERPTR_UNSYNCHRONIZED 0x80000000 /** * @handle: Returned handle for the object. * * Object handles are nonzero. */ __u32 handle; }; enum drm_i915_oa_format { I915_OA_FORMAT_A13 = 1, /* HSW only */ I915_OA_FORMAT_A29, /* HSW only */ I915_OA_FORMAT_A13_B8_C8, /* HSW only */ I915_OA_FORMAT_B4_C8, /* HSW only */ I915_OA_FORMAT_A45_B8_C8, /* HSW only */ I915_OA_FORMAT_B4_C8_A16, /* HSW only */ I915_OA_FORMAT_C4_B8, /* HSW+ */ /* Gen8+ */ I915_OA_FORMAT_A12, I915_OA_FORMAT_A12_B8_C8, I915_OA_FORMAT_A32u40_A4u32_B8_C8, /* DG2 */ I915_OAR_FORMAT_A32u40_A4u32_B8_C8, I915_OA_FORMAT_A24u40_A14u32_B8_C8, /* MTL OAM */ I915_OAM_FORMAT_MPEC8u64_B8_C8, I915_OAM_FORMAT_MPEC8u32_B8_C8, I915_OA_FORMAT_MAX /* non-ABI */ }; enum drm_i915_perf_property_id { /** * Open the stream for a specific context handle (as used with * execbuffer2). A stream opened for a specific context this way * won't typically require root privileges. * * This property is available in perf revision 1. */ DRM_I915_PERF_PROP_CTX_HANDLE = 1, /** * A value of 1 requests the inclusion of raw OA unit reports as * part of stream samples. * * This property is available in perf revision 1. */ DRM_I915_PERF_PROP_SAMPLE_OA, /** * The value specifies which set of OA unit metrics should be * configured, defining the contents of any OA unit reports. * * This property is available in perf revision 1. */ DRM_I915_PERF_PROP_OA_METRICS_SET, /** * The value specifies the size and layout of OA unit reports. * * This property is available in perf revision 1. */ DRM_I915_PERF_PROP_OA_FORMAT, /** * Specifying this property implicitly requests periodic OA unit * sampling and (at least on Haswell) the sampling frequency is derived * from this exponent as follows: * * 80ns * 2^(period_exponent + 1) * * This property is available in perf revision 1. */ DRM_I915_PERF_PROP_OA_EXPONENT, /** * Specifying this property is only valid when specify a context to * filter with DRM_I915_PERF_PROP_CTX_HANDLE. Specifying this property * will hold preemption of the particular context we want to gather * performance data about. The execbuf2 submissions must include a * drm_i915_gem_execbuffer_ext_perf parameter for this to apply. * * This property is available in perf revision 3. */ DRM_I915_PERF_PROP_HOLD_PREEMPTION, /** * Specifying this pins all contexts to the specified SSEU power * configuration for the duration of the recording. * * This parameter's value is a pointer to a struct * drm_i915_gem_context_param_sseu. * * This property is available in perf revision 4. */ DRM_I915_PERF_PROP_GLOBAL_SSEU, /** * This optional parameter specifies the timer interval in nanoseconds * at which the i915 driver will check the OA buffer for available data. * Minimum allowed value is 100 microseconds. A default value is used by * the driver if this parameter is not specified. Note that larger timer * values will reduce cpu consumption during OA perf captures. However, * excessively large values would potentially result in OA buffer * overwrites as captures reach end of the OA buffer. * * This property is available in perf revision 5. */ DRM_I915_PERF_PROP_POLL_OA_PERIOD, /** * Multiple engines may be mapped to the same OA unit. The OA unit is * identified by class:instance of any engine mapped to it. * * This parameter specifies the engine class and must be passed along * with DRM_I915_PERF_PROP_OA_ENGINE_INSTANCE. * * This property is available in perf revision 6. */ DRM_I915_PERF_PROP_OA_ENGINE_CLASS, /** * This parameter specifies the engine instance and must be passed along * with DRM_I915_PERF_PROP_OA_ENGINE_CLASS. * * This property is available in perf revision 6. */ DRM_I915_PERF_PROP_OA_ENGINE_INSTANCE, DRM_I915_PERF_PROP_MAX /* non-ABI */ }; struct drm_i915_perf_open_param { __u32 flags; #define I915_PERF_FLAG_FD_CLOEXEC (1<<0) #define I915_PERF_FLAG_FD_NONBLOCK (1<<1) #define I915_PERF_FLAG_DISABLED (1<<2) /** The number of u64 (id, value) pairs */ __u32 num_properties; /** * Pointer to array of u64 (id, value) pairs configuring the stream * to open. */ __u64 properties_ptr; }; /* * Enable data capture for a stream that was either opened in a disabled state * via I915_PERF_FLAG_DISABLED or was later disabled via * I915_PERF_IOCTL_DISABLE. * * It is intended to be cheaper to disable and enable a stream than it may be * to close and re-open a stream with the same configuration. * * It's undefined whether any pending data for the stream will be lost. * * This ioctl is available in perf revision 1. */ #define I915_PERF_IOCTL_ENABLE _IO('i', 0x0) /* * Disable data capture for a stream. * * It is an error to try and read a stream that is disabled. * * This ioctl is available in perf revision 1. */ #define I915_PERF_IOCTL_DISABLE _IO('i', 0x1) /* * Change metrics_set captured by a stream. * * If the stream is bound to a specific context, the configuration change * will performed __inline__ with that context such that it takes effect before * the next execbuf submission. * * Returns the previously bound metrics set id, or a negative error code. * * This ioctl is available in perf revision 2. */ #define I915_PERF_IOCTL_CONFIG _IO('i', 0x2) /* * Common to all i915 perf records */ struct drm_i915_perf_record_header { __u32 type; __u16 pad; __u16 size; }; enum drm_i915_perf_record_type { /** * Samples are the work horse record type whose contents are extensible * and defined when opening an i915 perf stream based on the given * properties. * * Boolean properties following the naming convention * DRM_I915_PERF_SAMPLE_xyz_PROP request the inclusion of 'xyz' data in * every sample. * * The order of these sample properties given by userspace has no * affect on the ordering of data within a sample. The order is * documented here. * * struct { * struct drm_i915_perf_record_header header; * * { u32 oa_report[]; } && DRM_I915_PERF_PROP_SAMPLE_OA * }; */ DRM_I915_PERF_RECORD_SAMPLE = 1, /* * Indicates that one or more OA reports were not written by the * hardware. This can happen for example if an MI_REPORT_PERF_COUNT * command collides with periodic sampling - which would be more likely * at higher sampling frequencies. */ DRM_I915_PERF_RECORD_OA_REPORT_LOST = 2, /** * An error occurred that resulted in all pending OA reports being lost. */ DRM_I915_PERF_RECORD_OA_BUFFER_LOST = 3, DRM_I915_PERF_RECORD_MAX /* non-ABI */ }; /** * struct drm_i915_perf_oa_config * * Structure to upload perf dynamic configuration into the kernel. */ struct drm_i915_perf_oa_config { /** * @uuid: * * String formatted like "%\08x-%\04x-%\04x-%\04x-%\012x" */ char uuid[36]; /** * @n_mux_regs: * * Number of mux regs in &mux_regs_ptr. */ __u32 n_mux_regs; /** * @n_boolean_regs: * * Number of boolean regs in &boolean_regs_ptr. */ __u32 n_boolean_regs; /** * @n_flex_regs: * * Number of flex regs in &flex_regs_ptr. */ __u32 n_flex_regs; /** * @mux_regs_ptr: * * Pointer to tuples of u32 values (register address, value) for mux * registers. Expected length of buffer is (2 * sizeof(u32) * * &n_mux_regs). */ __u64 mux_regs_ptr; /** * @boolean_regs_ptr: * * Pointer to tuples of u32 values (register address, value) for mux * registers. Expected length of buffer is (2 * sizeof(u32) * * &n_boolean_regs). */ __u64 boolean_regs_ptr; /** * @flex_regs_ptr: * * Pointer to tuples of u32 values (register address, value) for mux * registers. Expected length of buffer is (2 * sizeof(u32) * * &n_flex_regs). */ __u64 flex_regs_ptr; }; /** * struct drm_i915_query_item - An individual query for the kernel to process. * * The behaviour is determined by the @query_id. Note that exactly what * @data_ptr is also depends on the specific @query_id. */ struct drm_i915_query_item { /** * @query_id: * * The id for this query. Currently accepted query IDs are: * - %DRM_I915_QUERY_TOPOLOGY_INFO (see struct drm_i915_query_topology_info) * - %DRM_I915_QUERY_ENGINE_INFO (see struct drm_i915_engine_info) * - %DRM_I915_QUERY_PERF_CONFIG (see struct drm_i915_query_perf_config) * - %DRM_I915_QUERY_MEMORY_REGIONS (see struct drm_i915_query_memory_regions) * - %DRM_I915_QUERY_HWCONFIG_BLOB (see `GuC HWCONFIG blob uAPI`) * - %DRM_I915_QUERY_GEOMETRY_SUBSLICES (see struct drm_i915_query_topology_info) * - %DRM_I915_QUERY_GUC_SUBMISSION_VERSION (see struct drm_i915_query_guc_submission_version) */ __u64 query_id; #define DRM_I915_QUERY_TOPOLOGY_INFO 1 #define DRM_I915_QUERY_ENGINE_INFO 2 #define DRM_I915_QUERY_PERF_CONFIG 3 #define DRM_I915_QUERY_MEMORY_REGIONS 4 #define DRM_I915_QUERY_HWCONFIG_BLOB 5 #define DRM_I915_QUERY_GEOMETRY_SUBSLICES 6 #define DRM_I915_QUERY_GUC_SUBMISSION_VERSION 7 /* Must be kept compact -- no holes and well documented */ /** * @length: * * When set to zero by userspace, this is filled with the size of the * data to be written at the @data_ptr pointer. The kernel sets this * value to a negative value to signal an error on a particular query * item. */ __s32 length; /** * @flags: * * When &query_id == %DRM_I915_QUERY_TOPOLOGY_INFO, must be 0. * * When &query_id == %DRM_I915_QUERY_PERF_CONFIG, must be one of the * following: * * - %DRM_I915_QUERY_PERF_CONFIG_LIST * - %DRM_I915_QUERY_PERF_CONFIG_DATA_FOR_UUID * - %DRM_I915_QUERY_PERF_CONFIG_FOR_UUID * * When &query_id == %DRM_I915_QUERY_GEOMETRY_SUBSLICES must contain * a struct i915_engine_class_instance that references a render engine. */ __u32 flags; #define DRM_I915_QUERY_PERF_CONFIG_LIST 1 #define DRM_I915_QUERY_PERF_CONFIG_DATA_FOR_UUID 2 #define DRM_I915_QUERY_PERF_CONFIG_DATA_FOR_ID 3 /** * @data_ptr: * * Data will be written at the location pointed by @data_ptr when the * value of @length matches the length of the data to be written by the * kernel. */ __u64 data_ptr; }; /** * struct drm_i915_query - Supply an array of struct drm_i915_query_item for the * kernel to fill out. * * Note that this is generally a two step process for each struct * drm_i915_query_item in the array: * * 1. Call the DRM_IOCTL_I915_QUERY, giving it our array of struct * drm_i915_query_item, with &drm_i915_query_item.length set to zero. The * kernel will then fill in the size, in bytes, which tells userspace how * memory it needs to allocate for the blob(say for an array of properties). * * 2. Next we call DRM_IOCTL_I915_QUERY again, this time with the * &drm_i915_query_item.data_ptr equal to our newly allocated blob. Note that * the &drm_i915_query_item.length should still be the same as what the * kernel previously set. At this point the kernel can fill in the blob. * * Note that for some query items it can make sense for userspace to just pass * in a buffer/blob equal to or larger than the required size. In this case only * a single ioctl call is needed. For some smaller query items this can work * quite well. * */ struct drm_i915_query { /** @num_items: The number of elements in the @items_ptr array */ __u32 num_items; /** * @flags: Unused for now. Must be cleared to zero. */ __u32 flags; /** * @items_ptr: * * Pointer to an array of struct drm_i915_query_item. The number of * array elements is @num_items. */ __u64 items_ptr; }; /** * struct drm_i915_query_topology_info * * Describes slice/subslice/EU information queried by * %DRM_I915_QUERY_TOPOLOGY_INFO */ struct drm_i915_query_topology_info { /** * @flags: * * Unused for now. Must be cleared to zero. */ __u16 flags; /** * @max_slices: * * The number of bits used to express the slice mask. */ __u16 max_slices; /** * @max_subslices: * * The number of bits used to express the subslice mask. */ __u16 max_subslices; /** * @max_eus_per_subslice: * * The number of bits in the EU mask that correspond to a single * subslice's EUs. */ __u16 max_eus_per_subslice; /** * @subslice_offset: * * Offset in data[] at which the subslice masks are stored. */ __u16 subslice_offset; /** * @subslice_stride: * * Stride at which each of the subslice masks for each slice are * stored. */ __u16 subslice_stride; /** * @eu_offset: * * Offset in data[] at which the EU masks are stored. */ __u16 eu_offset; /** * @eu_stride: * * Stride at which each of the EU masks for each subslice are stored. */ __u16 eu_stride; /** * @data: * * Contains 3 pieces of information : * * - The slice mask with one bit per slice telling whether a slice is * available. The availability of slice X can be queried with the * following formula : * * .. code:: c * * (data[X / 8] >> (X % 8)) & 1 * * Starting with Xe_HP platforms, Intel hardware no longer has * traditional slices so i915 will always report a single slice * (hardcoded slicemask = 0x1) which contains all of the platform's * subslices. I.e., the mask here does not reflect any of the newer * hardware concepts such as "gslices" or "cslices" since userspace * is capable of inferring those from the subslice mask. * * - The subslice mask for each slice with one bit per subslice telling * whether a subslice is available. Starting with Gen12 we use the * term "subslice" to refer to what the hardware documentation * describes as a "dual-subslices." The availability of subslice Y * in slice X can be queried with the following formula : * * .. code:: c * * (data[subslice_offset + X * subslice_stride + Y / 8] >> (Y % 8)) & 1 * * - The EU mask for each subslice in each slice, with one bit per EU * telling whether an EU is available. The availability of EU Z in * subslice Y in slice X can be queried with the following formula : * * .. code:: c * * (data[eu_offset + * (X * max_subslices + Y) * eu_stride + * Z / 8 * ] >> (Z % 8)) & 1 */ __u8 data[]; }; /** * DOC: Engine Discovery uAPI * * Engine discovery uAPI is a way of enumerating physical engines present in a * GPU associated with an open i915 DRM file descriptor. This supersedes the old * way of using `DRM_IOCTL_I915_GETPARAM` and engine identifiers like * `I915_PARAM_HAS_BLT`. * * The need for this interface came starting with Icelake and newer GPUs, which * started to establish a pattern of having multiple engines of a same class, * where not all instances were always completely functionally equivalent. * * Entry point for this uapi is `DRM_IOCTL_I915_QUERY` with the * `DRM_I915_QUERY_ENGINE_INFO` as the queried item id. * * Example for getting the list of engines: * * .. code-block:: C * * struct drm_i915_query_engine_info *info; * struct drm_i915_query_item item = { * .query_id = DRM_I915_QUERY_ENGINE_INFO; * }; * struct drm_i915_query query = { * .num_items = 1, * .items_ptr = (uintptr_t)&item, * }; * int err, i; * * // First query the size of the blob we need, this needs to be large * // enough to hold our array of engines. The kernel will fill out the * // item.length for us, which is the number of bytes we need. * // * // Alternatively a large buffer can be allocated straightaway enabling * // querying in one pass, in which case item.length should contain the * // length of the provided buffer. * err = ioctl(fd, DRM_IOCTL_I915_QUERY, &query); * if (err) ... * * info = calloc(1, item.length); * // Now that we allocated the required number of bytes, we call the ioctl * // again, this time with the data_ptr pointing to our newly allocated * // blob, which the kernel can then populate with info on all engines. * item.data_ptr = (uintptr_t)&info; * * err = ioctl(fd, DRM_IOCTL_I915_QUERY, &query); * if (err) ... * * // We can now access each engine in the array * for (i = 0; i < info->num_engines; i++) { * struct drm_i915_engine_info einfo = info->engines[i]; * u16 class = einfo.engine.class; * u16 instance = einfo.engine.instance; * .... * } * * free(info); * * Each of the enumerated engines, apart from being defined by its class and * instance (see `struct i915_engine_class_instance`), also can have flags and * capabilities defined as documented in i915_drm.h. * * For instance video engines which support HEVC encoding will have the * `I915_VIDEO_CLASS_CAPABILITY_HEVC` capability bit set. * * Engine discovery only fully comes to its own when combined with the new way * of addressing engines when submitting batch buffers using contexts with * engine maps configured. */ /** * struct drm_i915_engine_info * * Describes one engine and its capabilities as known to the driver. */ struct drm_i915_engine_info { /** @engine: Engine class and instance. */ struct i915_engine_class_instance engine; /** @rsvd0: Reserved field. */ __u32 rsvd0; /** @flags: Engine flags. */ __u64 flags; #define I915_ENGINE_INFO_HAS_LOGICAL_INSTANCE (1 << 0) /** @capabilities: Capabilities of this engine. */ __u64 capabilities; #define I915_VIDEO_CLASS_CAPABILITY_HEVC (1 << 0) #define I915_VIDEO_AND_ENHANCE_CLASS_CAPABILITY_SFC (1 << 1) /** @logical_instance: Logical instance of engine */ __u16 logical_instance; /** @rsvd1: Reserved fields. */ __u16 rsvd1[3]; /** @rsvd2: Reserved fields. */ __u64 rsvd2[3]; }; /** * struct drm_i915_query_engine_info * * Engine info query enumerates all engines known to the driver by filling in * an array of struct drm_i915_engine_info structures. */ struct drm_i915_query_engine_info { /** @num_engines: Number of struct drm_i915_engine_info structs following. */ __u32 num_engines; /** @rsvd: MBZ */ __u32 rsvd[3]; /** @engines: Marker for drm_i915_engine_info structures. */ struct drm_i915_engine_info engines[]; }; /** * struct drm_i915_query_perf_config * * Data written by the kernel with query %DRM_I915_QUERY_PERF_CONFIG and * %DRM_I915_QUERY_GEOMETRY_SUBSLICES. */ struct drm_i915_query_perf_config { union { /** * @n_configs: * * When &drm_i915_query_item.flags == * %DRM_I915_QUERY_PERF_CONFIG_LIST, i915 sets this fields to * the number of configurations available. */ __u64 n_configs; /** * @config: * * When &drm_i915_query_item.flags == * %DRM_I915_QUERY_PERF_CONFIG_DATA_FOR_ID, i915 will use the * value in this field as configuration identifier to decide * what data to write into config_ptr. */ __u64 config; /** * @uuid: * * When &drm_i915_query_item.flags == * %DRM_I915_QUERY_PERF_CONFIG_DATA_FOR_UUID, i915 will use the * value in this field as configuration identifier to decide * what data to write into config_ptr. * * String formatted like "%08x-%04x-%04x-%04x-%012x" */ char uuid[36]; }; /** * @flags: * * Unused for now. Must be cleared to zero. */ __u32 flags; /** * @data: * * When &drm_i915_query_item.flags == %DRM_I915_QUERY_PERF_CONFIG_LIST, * i915 will write an array of __u64 of configuration identifiers. * * When &drm_i915_query_item.flags == %DRM_I915_QUERY_PERF_CONFIG_DATA, * i915 will write a struct drm_i915_perf_oa_config. If the following * fields of struct drm_i915_perf_oa_config are not set to 0, i915 will * write into the associated pointers the values of submitted when the * configuration was created : * * - &drm_i915_perf_oa_config.n_mux_regs * - &drm_i915_perf_oa_config.n_boolean_regs * - &drm_i915_perf_oa_config.n_flex_regs */ __u8 data[]; }; /** * enum drm_i915_gem_memory_class - Supported memory classes */ enum drm_i915_gem_memory_class { /** @I915_MEMORY_CLASS_SYSTEM: System memory */ I915_MEMORY_CLASS_SYSTEM = 0, /** @I915_MEMORY_CLASS_DEVICE: Device local-memory */ I915_MEMORY_CLASS_DEVICE, }; /** * struct drm_i915_gem_memory_class_instance - Identify particular memory region */ struct drm_i915_gem_memory_class_instance { /** @memory_class: See enum drm_i915_gem_memory_class */ __u16 memory_class; /** @memory_instance: Which instance */ __u16 memory_instance; }; /** * struct drm_i915_memory_region_info - Describes one region as known to the * driver. * * Note this is using both struct drm_i915_query_item and struct drm_i915_query. * For this new query we are adding the new query id DRM_I915_QUERY_MEMORY_REGIONS * at &drm_i915_query_item.query_id. */ struct drm_i915_memory_region_info { /** @region: The class:instance pair encoding */ struct drm_i915_gem_memory_class_instance region; /** @rsvd0: MBZ */ __u32 rsvd0; /** * @probed_size: Memory probed by the driver * * Note that it should not be possible to ever encounter a zero value * here, also note that no current region type will ever return -1 here. * Although for future region types, this might be a possibility. The * same applies to the other size fields. */ __u64 probed_size; /** * @unallocated_size: Estimate of memory remaining * * Requires CAP_PERFMON or CAP_SYS_ADMIN to get reliable accounting. * Without this (or if this is an older kernel) the value here will * always equal the @probed_size. Note this is only currently tracked * for I915_MEMORY_CLASS_DEVICE regions (for other types the value here * will always equal the @probed_size). */ __u64 unallocated_size; union { /** @rsvd1: MBZ */ __u64 rsvd1[8]; struct { /** * @probed_cpu_visible_size: Memory probed by the driver * that is CPU accessible. * * This will be always be <= @probed_size, and the * remainder (if there is any) will not be CPU * accessible. * * On systems without small BAR, the @probed_size will * always equal the @probed_cpu_visible_size, since all * of it will be CPU accessible. * * Note this is only tracked for * I915_MEMORY_CLASS_DEVICE regions (for other types the * value here will always equal the @probed_size). * * Note that if the value returned here is zero, then * this must be an old kernel which lacks the relevant * small-bar uAPI support (including * I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS), but on * such systems we should never actually end up with a * small BAR configuration, assuming we are able to load * the kernel module. Hence it should be safe to treat * this the same as when @probed_cpu_visible_size == * @probed_size. */ __u64 probed_cpu_visible_size; /** * @unallocated_cpu_visible_size: Estimate of CPU * visible memory remaining. * * Note this is only tracked for * I915_MEMORY_CLASS_DEVICE regions (for other types the * value here will always equal the * @probed_cpu_visible_size). * * Requires CAP_PERFMON or CAP_SYS_ADMIN to get reliable * accounting. Without this the value here will always * equal the @probed_cpu_visible_size. Note this is only * currently tracked for I915_MEMORY_CLASS_DEVICE * regions (for other types the value here will also * always equal the @probed_cpu_visible_size). * * If this is an older kernel the value here will be * zero, see also @probed_cpu_visible_size. */ __u64 unallocated_cpu_visible_size; }; }; }; /** * struct drm_i915_query_memory_regions * * The region info query enumerates all regions known to the driver by filling * in an array of struct drm_i915_memory_region_info structures. * * Example for getting the list of supported regions: * * .. code-block:: C * * struct drm_i915_query_memory_regions *info; * struct drm_i915_query_item item = { * .query_id = DRM_I915_QUERY_MEMORY_REGIONS; * }; * struct drm_i915_query query = { * .num_items = 1, * .items_ptr = (uintptr_t)&item, * }; * int err, i; * * // First query the size of the blob we need, this needs to be large * // enough to hold our array of regions. The kernel will fill out the * // item.length for us, which is the number of bytes we need. * err = ioctl(fd, DRM_IOCTL_I915_QUERY, &query); * if (err) ... * * info = calloc(1, item.length); * // Now that we allocated the required number of bytes, we call the ioctl * // again, this time with the data_ptr pointing to our newly allocated * // blob, which the kernel can then populate with the all the region info. * item.data_ptr = (uintptr_t)&info, * * err = ioctl(fd, DRM_IOCTL_I915_QUERY, &query); * if (err) ... * * // We can now access each region in the array * for (i = 0; i < info->num_regions; i++) { * struct drm_i915_memory_region_info mr = info->regions[i]; * u16 class = mr.region.class; * u16 instance = mr.region.instance; * * .... * } * * free(info); */ struct drm_i915_query_memory_regions { /** @num_regions: Number of supported regions */ __u32 num_regions; /** @rsvd: MBZ */ __u32 rsvd[3]; /** @regions: Info about each supported region */ struct drm_i915_memory_region_info regions[]; }; /** * struct drm_i915_query_guc_submission_version - query GuC submission interface version */ struct drm_i915_query_guc_submission_version { __u32 branch; __u32 major; __u32 minor; __u32 patch; }; /** * DOC: GuC HWCONFIG blob uAPI * * The GuC produces a blob with information about the current device. * i915 reads this blob from GuC and makes it available via this uAPI. * * The format and meaning of the blob content are documented in the * Programmer's Reference Manual. */ /** * struct drm_i915_gem_create_ext - Existing gem_create behaviour, with added * extension support using struct i915_user_extension. * * Note that new buffer flags should be added here, at least for the stuff that * is immutable. Previously we would have two ioctls, one to create the object * with gem_create, and another to apply various parameters, however this * creates some ambiguity for the params which are considered immutable. Also in * general we're phasing out the various SET/GET ioctls. */ struct drm_i915_gem_create_ext { /** * @size: Requested size for the object. * * The (page-aligned) allocated size for the object will be returned. * * On platforms like DG2/ATS the kernel will always use 64K or larger * pages for I915_MEMORY_CLASS_DEVICE. The kernel also requires a * minimum of 64K GTT alignment for such objects. * * NOTE: Previously the ABI here required a minimum GTT alignment of 2M * on DG2/ATS, due to how the hardware implemented 64K GTT page support, * where we had the following complications: * * 1) The entire PDE (which covers a 2MB virtual address range), must * contain only 64K PTEs, i.e mixing 4K and 64K PTEs in the same * PDE is forbidden by the hardware. * * 2) We still need to support 4K PTEs for I915_MEMORY_CLASS_SYSTEM * objects. * * However on actual production HW this was completely changed to now * allow setting a TLB hint at the PTE level (see PS64), which is a lot * more flexible than the above. With this the 2M restriction was * dropped where we now only require 64K. */ __u64 size; /** * @handle: Returned handle for the object. * * Object handles are nonzero. */ __u32 handle; /** * @flags: Optional flags. * * Supported values: * * I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS - Signal to the kernel that * the object will need to be accessed via the CPU. * * Only valid when placing objects in I915_MEMORY_CLASS_DEVICE, and only * strictly required on configurations where some subset of the device * memory is directly visible/mappable through the CPU (which we also * call small BAR), like on some DG2+ systems. Note that this is quite * undesirable, but due to various factors like the client CPU, BIOS etc * it's something we can expect to see in the wild. See * &drm_i915_memory_region_info.probed_cpu_visible_size for how to * determine if this system applies. * * Note that one of the placements MUST be I915_MEMORY_CLASS_SYSTEM, to * ensure the kernel can always spill the allocation to system memory, * if the object can't be allocated in the mappable part of * I915_MEMORY_CLASS_DEVICE. * * Also note that since the kernel only supports flat-CCS on objects * that can *only* be placed in I915_MEMORY_CLASS_DEVICE, we therefore * don't support I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS together with * flat-CCS. * * Without this hint, the kernel will assume that non-mappable * I915_MEMORY_CLASS_DEVICE is preferred for this object. Note that the * kernel can still migrate the object to the mappable part, as a last * resort, if userspace ever CPU faults this object, but this might be * expensive, and so ideally should be avoided. * * On older kernels which lack the relevant small-bar uAPI support (see * also &drm_i915_memory_region_info.probed_cpu_visible_size), * usage of the flag will result in an error, but it should NEVER be * possible to end up with a small BAR configuration, assuming we can * also successfully load the i915 kernel module. In such cases the * entire I915_MEMORY_CLASS_DEVICE region will be CPU accessible, and as * such there are zero restrictions on where the object can be placed. */ #define I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS (1 << 0) __u32 flags; /** * @extensions: The chain of extensions to apply to this object. * * This will be useful in the future when we need to support several * different extensions, and we need to apply more than one when * creating the object. See struct i915_user_extension. * * If we don't supply any extensions then we get the same old gem_create * behaviour. * * For I915_GEM_CREATE_EXT_MEMORY_REGIONS usage see * struct drm_i915_gem_create_ext_memory_regions. * * For I915_GEM_CREATE_EXT_PROTECTED_CONTENT usage see * struct drm_i915_gem_create_ext_protected_content. * * For I915_GEM_CREATE_EXT_SET_PAT usage see * struct drm_i915_gem_create_ext_set_pat. */ #define I915_GEM_CREATE_EXT_MEMORY_REGIONS 0 #define I915_GEM_CREATE_EXT_PROTECTED_CONTENT 1 #define I915_GEM_CREATE_EXT_SET_PAT 2 __u64 extensions; }; /** * struct drm_i915_gem_create_ext_memory_regions - The * I915_GEM_CREATE_EXT_MEMORY_REGIONS extension. * * Set the object with the desired set of placements/regions in priority * order. Each entry must be unique and supported by the device. * * This is provided as an array of struct drm_i915_gem_memory_class_instance, or * an equivalent layout of class:instance pair encodings. See struct * drm_i915_query_memory_regions and DRM_I915_QUERY_MEMORY_REGIONS for how to * query the supported regions for a device. * * As an example, on discrete devices, if we wish to set the placement as * device local-memory we can do something like: * * .. code-block:: C * * struct drm_i915_gem_memory_class_instance region_lmem = { * .memory_class = I915_MEMORY_CLASS_DEVICE, * .memory_instance = 0, * }; * struct drm_i915_gem_create_ext_memory_regions regions = { * .base = { .name = I915_GEM_CREATE_EXT_MEMORY_REGIONS }, * .regions = (uintptr_t)®ion_lmem, * .num_regions = 1, * }; * struct drm_i915_gem_create_ext create_ext = { * .size = 16 * PAGE_SIZE, * .extensions = (uintptr_t)®ions, * }; * * int err = ioctl(fd, DRM_IOCTL_I915_GEM_CREATE_EXT, &create_ext); * if (err) ... * * At which point we get the object handle in &drm_i915_gem_create_ext.handle, * along with the final object size in &drm_i915_gem_create_ext.size, which * should account for any rounding up, if required. * * Note that userspace has no means of knowing the current backing region * for objects where @num_regions is larger than one. The kernel will only * ensure that the priority order of the @regions array is honoured, either * when initially placing the object, or when moving memory around due to * memory pressure * * On Flat-CCS capable HW, compression is supported for the objects residing * in I915_MEMORY_CLASS_DEVICE. When such objects (compressed) have other * memory class in @regions and migrated (by i915, due to memory * constraints) to the non I915_MEMORY_CLASS_DEVICE region, then i915 needs to * decompress the content. But i915 doesn't have the required information to * decompress the userspace compressed objects. * * So i915 supports Flat-CCS, on the objects which can reside only on * I915_MEMORY_CLASS_DEVICE regions. */ struct drm_i915_gem_create_ext_memory_regions { /** @base: Extension link. See struct i915_user_extension. */ struct i915_user_extension base; /** @pad: MBZ */ __u32 pad; /** @num_regions: Number of elements in the @regions array. */ __u32 num_regions; /** * @regions: The regions/placements array. * * An array of struct drm_i915_gem_memory_class_instance. */ __u64 regions; }; /** * struct drm_i915_gem_create_ext_protected_content - The * I915_OBJECT_PARAM_PROTECTED_CONTENT extension. * * If this extension is provided, buffer contents are expected to be protected * by PXP encryption and require decryption for scan out and processing. This * is only possible on platforms that have PXP enabled, on all other scenarios * using this extension will cause the ioctl to fail and return -ENODEV. The * flags parameter is reserved for future expansion and must currently be set * to zero. * * The buffer contents are considered invalid after a PXP session teardown. * * The encryption is guaranteed to be processed correctly only if the object * is submitted with a context created using the * I915_CONTEXT_PARAM_PROTECTED_CONTENT flag. This will also enable extra checks * at submission time on the validity of the objects involved. * * Below is an example on how to create a protected object: * * .. code-block:: C * * struct drm_i915_gem_create_ext_protected_content protected_ext = { * .base = { .name = I915_GEM_CREATE_EXT_PROTECTED_CONTENT }, * .flags = 0, * }; * struct drm_i915_gem_create_ext create_ext = { * .size = PAGE_SIZE, * .extensions = (uintptr_t)&protected_ext, * }; * * int err = ioctl(fd, DRM_IOCTL_I915_GEM_CREATE_EXT, &create_ext); * if (err) ... */ struct drm_i915_gem_create_ext_protected_content { /** @base: Extension link. See struct i915_user_extension. */ struct i915_user_extension base; /** @flags: reserved for future usage, currently MBZ */ __u32 flags; }; /** * struct drm_i915_gem_create_ext_set_pat - The * I915_GEM_CREATE_EXT_SET_PAT extension. * * If this extension is provided, the specified caching policy (PAT index) is * applied to the buffer object. * * Below is an example on how to create an object with specific caching policy: * * .. code-block:: C * * struct drm_i915_gem_create_ext_set_pat set_pat_ext = { * .base = { .name = I915_GEM_CREATE_EXT_SET_PAT }, * .pat_index = 0, * }; * struct drm_i915_gem_create_ext create_ext = { * .size = PAGE_SIZE, * .extensions = (uintptr_t)&set_pat_ext, * }; * * int err = ioctl(fd, DRM_IOCTL_I915_GEM_CREATE_EXT, &create_ext); * if (err) ... */ struct drm_i915_gem_create_ext_set_pat { /** @base: Extension link. See struct i915_user_extension. */ struct i915_user_extension base; /** * @pat_index: PAT index to be set * PAT index is a bit field in Page Table Entry to control caching * behaviors for GPU accesses. The definition of PAT index is * platform dependent and can be found in hardware specifications, */ __u32 pat_index; /** @rsvd: reserved for future use */ __u32 rsvd; }; /* ID of the protected content session managed by i915 when PXP is active */ #define I915_PROTECTED_CONTENT_DEFAULT_SESSION 0xf #if defined(__cplusplus) } #endif #endif /* _I915_DRM_H_ */ aristocratos-btop-d43a485/src/linux/intel_gpu_top/i915_pciids.h000066400000000000000000000660641517514752700245520ustar00rootroot00000000000000/* * Copyright 2013 Intel Corporation * All Rights Reserved. * * 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, sub license, 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 (including the * next paragraph) 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 _I915_PCIIDS_H #define _I915_PCIIDS_H /* * A pci_device_id struct { * __u32 vendor, device; * __u32 subvendor, subdevice; * __u32 class, class_mask; * kernel_ulong_t driver_data; * }; * Don't use C99 here because "class" is reserved and we want to * give userspace flexibility. */ #define INTEL_VGA_DEVICE(id, info) { \ 0x8086, id, \ ~0, ~0, \ 0x030000, 0xff0000, \ (unsigned long) info } #define INTEL_QUANTA_VGA_DEVICE(info) { \ 0x8086, 0x16a, \ 0x152d, 0x8990, \ 0x030000, 0xff0000, \ (unsigned long) info } #define INTEL_I810_IDS(MACRO__, ...) \ MACRO__(0x7121, ## __VA_ARGS__), /* I810 */ \ MACRO__(0x7123, ## __VA_ARGS__), /* I810_DC100 */ \ MACRO__(0x7125, ## __VA_ARGS__) /* I810_E */ #define INTEL_I815_IDS(MACRO__, ...) \ MACRO__(0x1132, ## __VA_ARGS__) /* I815*/ #define INTEL_I830_IDS(MACRO__, ...) \ MACRO__(0x3577, ## __VA_ARGS__) #define INTEL_I845G_IDS(MACRO__, ...) \ MACRO__(0x2562, ## __VA_ARGS__) #define INTEL_I85X_IDS(MACRO__, ...) \ MACRO__(0x3582, ## __VA_ARGS__), /* I855_GM */ \ MACRO__(0x358e, ## __VA_ARGS__) #define INTEL_I865G_IDS(MACRO__, ...) \ MACRO__(0x2572, ## __VA_ARGS__) /* I865_G */ #define INTEL_I915G_IDS(MACRO__, ...) \ MACRO__(0x2582, ## __VA_ARGS__), /* I915_G */ \ MACRO__(0x258a, ## __VA_ARGS__) /* E7221_G */ #define INTEL_I915GM_IDS(MACRO__, ...) \ MACRO__(0x2592, ## __VA_ARGS__) /* I915_GM */ #define INTEL_I945G_IDS(MACRO__, ...) \ MACRO__(0x2772, ## __VA_ARGS__) /* I945_G */ #define INTEL_I945GM_IDS(MACRO__, ...) \ MACRO__(0x27a2, ## __VA_ARGS__), /* I945_GM */ \ MACRO__(0x27ae, ## __VA_ARGS__) /* I945_GME */ #define INTEL_I965G_IDS(MACRO__, ...) \ MACRO__(0x2972, ## __VA_ARGS__), /* I946_GZ */ \ MACRO__(0x2982, ## __VA_ARGS__), /* G35_G */ \ MACRO__(0x2992, ## __VA_ARGS__), /* I965_Q */ \ MACRO__(0x29a2, ## __VA_ARGS__) /* I965_G */ #define INTEL_G33_IDS(MACRO__, ...) \ MACRO__(0x29b2, ## __VA_ARGS__), /* Q35_G */ \ MACRO__(0x29c2, ## __VA_ARGS__), /* G33_G */ \ MACRO__(0x29d2, ## __VA_ARGS__) /* Q33_G */ #define INTEL_I965GM_IDS(MACRO__, ...) \ MACRO__(0x2a02, ## __VA_ARGS__), /* I965_GM */ \ MACRO__(0x2a12, ## __VA_ARGS__) /* I965_GME */ #define INTEL_GM45_IDS(MACRO__, ...) \ MACRO__(0x2a42, ## __VA_ARGS__) /* GM45_G */ #define INTEL_G45_IDS(MACRO__, ...) \ MACRO__(0x2e02, ## __VA_ARGS__), /* IGD_E_G */ \ MACRO__(0x2e12, ## __VA_ARGS__), /* Q45_G */ \ MACRO__(0x2e22, ## __VA_ARGS__), /* G45_G */ \ MACRO__(0x2e32, ## __VA_ARGS__), /* G41_G */ \ MACRO__(0x2e42, ## __VA_ARGS__), /* B43_G */ \ MACRO__(0x2e92, ## __VA_ARGS__) /* B43_G.1 */ #define INTEL_PNV_G_IDS(MACRO__, ...) \ MACRO__(0xa001, ## __VA_ARGS__) #define INTEL_PNV_M_IDS(MACRO__, ...) \ MACRO__(0xa011, ## __VA_ARGS__) #define INTEL_PNV_IDS(MACRO__, ...) \ INTEL_PNV_G_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_PNV_M_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_ILK_D_IDS(MACRO__, ...) \ MACRO__(0x0042, ## __VA_ARGS__) #define INTEL_ILK_M_IDS(MACRO__, ...) \ MACRO__(0x0046, ## __VA_ARGS__) #define INTEL_ILK_IDS(MACRO__, ...) \ INTEL_ILK_D_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_ILK_M_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_SNB_D_GT1_IDS(MACRO__, ...) \ MACRO__(0x0102, ## __VA_ARGS__), \ MACRO__(0x010A, ## __VA_ARGS__) #define INTEL_SNB_D_GT2_IDS(MACRO__, ...) \ MACRO__(0x0112, ## __VA_ARGS__), \ MACRO__(0x0122, ## __VA_ARGS__) #define INTEL_SNB_D_IDS(MACRO__, ...) \ INTEL_SNB_D_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SNB_D_GT2_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_SNB_M_GT1_IDS(MACRO__, ...) \ MACRO__(0x0106, ## __VA_ARGS__) #define INTEL_SNB_M_GT2_IDS(MACRO__, ...) \ MACRO__(0x0116, ## __VA_ARGS__), \ MACRO__(0x0126, ## __VA_ARGS__) #define INTEL_SNB_M_IDS(MACRO__, ...) \ INTEL_SNB_M_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SNB_M_GT2_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_SNB_IDS(MACRO__, ...) \ INTEL_SNB_D_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SNB_M_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_IVB_M_GT1_IDS(MACRO__, ...) \ MACRO__(0x0156, ## __VA_ARGS__) /* GT1 mobile */ #define INTEL_IVB_M_GT2_IDS(MACRO__, ...) \ MACRO__(0x0166, ## __VA_ARGS__) /* GT2 mobile */ #define INTEL_IVB_M_IDS(MACRO__, ...) \ INTEL_IVB_M_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_IVB_M_GT2_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_IVB_D_GT1_IDS(MACRO__, ...) \ MACRO__(0x0152, ## __VA_ARGS__), /* GT1 desktop */ \ MACRO__(0x015a, ## __VA_ARGS__) /* GT1 server */ #define INTEL_IVB_D_GT2_IDS(MACRO__, ...) \ MACRO__(0x0162, ## __VA_ARGS__), /* GT2 desktop */ \ MACRO__(0x016a, ## __VA_ARGS__) /* GT2 server */ #define INTEL_IVB_D_IDS(MACRO__, ...) \ INTEL_IVB_D_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_IVB_D_GT2_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_IVB_IDS(MACRO__, ...) \ INTEL_IVB_M_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_IVB_D_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_IVB_Q_IDS(MACRO__, ...) \ INTEL_QUANTA_VGA_DEVICE(__VA_ARGS__) /* Quanta transcode */ #define INTEL_HSW_ULT_GT1_IDS(MACRO__, ...) \ MACRO__(0x0A02, ## __VA_ARGS__), /* ULT GT1 desktop */ \ MACRO__(0x0A06, ## __VA_ARGS__), /* ULT GT1 mobile */ \ MACRO__(0x0A0A, ## __VA_ARGS__), /* ULT GT1 server */ \ MACRO__(0x0A0B, ## __VA_ARGS__) /* ULT GT1 reserved */ #define INTEL_HSW_ULX_GT1_IDS(MACRO__, ...) \ MACRO__(0x0A0E, ## __VA_ARGS__) /* ULX GT1 mobile */ #define INTEL_HSW_GT1_IDS(MACRO__, ...) \ INTEL_HSW_ULT_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_HSW_ULX_GT1_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x0402, ## __VA_ARGS__), /* GT1 desktop */ \ MACRO__(0x0406, ## __VA_ARGS__), /* GT1 mobile */ \ MACRO__(0x040A, ## __VA_ARGS__), /* GT1 server */ \ MACRO__(0x040B, ## __VA_ARGS__), /* GT1 reserved */ \ MACRO__(0x040E, ## __VA_ARGS__), /* GT1 reserved */ \ MACRO__(0x0C02, ## __VA_ARGS__), /* SDV GT1 desktop */ \ MACRO__(0x0C06, ## __VA_ARGS__), /* SDV GT1 mobile */ \ MACRO__(0x0C0A, ## __VA_ARGS__), /* SDV GT1 server */ \ MACRO__(0x0C0B, ## __VA_ARGS__), /* SDV GT1 reserved */ \ MACRO__(0x0C0E, ## __VA_ARGS__), /* SDV GT1 reserved */ \ MACRO__(0x0D02, ## __VA_ARGS__), /* CRW GT1 desktop */ \ MACRO__(0x0D06, ## __VA_ARGS__), /* CRW GT1 mobile */ \ MACRO__(0x0D0A, ## __VA_ARGS__), /* CRW GT1 server */ \ MACRO__(0x0D0B, ## __VA_ARGS__), /* CRW GT1 reserved */ \ MACRO__(0x0D0E, ## __VA_ARGS__) /* CRW GT1 reserved */ #define INTEL_HSW_ULT_GT2_IDS(MACRO__, ...) \ MACRO__(0x0A12, ## __VA_ARGS__), /* ULT GT2 desktop */ \ MACRO__(0x0A16, ## __VA_ARGS__), /* ULT GT2 mobile */ \ MACRO__(0x0A1A, ## __VA_ARGS__), /* ULT GT2 server */ \ MACRO__(0x0A1B, ## __VA_ARGS__) /* ULT GT2 reserved */ \ #define INTEL_HSW_ULX_GT2_IDS(MACRO__, ...) \ MACRO__(0x0A1E, ## __VA_ARGS__) /* ULX GT2 mobile */ \ #define INTEL_HSW_GT2_IDS(MACRO__, ...) \ INTEL_HSW_ULT_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_HSW_ULX_GT2_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x0412, ## __VA_ARGS__), /* GT2 desktop */ \ MACRO__(0x0416, ## __VA_ARGS__), /* GT2 mobile */ \ MACRO__(0x041A, ## __VA_ARGS__), /* GT2 server */ \ MACRO__(0x041B, ## __VA_ARGS__), /* GT2 reserved */ \ MACRO__(0x041E, ## __VA_ARGS__), /* GT2 reserved */ \ MACRO__(0x0C12, ## __VA_ARGS__), /* SDV GT2 desktop */ \ MACRO__(0x0C16, ## __VA_ARGS__), /* SDV GT2 mobile */ \ MACRO__(0x0C1A, ## __VA_ARGS__), /* SDV GT2 server */ \ MACRO__(0x0C1B, ## __VA_ARGS__), /* SDV GT2 reserved */ \ MACRO__(0x0C1E, ## __VA_ARGS__), /* SDV GT2 reserved */ \ MACRO__(0x0D12, ## __VA_ARGS__), /* CRW GT2 desktop */ \ MACRO__(0x0D16, ## __VA_ARGS__), /* CRW GT2 mobile */ \ MACRO__(0x0D1A, ## __VA_ARGS__), /* CRW GT2 server */ \ MACRO__(0x0D1B, ## __VA_ARGS__), /* CRW GT2 reserved */ \ MACRO__(0x0D1E, ## __VA_ARGS__) /* CRW GT2 reserved */ #define INTEL_HSW_ULT_GT3_IDS(MACRO__, ...) \ MACRO__(0x0A22, ## __VA_ARGS__), /* ULT GT3 desktop */ \ MACRO__(0x0A26, ## __VA_ARGS__), /* ULT GT3 mobile */ \ MACRO__(0x0A2A, ## __VA_ARGS__), /* ULT GT3 server */ \ MACRO__(0x0A2B, ## __VA_ARGS__), /* ULT GT3 reserved */ \ MACRO__(0x0A2E, ## __VA_ARGS__) /* ULT GT3 reserved */ #define INTEL_HSW_GT3_IDS(MACRO__, ...) \ INTEL_HSW_ULT_GT3_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x0422, ## __VA_ARGS__), /* GT3 desktop */ \ MACRO__(0x0426, ## __VA_ARGS__), /* GT3 mobile */ \ MACRO__(0x042A, ## __VA_ARGS__), /* GT3 server */ \ MACRO__(0x042B, ## __VA_ARGS__), /* GT3 reserved */ \ MACRO__(0x042E, ## __VA_ARGS__), /* GT3 reserved */ \ MACRO__(0x0C22, ## __VA_ARGS__), /* SDV GT3 desktop */ \ MACRO__(0x0C26, ## __VA_ARGS__), /* SDV GT3 mobile */ \ MACRO__(0x0C2A, ## __VA_ARGS__), /* SDV GT3 server */ \ MACRO__(0x0C2B, ## __VA_ARGS__), /* SDV GT3 reserved */ \ MACRO__(0x0C2E, ## __VA_ARGS__), /* SDV GT3 reserved */ \ MACRO__(0x0D22, ## __VA_ARGS__), /* CRW GT3 desktop */ \ MACRO__(0x0D26, ## __VA_ARGS__), /* CRW GT3 mobile */ \ MACRO__(0x0D2A, ## __VA_ARGS__), /* CRW GT3 server */ \ MACRO__(0x0D2B, ## __VA_ARGS__), /* CRW GT3 reserved */ \ MACRO__(0x0D2E, ## __VA_ARGS__) /* CRW GT3 reserved */ #define INTEL_HSW_IDS(MACRO__, ...) \ INTEL_HSW_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_HSW_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_HSW_GT3_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_VLV_IDS(MACRO__, ...) \ MACRO__(0x0f30, ## __VA_ARGS__), \ MACRO__(0x0f31, ## __VA_ARGS__), \ MACRO__(0x0f32, ## __VA_ARGS__), \ MACRO__(0x0f33, ## __VA_ARGS__) #define INTEL_BDW_ULT_GT1_IDS(MACRO__, ...) \ MACRO__(0x1606, ## __VA_ARGS__), /* GT1 ULT */ \ MACRO__(0x160B, ## __VA_ARGS__) /* GT1 Iris */ #define INTEL_BDW_ULX_GT1_IDS(MACRO__, ...) \ MACRO__(0x160E, ## __VA_ARGS__) /* GT1 ULX */ #define INTEL_BDW_GT1_IDS(MACRO__, ...) \ INTEL_BDW_ULT_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_ULX_GT1_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x1602, ## __VA_ARGS__), /* GT1 ULT */ \ MACRO__(0x160A, ## __VA_ARGS__), /* GT1 Server */ \ MACRO__(0x160D, ## __VA_ARGS__) /* GT1 Workstation */ #define INTEL_BDW_ULT_GT2_IDS(MACRO__, ...) \ MACRO__(0x1616, ## __VA_ARGS__), /* GT2 ULT */ \ MACRO__(0x161B, ## __VA_ARGS__) /* GT2 ULT */ #define INTEL_BDW_ULX_GT2_IDS(MACRO__, ...) \ MACRO__(0x161E, ## __VA_ARGS__) /* GT2 ULX */ #define INTEL_BDW_GT2_IDS(MACRO__, ...) \ INTEL_BDW_ULT_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_ULX_GT2_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x1612, ## __VA_ARGS__), /* GT2 Halo */ \ MACRO__(0x161A, ## __VA_ARGS__), /* GT2 Server */ \ MACRO__(0x161D, ## __VA_ARGS__) /* GT2 Workstation */ #define INTEL_BDW_ULT_GT3_IDS(MACRO__, ...) \ MACRO__(0x1626, ## __VA_ARGS__), /* ULT */ \ MACRO__(0x162B, ## __VA_ARGS__) /* Iris */ \ #define INTEL_BDW_ULX_GT3_IDS(MACRO__, ...) \ MACRO__(0x162E, ## __VA_ARGS__) /* ULX */ #define INTEL_BDW_GT3_IDS(MACRO__, ...) \ INTEL_BDW_ULT_GT3_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_ULX_GT3_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x1622, ## __VA_ARGS__), /* ULT */ \ MACRO__(0x162A, ## __VA_ARGS__), /* Server */ \ MACRO__(0x162D, ## __VA_ARGS__) /* Workstation */ #define INTEL_BDW_ULT_RSVD_IDS(MACRO__, ...) \ MACRO__(0x1636, ## __VA_ARGS__), /* ULT */ \ MACRO__(0x163B, ## __VA_ARGS__) /* Iris */ #define INTEL_BDW_ULX_RSVD_IDS(MACRO__, ...) \ MACRO__(0x163E, ## __VA_ARGS__) /* ULX */ #define INTEL_BDW_RSVD_IDS(MACRO__, ...) \ INTEL_BDW_ULT_RSVD_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_ULX_RSVD_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x1632, ## __VA_ARGS__), /* ULT */ \ MACRO__(0x163A, ## __VA_ARGS__), /* Server */ \ MACRO__(0x163D, ## __VA_ARGS__) /* Workstation */ #define INTEL_BDW_IDS(MACRO__, ...) \ INTEL_BDW_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_GT3_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_BDW_RSVD_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_CHV_IDS(MACRO__, ...) \ MACRO__(0x22b0, ## __VA_ARGS__), \ MACRO__(0x22b1, ## __VA_ARGS__), \ MACRO__(0x22b2, ## __VA_ARGS__), \ MACRO__(0x22b3, ## __VA_ARGS__) #define INTEL_SKL_ULT_GT1_IDS(MACRO__, ...) \ MACRO__(0x1906, ## __VA_ARGS__), /* ULT GT1 */ \ MACRO__(0x1913, ## __VA_ARGS__) /* ULT GT1.5 */ #define INTEL_SKL_ULX_GT1_IDS(MACRO__, ...) \ MACRO__(0x190E, ## __VA_ARGS__), /* ULX GT1 */ \ MACRO__(0x1915, ## __VA_ARGS__) /* ULX GT1.5 */ #define INTEL_SKL_GT1_IDS(MACRO__, ...) \ INTEL_SKL_ULT_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SKL_ULX_GT1_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x1902, ## __VA_ARGS__), /* DT GT1 */ \ MACRO__(0x190A, ## __VA_ARGS__), /* SRV GT1 */ \ MACRO__(0x190B, ## __VA_ARGS__), /* Halo GT1 */ \ MACRO__(0x1917, ## __VA_ARGS__) /* DT GT1.5 */ #define INTEL_SKL_ULT_GT2_IDS(MACRO__, ...) \ MACRO__(0x1916, ## __VA_ARGS__), /* ULT GT2 */ \ MACRO__(0x1921, ## __VA_ARGS__) /* ULT GT2F */ #define INTEL_SKL_ULX_GT2_IDS(MACRO__, ...) \ MACRO__(0x191E, ## __VA_ARGS__) /* ULX GT2 */ #define INTEL_SKL_GT2_IDS(MACRO__, ...) \ INTEL_SKL_ULT_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SKL_ULX_GT2_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x1912, ## __VA_ARGS__), /* DT GT2 */ \ MACRO__(0x191A, ## __VA_ARGS__), /* SRV GT2 */ \ MACRO__(0x191B, ## __VA_ARGS__), /* Halo GT2 */ \ MACRO__(0x191D, ## __VA_ARGS__) /* WKS GT2 */ #define INTEL_SKL_ULT_GT3_IDS(MACRO__, ...) \ MACRO__(0x1923, ## __VA_ARGS__), /* ULT GT3 */ \ MACRO__(0x1926, ## __VA_ARGS__), /* ULT GT3e */ \ MACRO__(0x1927, ## __VA_ARGS__) /* ULT GT3e */ #define INTEL_SKL_GT3_IDS(MACRO__, ...) \ INTEL_SKL_ULT_GT3_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x192A, ## __VA_ARGS__), /* SRV GT3 */ \ MACRO__(0x192B, ## __VA_ARGS__), /* Halo GT3e */ \ MACRO__(0x192D, ## __VA_ARGS__) /* SRV GT3e */ #define INTEL_SKL_GT4_IDS(MACRO__, ...) \ MACRO__(0x1932, ## __VA_ARGS__), /* DT GT4 */ \ MACRO__(0x193A, ## __VA_ARGS__), /* SRV GT4e */ \ MACRO__(0x193B, ## __VA_ARGS__), /* Halo GT4e */ \ MACRO__(0x193D, ## __VA_ARGS__) /* WKS GT4e */ #define INTEL_SKL_IDS(MACRO__, ...) \ INTEL_SKL_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SKL_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SKL_GT3_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_SKL_GT4_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_BXT_IDS(MACRO__, ...) \ MACRO__(0x0A84, ## __VA_ARGS__), \ MACRO__(0x1A84, ## __VA_ARGS__), \ MACRO__(0x1A85, ## __VA_ARGS__), \ MACRO__(0x5A84, ## __VA_ARGS__), /* APL HD Graphics 505 */ \ MACRO__(0x5A85, ## __VA_ARGS__) /* APL HD Graphics 500 */ #define INTEL_GLK_IDS(MACRO__, ...) \ MACRO__(0x3184, ## __VA_ARGS__), \ MACRO__(0x3185, ## __VA_ARGS__) #define INTEL_KBL_ULT_GT1_IDS(MACRO__, ...) \ MACRO__(0x5906, ## __VA_ARGS__), /* ULT GT1 */ \ MACRO__(0x5913, ## __VA_ARGS__) /* ULT GT1.5 */ #define INTEL_KBL_ULX_GT1_IDS(MACRO__, ...) \ MACRO__(0x590E, ## __VA_ARGS__), /* ULX GT1 */ \ MACRO__(0x5915, ## __VA_ARGS__) /* ULX GT1.5 */ #define INTEL_KBL_GT1_IDS(MACRO__, ...) \ INTEL_KBL_ULT_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_KBL_ULX_GT1_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x5902, ## __VA_ARGS__), /* DT GT1 */ \ MACRO__(0x5908, ## __VA_ARGS__), /* Halo GT1 */ \ MACRO__(0x590A, ## __VA_ARGS__), /* SRV GT1 */ \ MACRO__(0x590B, ## __VA_ARGS__) /* Halo GT1 */ #define INTEL_KBL_ULT_GT2_IDS(MACRO__, ...) \ MACRO__(0x5916, ## __VA_ARGS__), /* ULT GT2 */ \ MACRO__(0x5921, ## __VA_ARGS__) /* ULT GT2F */ #define INTEL_KBL_ULX_GT2_IDS(MACRO__, ...) \ MACRO__(0x591E, ## __VA_ARGS__) /* ULX GT2 */ #define INTEL_KBL_GT2_IDS(MACRO__, ...) \ INTEL_KBL_ULT_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_KBL_ULX_GT2_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x5912, ## __VA_ARGS__), /* DT GT2 */ \ MACRO__(0x5917, ## __VA_ARGS__), /* Mobile GT2 */ \ MACRO__(0x591A, ## __VA_ARGS__), /* SRV GT2 */ \ MACRO__(0x591B, ## __VA_ARGS__), /* Halo GT2 */ \ MACRO__(0x591D, ## __VA_ARGS__) /* WKS GT2 */ #define INTEL_KBL_ULT_GT3_IDS(MACRO__, ...) \ MACRO__(0x5926, ## __VA_ARGS__) /* ULT GT3 */ #define INTEL_KBL_GT3_IDS(MACRO__, ...) \ INTEL_KBL_ULT_GT3_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x5923, ## __VA_ARGS__), /* ULT GT3 */ \ MACRO__(0x5927, ## __VA_ARGS__) /* ULT GT3 */ #define INTEL_KBL_GT4_IDS(MACRO__, ...) \ MACRO__(0x593B, ## __VA_ARGS__) /* Halo GT4 */ /* AML/KBL Y GT2 */ #define INTEL_AML_KBL_GT2_IDS(MACRO__, ...) \ MACRO__(0x591C, ## __VA_ARGS__), /* ULX GT2 */ \ MACRO__(0x87C0, ## __VA_ARGS__) /* ULX GT2 */ /* AML/CFL Y GT2 */ #define INTEL_AML_CFL_GT2_IDS(MACRO__, ...) \ MACRO__(0x87CA, ## __VA_ARGS__) /* CML GT1 */ #define INTEL_CML_GT1_IDS(MACRO__, ...) \ MACRO__(0x9BA2, ## __VA_ARGS__), \ MACRO__(0x9BA4, ## __VA_ARGS__), \ MACRO__(0x9BA5, ## __VA_ARGS__), \ MACRO__(0x9BA8, ## __VA_ARGS__) #define INTEL_CML_U_GT1_IDS(MACRO__, ...) \ MACRO__(0x9B21, ## __VA_ARGS__), \ MACRO__(0x9BAA, ## __VA_ARGS__), \ MACRO__(0x9BAC, ## __VA_ARGS__) /* CML GT2 */ #define INTEL_CML_GT2_IDS(MACRO__, ...) \ MACRO__(0x9BC2, ## __VA_ARGS__), \ MACRO__(0x9BC4, ## __VA_ARGS__), \ MACRO__(0x9BC5, ## __VA_ARGS__), \ MACRO__(0x9BC6, ## __VA_ARGS__), \ MACRO__(0x9BC8, ## __VA_ARGS__), \ MACRO__(0x9BE6, ## __VA_ARGS__), \ MACRO__(0x9BF6, ## __VA_ARGS__) #define INTEL_CML_U_GT2_IDS(MACRO__, ...) \ MACRO__(0x9B41, ## __VA_ARGS__), \ MACRO__(0x9BCA, ## __VA_ARGS__), \ MACRO__(0x9BCC, ## __VA_ARGS__) #define INTEL_CML_IDS(MACRO__, ...) \ INTEL_CML_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CML_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CML_U_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CML_U_GT2_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_KBL_IDS(MACRO__, ...) \ INTEL_KBL_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_KBL_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_KBL_GT3_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_KBL_GT4_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_AML_KBL_GT2_IDS(MACRO__, ## __VA_ARGS__) /* CFL S */ #define INTEL_CFL_S_GT1_IDS(MACRO__, ...) \ MACRO__(0x3E90, ## __VA_ARGS__), /* SRV GT1 */ \ MACRO__(0x3E93, ## __VA_ARGS__), /* SRV GT1 */ \ MACRO__(0x3E99, ## __VA_ARGS__) /* SRV GT1 */ #define INTEL_CFL_S_GT2_IDS(MACRO__, ...) \ MACRO__(0x3E91, ## __VA_ARGS__), /* SRV GT2 */ \ MACRO__(0x3E92, ## __VA_ARGS__), /* SRV GT2 */ \ MACRO__(0x3E96, ## __VA_ARGS__), /* SRV GT2 */ \ MACRO__(0x3E98, ## __VA_ARGS__), /* SRV GT2 */ \ MACRO__(0x3E9A, ## __VA_ARGS__) /* SRV GT2 */ /* CFL H */ #define INTEL_CFL_H_GT1_IDS(MACRO__, ...) \ MACRO__(0x3E9C, ## __VA_ARGS__) #define INTEL_CFL_H_GT2_IDS(MACRO__, ...) \ MACRO__(0x3E94, ## __VA_ARGS__), /* Halo GT2 */ \ MACRO__(0x3E9B, ## __VA_ARGS__) /* Halo GT2 */ /* CFL U GT2 */ #define INTEL_CFL_U_GT2_IDS(MACRO__, ...) \ MACRO__(0x3EA9, ## __VA_ARGS__) /* CFL U GT3 */ #define INTEL_CFL_U_GT3_IDS(MACRO__, ...) \ MACRO__(0x3EA5, ## __VA_ARGS__), /* ULT GT3 */ \ MACRO__(0x3EA6, ## __VA_ARGS__), /* ULT GT3 */ \ MACRO__(0x3EA7, ## __VA_ARGS__), /* ULT GT3 */ \ MACRO__(0x3EA8, ## __VA_ARGS__) /* ULT GT3 */ #define INTEL_CFL_IDS(MACRO__, ...) \ INTEL_CFL_S_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CFL_S_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CFL_H_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CFL_H_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CFL_U_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_CFL_U_GT3_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_AML_CFL_GT2_IDS(MACRO__, ## __VA_ARGS__) /* WHL/CFL U GT1 */ #define INTEL_WHL_U_GT1_IDS(MACRO__, ...) \ MACRO__(0x3EA1, ## __VA_ARGS__), \ MACRO__(0x3EA4, ## __VA_ARGS__) /* WHL/CFL U GT2 */ #define INTEL_WHL_U_GT2_IDS(MACRO__, ...) \ MACRO__(0x3EA0, ## __VA_ARGS__), \ MACRO__(0x3EA3, ## __VA_ARGS__) /* WHL/CFL U GT3 */ #define INTEL_WHL_U_GT3_IDS(MACRO__, ...) \ MACRO__(0x3EA2, ## __VA_ARGS__) #define INTEL_WHL_IDS(MACRO__, ...) \ INTEL_WHL_U_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_WHL_U_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_WHL_U_GT3_IDS(MACRO__, ## __VA_ARGS__) /* CNL */ #define INTEL_CNL_PORT_F_IDS(MACRO__, ...) \ MACRO__(0x5A44, ## __VA_ARGS__), \ MACRO__(0x5A4C, ## __VA_ARGS__), \ MACRO__(0x5A54, ## __VA_ARGS__), \ MACRO__(0x5A5C, ## __VA_ARGS__) #define INTEL_CNL_IDS(MACRO__, ...) \ INTEL_CNL_PORT_F_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x5A40, ## __VA_ARGS__), \ MACRO__(0x5A41, ## __VA_ARGS__), \ MACRO__(0x5A42, ## __VA_ARGS__), \ MACRO__(0x5A49, ## __VA_ARGS__), \ MACRO__(0x5A4A, ## __VA_ARGS__), \ MACRO__(0x5A50, ## __VA_ARGS__), \ MACRO__(0x5A51, ## __VA_ARGS__), \ MACRO__(0x5A52, ## __VA_ARGS__), \ MACRO__(0x5A59, ## __VA_ARGS__), \ MACRO__(0x5A5A, ## __VA_ARGS__) /* ICL */ #define INTEL_ICL_PORT_F_IDS(MACRO__, ...) \ MACRO__(0x8A50, ## __VA_ARGS__), \ MACRO__(0x8A52, ## __VA_ARGS__), \ MACRO__(0x8A53, ## __VA_ARGS__), \ MACRO__(0x8A54, ## __VA_ARGS__), \ MACRO__(0x8A56, ## __VA_ARGS__), \ MACRO__(0x8A57, ## __VA_ARGS__), \ MACRO__(0x8A58, ## __VA_ARGS__), \ MACRO__(0x8A59, ## __VA_ARGS__), \ MACRO__(0x8A5A, ## __VA_ARGS__), \ MACRO__(0x8A5B, ## __VA_ARGS__), \ MACRO__(0x8A5C, ## __VA_ARGS__), \ MACRO__(0x8A70, ## __VA_ARGS__), \ MACRO__(0x8A71, ## __VA_ARGS__) #define INTEL_ICL_IDS(MACRO__, ...) \ INTEL_ICL_PORT_F_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0x8A51, ## __VA_ARGS__), \ MACRO__(0x8A5D, ## __VA_ARGS__) /* EHL */ #define INTEL_EHL_IDS(MACRO__, ...) \ MACRO__(0x4541, ## __VA_ARGS__), \ MACRO__(0x4551, ## __VA_ARGS__), \ MACRO__(0x4555, ## __VA_ARGS__), \ MACRO__(0x4557, ## __VA_ARGS__), \ MACRO__(0x4570, ## __VA_ARGS__), \ MACRO__(0x4571, ## __VA_ARGS__) /* JSL */ #define INTEL_JSL_IDS(MACRO__, ...) \ MACRO__(0x4E51, ## __VA_ARGS__), \ MACRO__(0x4E55, ## __VA_ARGS__), \ MACRO__(0x4E57, ## __VA_ARGS__), \ MACRO__(0x4E61, ## __VA_ARGS__), \ MACRO__(0x4E71, ## __VA_ARGS__) /* TGL */ #define INTEL_TGL_GT1_IDS(MACRO__, ...) \ MACRO__(0x9A60, ## __VA_ARGS__), \ MACRO__(0x9A68, ## __VA_ARGS__), \ MACRO__(0x9A70, ## __VA_ARGS__) #define INTEL_TGL_GT2_IDS(MACRO__, ...) \ MACRO__(0x9A40, ## __VA_ARGS__), \ MACRO__(0x9A49, ## __VA_ARGS__), \ MACRO__(0x9A59, ## __VA_ARGS__), \ MACRO__(0x9A78, ## __VA_ARGS__), \ MACRO__(0x9AC0, ## __VA_ARGS__), \ MACRO__(0x9AC9, ## __VA_ARGS__), \ MACRO__(0x9AD9, ## __VA_ARGS__), \ MACRO__(0x9AF8, ## __VA_ARGS__) #define INTEL_TGL_IDS(MACRO__, ...) \ INTEL_TGL_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_TGL_GT2_IDS(MACRO__, ## __VA_ARGS__) /* RKL */ #define INTEL_RKL_IDS(MACRO__, ...) \ MACRO__(0x4C80, ## __VA_ARGS__), \ MACRO__(0x4C8A, ## __VA_ARGS__), \ MACRO__(0x4C8B, ## __VA_ARGS__), \ MACRO__(0x4C8C, ## __VA_ARGS__), \ MACRO__(0x4C90, ## __VA_ARGS__), \ MACRO__(0x4C9A, ## __VA_ARGS__) /* DG1 */ #define INTEL_DG1_IDS(MACRO__, ...) \ MACRO__(0x4905, ## __VA_ARGS__), \ MACRO__(0x4906, ## __VA_ARGS__), \ MACRO__(0x4907, ## __VA_ARGS__), \ MACRO__(0x4908, ## __VA_ARGS__), \ MACRO__(0x4909, ## __VA_ARGS__) /* ADL-S */ #define INTEL_ADLS_IDS(MACRO__, ...) \ MACRO__(0x4680, ## __VA_ARGS__), \ MACRO__(0x4682, ## __VA_ARGS__), \ MACRO__(0x4688, ## __VA_ARGS__), \ MACRO__(0x468A, ## __VA_ARGS__), \ MACRO__(0x468B, ## __VA_ARGS__), \ MACRO__(0x4690, ## __VA_ARGS__), \ MACRO__(0x4692, ## __VA_ARGS__), \ MACRO__(0x4693, ## __VA_ARGS__) /* ADL-P */ #define INTEL_ADLP_IDS(MACRO__, ...) \ MACRO__(0x46A0, ## __VA_ARGS__), \ MACRO__(0x46A1, ## __VA_ARGS__), \ MACRO__(0x46A2, ## __VA_ARGS__), \ MACRO__(0x46A3, ## __VA_ARGS__), \ MACRO__(0x46A6, ## __VA_ARGS__), \ MACRO__(0x46A8, ## __VA_ARGS__), \ MACRO__(0x46AA, ## __VA_ARGS__), \ MACRO__(0x462A, ## __VA_ARGS__), \ MACRO__(0x4626, ## __VA_ARGS__), \ MACRO__(0x4628, ## __VA_ARGS__), \ MACRO__(0x46B0, ## __VA_ARGS__), \ MACRO__(0x46B1, ## __VA_ARGS__), \ MACRO__(0x46B2, ## __VA_ARGS__), \ MACRO__(0x46B3, ## __VA_ARGS__), \ MACRO__(0x46C0, ## __VA_ARGS__), \ MACRO__(0x46C1, ## __VA_ARGS__), \ MACRO__(0x46C2, ## __VA_ARGS__), \ MACRO__(0x46C3, ## __VA_ARGS__) /* ADL-N */ #define INTEL_ADLN_IDS(MACRO__, ...) \ MACRO__(0x46D0, ## __VA_ARGS__), \ MACRO__(0x46D1, ## __VA_ARGS__), \ MACRO__(0x46D2, ## __VA_ARGS__), \ MACRO__(0x46D3, ## __VA_ARGS__), \ MACRO__(0x46D4, ## __VA_ARGS__) /* RPL-S */ #define INTEL_RPLS_IDS(MACRO__, ...) \ MACRO__(0xA780, ## __VA_ARGS__), \ MACRO__(0xA781, ## __VA_ARGS__), \ MACRO__(0xA782, ## __VA_ARGS__), \ MACRO__(0xA783, ## __VA_ARGS__), \ MACRO__(0xA788, ## __VA_ARGS__), \ MACRO__(0xA789, ## __VA_ARGS__), \ MACRO__(0xA78A, ## __VA_ARGS__), \ MACRO__(0xA78B, ## __VA_ARGS__) /* RPL-U */ #define INTEL_RPLU_IDS(MACRO__, ...) \ MACRO__(0xA721, ## __VA_ARGS__), \ MACRO__(0xA7A1, ## __VA_ARGS__), \ MACRO__(0xA7A9, ## __VA_ARGS__), \ MACRO__(0xA7AC, ## __VA_ARGS__), \ MACRO__(0xA7AD, ## __VA_ARGS__) /* RPL-P */ #define INTEL_RPLP_IDS(MACRO__, ...) \ MACRO__(0xA720, ## __VA_ARGS__), \ MACRO__(0xA7A0, ## __VA_ARGS__), \ MACRO__(0xA7A8, ## __VA_ARGS__), \ MACRO__(0xA7AA, ## __VA_ARGS__), \ MACRO__(0xA7AB, ## __VA_ARGS__) /* DG2 */ #define INTEL_DG2_G10_IDS(MACRO__, ...) \ MACRO__(0x5690, ## __VA_ARGS__), \ MACRO__(0x5691, ## __VA_ARGS__), \ MACRO__(0x5692, ## __VA_ARGS__), \ MACRO__(0x56A0, ## __VA_ARGS__), \ MACRO__(0x56A1, ## __VA_ARGS__), \ MACRO__(0x56A2, ## __VA_ARGS__), \ MACRO__(0x56BE, ## __VA_ARGS__), \ MACRO__(0x56BF, ## __VA_ARGS__) #define INTEL_DG2_G11_IDS(MACRO__, ...) \ MACRO__(0x5693, ## __VA_ARGS__), \ MACRO__(0x5694, ## __VA_ARGS__), \ MACRO__(0x5695, ## __VA_ARGS__), \ MACRO__(0x56A5, ## __VA_ARGS__), \ MACRO__(0x56A6, ## __VA_ARGS__), \ MACRO__(0x56B0, ## __VA_ARGS__), \ MACRO__(0x56B1, ## __VA_ARGS__), \ MACRO__(0x56BA, ## __VA_ARGS__), \ MACRO__(0x56BB, ## __VA_ARGS__), \ MACRO__(0x56BC, ## __VA_ARGS__), \ MACRO__(0x56BD, ## __VA_ARGS__) #define INTEL_DG2_G12_IDS(MACRO__, ...) \ MACRO__(0x5696, ## __VA_ARGS__), \ MACRO__(0x5697, ## __VA_ARGS__), \ MACRO__(0x56A3, ## __VA_ARGS__), \ MACRO__(0x56A4, ## __VA_ARGS__), \ MACRO__(0x56B2, ## __VA_ARGS__), \ MACRO__(0x56B3, ## __VA_ARGS__) #define INTEL_DG2_IDS(MACRO__, ...) \ INTEL_DG2_G10_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_DG2_G11_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_DG2_G12_IDS(MACRO__, ## __VA_ARGS__) #define INTEL_ATS_M150_IDS(MACRO__, ...) \ MACRO__(0x56C0, ## __VA_ARGS__), \ MACRO__(0x56C2, ## __VA_ARGS__) #define INTEL_ATS_M75_IDS(MACRO__, ...) \ MACRO__(0x56C1, ## __VA_ARGS__) #define INTEL_ATS_M_IDS(MACRO__, ...) \ INTEL_ATS_M150_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_ATS_M75_IDS(MACRO__, ## __VA_ARGS__) /* MTL */ #define INTEL_MTL_IDS(MACRO__, ...) \ MACRO__(0x7D40, ## __VA_ARGS__), \ MACRO__(0x7D41, ## __VA_ARGS__), \ MACRO__(0x7D45, ## __VA_ARGS__), \ MACRO__(0x7D51, ## __VA_ARGS__), \ MACRO__(0x7D55, ## __VA_ARGS__), \ MACRO__(0x7D60, ## __VA_ARGS__), \ MACRO__(0x7D67, ## __VA_ARGS__), \ MACRO__(0x7DD1, ## __VA_ARGS__), \ MACRO__(0x7DD5, ## __VA_ARGS__) #endif /* _I915_PCIIDS_H */ aristocratos-btop-d43a485/src/linux/intel_gpu_top/i915_pciids_local.h000066400000000000000000000032071517514752700257120ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* * Copyright ยฉ 2022 Intel Corporation */ #ifndef _I915_PCIIDS_LOCAL_H_ #define _I915_PCIIDS_LOCAL_H_ #include "i915_pciids.h" /* MTL perf */ #ifndef INTEL_MTL_M_IDS #define INTEL_MTL_M_IDS(MACRO__, ...) \ MACRO__(0x7D60, ## __VA_ARGS__), \ MACRO__(0x7D67, ## __VA_ARGS__) #endif #ifndef INTEL_MTL_P_GT2_IDS #define INTEL_MTL_P_GT2_IDS(MACRO__, ...) \ MACRO__(0x7D45, ## __VA_ARGS__) #endif #ifndef INTEL_MTL_P_GT3_IDS #define INTEL_MTL_P_GT3_IDS(MACRO__, ...) \ MACRO__(0x7D55, ## __VA_ARGS__), \ MACRO__(0x7DD5, ## __VA_ARGS__) #endif #ifndef INTEL_MTL_P_IDS #define INTEL_MTL_P_IDS(MACRO__, ...) \ INTEL_MTL_P_GT2_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_MTL_P_GT3_IDS(MACRO__, ## __VA_ARGS__) #endif #ifndef INTEL_ARL_GT1_IDS #define INTEL_ARL_GT1_IDS(MACRO__, ...) \ MACRO__(0x7D41, ## __VA_ARGS__), \ MACRO__(0x7D67, ## __VA_ARGS__) #endif #ifndef INTEL_ARL_GT2_IDS #define INTEL_ARL_GT2_IDS(MACRO__, ...) \ MACRO__(0x7D51, ## __VA_ARGS__), \ MACRO__(0x7DD1, ## __VA_ARGS__) #endif #ifndef INTEL_ARL_IDS #define INTEL_ARL_IDS(MACRO__, ...) \ INTEL_ARL_GT1_IDS(MACRO__, ## __VA_ARGS__), \ INTEL_ARL_GT2_IDS(MACRO__, ## __VA_ARGS__) #endif /* PVC */ #ifndef INTEL_PVC_IDS #define INTEL_PVC_IDS(MACRO__, ...) \ MACRO__(0x0BD0, ## __VA_ARGS__), \ MACRO__(0x0BD1, ## __VA_ARGS__), \ MACRO__(0x0BD2, ## __VA_ARGS__), \ MACRO__(0x0BD5, ## __VA_ARGS__), \ MACRO__(0x0BD6, ## __VA_ARGS__), \ MACRO__(0x0BD7, ## __VA_ARGS__), \ MACRO__(0x0BD8, ## __VA_ARGS__), \ MACRO__(0x0BD9, ## __VA_ARGS__), \ MACRO__(0x0BDA, ## __VA_ARGS__), \ MACRO__(0x0BDB, ## __VA_ARGS__) #endif #endif /* _I915_PCIIDS_LOCAL_H */ aristocratos-btop-d43a485/src/linux/intel_gpu_top/igt_perf.c000066400000000000000000000101521517514752700243050ustar00rootroot00000000000000#include #include #include #include #include #include #include #ifdef __linux__ #include #include #include #endif #include #include #include #include "igt_perf.h" static char *bus_address(int i915, char *path, int pathlen) { struct stat st; int len = -1; int dir; char *s; if (fstat(i915, &st) || !S_ISCHR(st.st_mode)) return NULL; snprintf(path, pathlen, "/sys/dev/char/%d:%d", major(st.st_rdev), minor(st.st_rdev)); dir = open(path, O_RDONLY); if (dir != -1) { len = readlinkat(dir, "device", path, pathlen - 1); close(dir); } if (len < 0) return NULL; path[len] = '\0'; /* strip off the relative path */ s = strrchr(path, '/'); if (s) memmove(path, s + 1, len - (s - path) + 1); return path; } const char *i915_perf_device(int i915, char *buf, int buflen) { char *s; #define prefix "i915_" #define plen strlen(prefix) if (!buf || buflen < plen) return "i915"; memcpy(buf, prefix, plen); if (!bus_address(i915, buf + plen, buflen - plen) || strcmp(buf + plen, "0000:00:02.0") == 0) /* legacy name for igfx */ buf[plen - 1] = '\0'; /* Convert all colons in the address to '_', thanks perf! */ for (s = buf; *s; s++) if (*s == ':') *s = '_'; return buf; } const char *xe_perf_device(int xe, char *buf, int buflen) { char *s; char pref[] = "xe_"; int len = strlen(pref); if (!buf || buflen < len) return "xe"; memcpy(buf, pref, len); if (!bus_address(xe, buf + len, buflen - len)) buf[len - 1] = '\0'; /* Convert all colons in the address to '_', thanks perf! */ for (s = buf; *s; s++) if (*s == ':') *s = '_'; return buf; } uint64_t xe_perf_type_id(int xe) { char buf[80]; return igt_perf_type_id(xe_perf_device(xe, buf, sizeof(buf))); } uint64_t i915_perf_type_id(int i915) { char buf[80]; return igt_perf_type_id(i915_perf_device(i915, buf, sizeof(buf))); } uint64_t igt_perf_type_id(const char *device) { char buf[64]; ssize_t ret; int fd; snprintf(buf, sizeof(buf), "/sys/bus/event_source/devices/%s/type", device); fd = open(buf, O_RDONLY); if (fd < 0) return 0; ret = read(fd, buf, sizeof(buf) - 1); close(fd); if (ret < 1) return 0; buf[ret] = '\0'; return strtoull(buf, NULL, 0); } int igt_perf_events_dir(int i915) { char buf[80]; char path[PATH_MAX]; i915_perf_device(i915, buf, sizeof(buf)); snprintf(path, sizeof(path), "/sys/bus/event_source/devices/%s/events", buf); return open(path, O_RDONLY); } static int _perf_open(uint64_t type, uint64_t config, int group, uint64_t format) { struct perf_event_attr attr = { }; int nr_cpus = get_nprocs_conf(); int cpu = 0, ret; attr.type = type; if (attr.type == 0) return -ENOENT; if (group >= 0) format &= ~PERF_FORMAT_GROUP; attr.read_format = format; attr.config = config; attr.use_clockid = 1; attr.clockid = CLOCK_MONOTONIC; do { ret = perf_event_open(&attr, -1, cpu++, group, 0); } while ((ret < 0 && errno == EINVAL) && (cpu < nr_cpus)); return ret; } int perf_igfx_open(uint64_t config) { return _perf_open(igt_perf_type_id("i915"), config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED); } int perf_igfx_open_group(uint64_t config, int group) { return _perf_open(igt_perf_type_id("i915"), config, group, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP); } int perf_xe_open(int xe, uint64_t config) { return _perf_open(xe_perf_type_id(xe), config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED); } int perf_i915_open(int i915, uint64_t config) { return _perf_open(i915_perf_type_id(i915), config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED); } int perf_i915_open_group(int i915, uint64_t config, int group) { return _perf_open(i915_perf_type_id(i915), config, group, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP); } int igt_perf_open(uint64_t type, uint64_t config) { return _perf_open(type, config, -1, PERF_FORMAT_TOTAL_TIME_ENABLED); } int igt_perf_open_group(uint64_t type, uint64_t config, int group) { return _perf_open(type, config, group, PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_GROUP); } aristocratos-btop-d43a485/src/linux/intel_gpu_top/igt_perf.h000066400000000000000000000045411517514752700243170ustar00rootroot00000000000000/* * Copyright ยฉ 2017 Intel Corporation * * 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 (including the next * paragraph) 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 I915_PERF_H #define I915_PERF_H #include #ifdef __linux__ #include #endif //#include "igt_gt.h" static inline int perf_event_open(struct perf_event_attr *attr, pid_t pid, int cpu, int group_fd, unsigned long flags) { #ifndef __NR_perf_event_open #if defined(__i386__) #define __NR_perf_event_open 336 #elif defined(__x86_64__) #define __NR_perf_event_open 298 #else #define __NR_perf_event_open 0 #endif #endif attr->size = sizeof(*attr); return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags); } uint64_t igt_perf_type_id(const char *device); int igt_perf_events_dir(int i915); int igt_perf_open(uint64_t type, uint64_t config); int igt_perf_open_group(uint64_t type, uint64_t config, int group); const char *i915_perf_device(int i915, char *buf, int buflen); uint64_t i915_perf_type_id(int i915); const char *xe_perf_device(int xe, char *buf, int buflen); uint64_t xe_perf_type_id(int); int perf_igfx_open(uint64_t config); int perf_igfx_open_group(uint64_t config, int group); int perf_i915_open(int i915, uint64_t config); int perf_i915_open_group(int i915, uint64_t config, int group); int perf_xe_open(int xe, uint64_t config); #endif /* I915_PERF_H */ aristocratos-btop-d43a485/src/linux/intel_gpu_top/intel_chipset.h000066400000000000000000000201321517514752700253440ustar00rootroot00000000000000/* * Copyright ยฉ 2007 Intel Corporation * * 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 (including the next * paragraph) 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. * * Authors: * Eric Anholt * */ #ifndef _INTEL_CHIPSET_H #define _INTEL_CHIPSET_H #include #include #define BIT(x) (1ul <<(x)) struct intel_device_info { unsigned graphics_ver; unsigned graphics_rel; unsigned display_ver; unsigned gt; /* 0 if unknown */ bool has_4tile : 1; bool has_flatccs : 1; bool has_oam : 1; bool is_mobile : 1; bool is_whitney : 1; bool is_almador : 1; bool is_brookdale : 1; bool is_montara : 1; bool is_springdale : 1; bool is_grantsdale : 1; bool is_alviso : 1; bool is_lakeport : 1; bool is_calistoga : 1; bool is_bearlake : 1; bool is_pineview : 1; bool is_broadwater : 1; bool is_crestline : 1; bool is_eaglelake : 1; bool is_cantiga : 1; bool is_ironlake : 1; bool is_arrandale : 1; bool is_sandybridge : 1; bool is_ivybridge : 1; bool is_valleyview : 1; bool is_haswell : 1; bool is_broadwell : 1; bool is_cherryview : 1; bool is_skylake : 1; bool is_broxton : 1; bool is_kabylake : 1; bool is_geminilake : 1; bool is_coffeelake : 1; bool is_cometlake : 1; bool is_cannonlake : 1; bool is_icelake : 1; bool is_elkhartlake : 1; bool is_jasperlake : 1; bool is_tigerlake : 1; bool is_rocketlake : 1; bool is_dg1 : 1; bool is_dg2 : 1; bool is_alderlake_s : 1; bool is_raptorlake_s : 1; bool is_alderlake_p : 1; bool is_alderlake_n : 1; bool is_meteorlake : 1; bool is_pontevecchio : 1; bool is_lunarlake : 1; bool is_battlemage : 1; const char *codename; }; const struct intel_device_info *intel_get_device_info(uint16_t devid) __attribute__((pure)); extern enum pch_type intel_pch; enum pch_type { PCH_NONE, PCH_IBX, PCH_CPT, PCH_LPT, }; void intel_check_pch(void); #define HAS_IBX (intel_pch == PCH_IBX) #define HAS_CPT (intel_pch == PCH_CPT) #define HAS_LPT (intel_pch == PCH_LPT) #define IP_VER(ver, rel) ((ver) << 8 | (rel)) /* Exclude chipset #defines, they just add noise */ #ifndef __GTK_DOC_IGNORE__ #define PCI_CHIP_I810 0x7121 #define PCI_CHIP_I810_DC100 0x7123 #define PCI_CHIP_I810_E 0x7125 #define PCI_CHIP_I815 0x1132 #define PCI_CHIP_I830_M 0x3577 #define PCI_CHIP_845_G 0x2562 #define PCI_CHIP_I854_G 0x358e #define PCI_CHIP_I855_GM 0x3582 #define PCI_CHIP_I865_G 0x2572 #define PCI_CHIP_I915_G 0x2582 #define PCI_CHIP_E7221_G 0x258A #define PCI_CHIP_I915_GM 0x2592 #define PCI_CHIP_I945_G 0x2772 #define PCI_CHIP_I945_GM 0x27A2 #define PCI_CHIP_I945_GME 0x27AE #define PCI_CHIP_I965_G 0x29A2 #define PCI_CHIP_I965_Q 0x2992 #define PCI_CHIP_I965_G_1 0x2982 #define PCI_CHIP_I946_GZ 0x2972 #define PCI_CHIP_I965_GM 0x2A02 #define PCI_CHIP_I965_GME 0x2A12 #define PCI_CHIP_GM45_GM 0x2A42 #define PCI_CHIP_Q45_G 0x2E12 #define PCI_CHIP_G45_G 0x2E22 #define PCI_CHIP_G41_G 0x2E32 #endif /* __GTK_DOC_IGNORE__ */ #define IS_915G(devid) (intel_get_device_info(devid)->is_grantsdale) #define IS_915GM(devid) (intel_get_device_info(devid)->is_alviso) #define IS_915(devid) (IS_915G(devid) || IS_915GM(devid)) #define IS_945G(devid) (intel_get_device_info(devid)->is_lakeport) #define IS_945GM(devid) (intel_get_device_info(devid)->is_calistoga) #define IS_945(devid) (IS_945G(devid) || \ IS_945GM(devid) || \ IS_G33(devid)) #define IS_PINEVIEW(devid) (intel_get_device_info(devid)->is_pineview) #define IS_G33(devid) (intel_get_device_info(devid)->is_bearlake || \ intel_get_device_info(devid)->is_pineview) #define IS_BROADWATER(devid) (intel_get_device_info(devid)->is_broadwater) #define IS_CRESTLINE(devid) (intel_get_device_info(devid)->is_crestline) #define IS_GM45(devid) (intel_get_device_info(devid)->is_cantiga) #define IS_G45(devid) (intel_get_device_info(devid)->is_eaglelake) #define IS_G4X(devid) (IS_G45(devid) || IS_GM45(devid)) #define IS_IRONLAKE(devid) (intel_get_device_info(devid)->is_ironlake) #define IS_ARRANDALE(devid) (intel_get_device_info(devid)->is_arrandale) #define IS_SANDYBRIDGE(devid) (intel_get_device_info(devid)->is_sandybridge) #define IS_IVYBRIDGE(devid) (intel_get_device_info(devid)->is_ivybridge) #define IS_VALLEYVIEW(devid) (intel_get_device_info(devid)->is_valleyview) #define IS_HASWELL(devid) (intel_get_device_info(devid)->is_haswell) #define IS_BROADWELL(devid) (intel_get_device_info(devid)->is_broadwell) #define IS_CHERRYVIEW(devid) (intel_get_device_info(devid)->is_cherryview) #define IS_SKYLAKE(devid) (intel_get_device_info(devid)->is_skylake) #define IS_BROXTON(devid) (intel_get_device_info(devid)->is_broxton) #define IS_KABYLAKE(devid) (intel_get_device_info(devid)->is_kabylake) #define IS_GEMINILAKE(devid) (intel_get_device_info(devid)->is_geminilake) #define IS_COFFEELAKE(devid) (intel_get_device_info(devid)->is_coffeelake) #define IS_COMETLAKE(devid) (intel_get_device_info(devid)->is_cometlake) #define IS_CANNONLAKE(devid) (intel_get_device_info(devid)->is_cannonlake) #define IS_ICELAKE(devid) (intel_get_device_info(devid)->is_icelake) #define IS_TIGERLAKE(devid) (intel_get_device_info(devid)->is_tigerlake) #define IS_ROCKETLAKE(devid) (intel_get_device_info(devid)->is_rocketlake) #define IS_DG1(devid) (intel_get_device_info(devid)->is_dg1) #define IS_DG2(devid) (intel_get_device_info(devid)->is_dg2) #define IS_ALDERLAKE_S(devid) (intel_get_device_info(devid)->is_alderlake_s) #define IS_RAPTORLAKE_S(devid) (intel_get_device_info(devid)->is_raptorlake_s) #define IS_ALDERLAKE_P(devid) (intel_get_device_info(devid)->is_alderlake_p) #define IS_ALDERLAKE_N(devid) (intel_get_device_info(devid)->is_alderlake_n) #define IS_METEORLAKE(devid) (intel_get_device_info(devid)->is_meteorlake) #define IS_PONTEVECCHIO(devid) (intel_get_device_info(devid)->is_pontevecchio) #define IS_LUNARLAKE(devid) (intel_get_device_info(devid)->is_lunarlake) #define IS_BATTLEMAGE(devid) (intel_get_device_info(devid)->is_battlemage) #define IS_GEN(devid, x) (intel_get_device_info(devid)->graphics_ver == x) #define AT_LEAST_GEN(devid, x) (intel_get_device_info(devid)->graphics_ver >= x) #define AT_LEAST_DISPLAY(devid, x) (intel_get_device_info(devid)->display_ver >= x) #define IS_GEN2(devid) IS_GEN(devid, 2) #define IS_GEN3(devid) IS_GEN(devid, 3) #define IS_GEN4(devid) IS_GEN(devid, 4) #define IS_GEN5(devid) IS_GEN(devid, 5) #define IS_GEN6(devid) IS_GEN(devid, 6) #define IS_GEN7(devid) IS_GEN(devid, 7) #define IS_GEN8(devid) IS_GEN(devid, 8) #define IS_GEN9(devid) IS_GEN(devid, 9) #define IS_GEN10(devid) IS_GEN(devid, 10) #define IS_GEN11(devid) IS_GEN(devid, 11) #define IS_GEN12(devid) IS_GEN(devid, 12) #define IS_MOBILE(devid) (intel_get_device_info(devid)->is_mobile) #define IS_965(devid) AT_LEAST_GEN(devid, 4) #define HAS_BSD_RING(devid) AT_LEAST_GEN(devid, 5) #define HAS_BLT_RING(devid) AT_LEAST_GEN(devid, 6) #define HAS_PCH_SPLIT(devid) (AT_LEAST_GEN(devid, 5) && \ !(IS_VALLEYVIEW(devid) || \ IS_CHERRYVIEW(devid) || \ IS_BROXTON(devid))) #define HAS_4TILE(devid) (intel_get_device_info(devid)->has_4tile) #define HAS_FLATCCS(devid) (intel_get_device_info(devid)->has_flatccs) #define HAS_OAM(devid) (intel_get_device_info(devid)->has_oam) #endif /* _INTEL_CHIPSET_H */ aristocratos-btop-d43a485/src/linux/intel_gpu_top/intel_device_info.c000066400000000000000000000403301517514752700261540ustar00rootroot00000000000000#include "intel_chipset.h" #include "i915_pciids.h" #include "i915_pciids_local.h" #include "xe_pciids.h" #include /* ffs() */ // from pciaccess.h #define PCI_MATCH_ANY (~0U) // from pciaccess.h struct pci_id_match { /** * \name Device / vendor matching controls * * Control the search based on the device, vendor, subdevice, or subvendor * IDs. Setting any of these fields to \c PCI_MATCH_ANY will cause the * field to not be used in the comparison. */ /*@{*/ uint32_t vendor_id; uint32_t device_id; uint32_t subvendor_id; uint32_t subdevice_id; /*@}*/ /** * \name Device class matching controls * */ /*@{*/ uint32_t device_class; uint32_t device_class_mask; /*@}*/ intptr_t match_data; }; static const struct intel_device_info intel_generic_info = { .graphics_ver = 0, .display_ver = 0, }; static const struct intel_device_info intel_i810_info = { .graphics_ver = 1, .display_ver = 1, .is_whitney = true, .codename = "solano" /* 815 == "whitney" ? or vice versa? */ }; static const struct intel_device_info intel_i815_info = { .graphics_ver = 1, .display_ver = 1, .is_whitney = true, .codename = "whitney" }; static const struct intel_device_info intel_i830_info = { .graphics_ver = 2, .display_ver = 2, .is_almador = true, .codename = "almador" }; static const struct intel_device_info intel_i845_info = { .graphics_ver = 2, .display_ver = 2, .is_brookdale = true, .codename = "brookdale" }; static const struct intel_device_info intel_i855_info = { .graphics_ver = 2, .display_ver = 2, .is_mobile = true, .is_montara = true, .codename = "montara" }; static const struct intel_device_info intel_i865_info = { .graphics_ver = 2, .display_ver = 2, .is_springdale = true, .codename = "spingdale" }; static const struct intel_device_info intel_i915_info = { .graphics_ver = 3, .display_ver = 3, .is_grantsdale = true, .codename = "grantsdale" }; static const struct intel_device_info intel_i915m_info = { .graphics_ver = 3, .display_ver = 3, .is_mobile = true, .is_alviso = true, .codename = "alviso" }; static const struct intel_device_info intel_i945_info = { .graphics_ver = 3, .display_ver = 3, .is_lakeport = true, .codename = "lakeport" }; static const struct intel_device_info intel_i945m_info = { .graphics_ver = 3, .display_ver = 3, .is_mobile = true, .is_calistoga = true, .codename = "calistoga" }; static const struct intel_device_info intel_g33_info = { .graphics_ver = 3, .display_ver = 3, .is_bearlake = true, .codename = "bearlake" }; static const struct intel_device_info intel_pineview_g_info = { .graphics_ver = 3, .display_ver = 3, .is_pineview = true, .codename = "pineview" }; static const struct intel_device_info intel_pineview_m_info = { .graphics_ver = 3, .display_ver = 3, .is_mobile = true, .is_pineview = true, .codename = "pineview" }; static const struct intel_device_info intel_i965_info = { .graphics_ver = 4, .display_ver = 4, .is_broadwater = true, .codename = "broadwater" }; static const struct intel_device_info intel_i965m_info = { .graphics_ver = 4, .display_ver = 4, .is_mobile = true, .is_crestline = true, .codename = "crestline" }; static const struct intel_device_info intel_g45_info = { .graphics_ver = 4, .display_ver = 4, .is_eaglelake = true, .codename = "eaglelake" }; static const struct intel_device_info intel_gm45_info = { .graphics_ver = 4, .display_ver = 4, .is_mobile = true, .is_cantiga = true, .codename = "cantiga" }; static const struct intel_device_info intel_ironlake_info = { .graphics_ver = 5, .display_ver = 5, .is_ironlake = true, .codename = "ironlake" /* clarkdale? */ }; static const struct intel_device_info intel_ironlake_m_info = { .graphics_ver = 5, .display_ver = 5, .is_mobile = true, .is_arrandale = true, .codename = "arrandale" }; static const struct intel_device_info intel_sandybridge_info = { .graphics_ver = 6, .display_ver = 6, .is_sandybridge = true, .codename = "sandybridge" }; static const struct intel_device_info intel_sandybridge_m_info = { .graphics_ver = 6, .display_ver = 6, .is_mobile = true, .is_sandybridge = true, .codename = "sandybridge" }; static const struct intel_device_info intel_ivybridge_info = { .graphics_ver = 7, .display_ver = 7, .is_ivybridge = true, .codename = "ivybridge" }; static const struct intel_device_info intel_ivybridge_m_info = { .graphics_ver = 7, .display_ver = 7, .is_mobile = true, .is_ivybridge = true, .codename = "ivybridge" }; static const struct intel_device_info intel_valleyview_info = { .graphics_ver = 7, .display_ver = 7, .is_valleyview = true, .codename = "valleyview" }; #define HASWELL_FIELDS \ .graphics_ver = 7, \ .display_ver = 7, \ .is_haswell = true, \ .codename = "haswell" static const struct intel_device_info intel_haswell_gt1_info = { HASWELL_FIELDS, .gt = 1, }; static const struct intel_device_info intel_haswell_gt2_info = { HASWELL_FIELDS, .gt = 2, }; static const struct intel_device_info intel_haswell_gt3_info = { HASWELL_FIELDS, .gt = 3, }; #define BROADWELL_FIELDS \ .graphics_ver = 8, \ .display_ver = 8, \ .is_broadwell = true, \ .codename = "broadwell" static const struct intel_device_info intel_broadwell_gt1_info = { BROADWELL_FIELDS, .gt = 1, }; static const struct intel_device_info intel_broadwell_gt2_info = { BROADWELL_FIELDS, .gt = 2, }; static const struct intel_device_info intel_broadwell_gt3_info = { BROADWELL_FIELDS, .gt = 3, }; static const struct intel_device_info intel_broadwell_unknown_info = { BROADWELL_FIELDS, }; static const struct intel_device_info intel_cherryview_info = { .graphics_ver = 8, .display_ver = 8, .is_cherryview = true, .codename = "cherryview" }; #define SKYLAKE_FIELDS \ .graphics_ver = 9, \ .display_ver = 9, \ .codename = "skylake", \ .is_skylake = true static const struct intel_device_info intel_skylake_gt1_info = { SKYLAKE_FIELDS, .gt = 1, }; static const struct intel_device_info intel_skylake_gt2_info = { SKYLAKE_FIELDS, .gt = 2, }; static const struct intel_device_info intel_skylake_gt3_info = { SKYLAKE_FIELDS, .gt = 3, }; static const struct intel_device_info intel_skylake_gt4_info = { SKYLAKE_FIELDS, .gt = 4, }; static const struct intel_device_info intel_broxton_info = { .graphics_ver = 9, .display_ver = 9, .is_broxton = true, .codename = "broxton" }; #define KABYLAKE_FIELDS \ .graphics_ver = 9, \ .display_ver = 9, \ .is_kabylake = true, \ .codename = "kabylake" static const struct intel_device_info intel_kabylake_gt1_info = { KABYLAKE_FIELDS, .gt = 1, }; static const struct intel_device_info intel_kabylake_gt2_info = { KABYLAKE_FIELDS, .gt = 2, }; static const struct intel_device_info intel_kabylake_gt3_info = { KABYLAKE_FIELDS, .gt = 3, }; static const struct intel_device_info intel_kabylake_gt4_info = { KABYLAKE_FIELDS, .gt = 4, }; static const struct intel_device_info intel_geminilake_info = { .graphics_ver = 9, .display_ver = 9, .is_geminilake = true, .codename = "geminilake" }; #define COFFEELAKE_FIELDS \ .graphics_ver = 9, \ .display_ver = 9, \ .is_coffeelake = true, \ .codename = "coffeelake" static const struct intel_device_info intel_coffeelake_gt1_info = { COFFEELAKE_FIELDS, .gt = 1, }; static const struct intel_device_info intel_coffeelake_gt2_info = { COFFEELAKE_FIELDS, .gt = 2, }; static const struct intel_device_info intel_coffeelake_gt3_info = { COFFEELAKE_FIELDS, .gt = 3, }; #define COMETLAKE_FIELDS \ .graphics_ver = 9, \ .display_ver = 9, \ .is_cometlake = true, \ .codename = "cometlake" static const struct intel_device_info intel_cometlake_gt1_info = { COMETLAKE_FIELDS, .gt = 1, }; static const struct intel_device_info intel_cometlake_gt2_info = { COMETLAKE_FIELDS, .gt = 2, }; static const struct intel_device_info intel_cannonlake_info = { .graphics_ver = 10, .display_ver = 10, .is_cannonlake = true, .codename = "cannonlake" }; static const struct intel_device_info intel_icelake_info = { .graphics_ver = 11, .display_ver = 11, .is_icelake = true, .codename = "icelake" }; static const struct intel_device_info intel_elkhartlake_info = { .graphics_ver = 11, .display_ver = 11, .is_elkhartlake = true, .codename = "elkhartlake" }; static const struct intel_device_info intel_jasperlake_info = { .graphics_ver = 11, .display_ver = 11, .is_jasperlake = true, .codename = "jasperlake" }; static const struct intel_device_info intel_tigerlake_gt1_info = { .graphics_ver = 12, .display_ver = 12, .is_tigerlake = true, .codename = "tigerlake", .gt = 1, }; static const struct intel_device_info intel_tigerlake_gt2_info = { .graphics_ver = 12, .display_ver = 12, .is_tigerlake = true, .codename = "tigerlake", .gt = 2, }; static const struct intel_device_info intel_rocketlake_info = { .graphics_ver = 12, .display_ver = 12, .is_rocketlake = true, .codename = "rocketlake" }; static const struct intel_device_info intel_dg1_info = { .graphics_ver = 12, .graphics_rel = 10, .display_ver = 12, .is_dg1 = true, .codename = "dg1" }; static const struct intel_device_info intel_dg2_info = { .graphics_ver = 12, .graphics_rel = 55, .display_ver = 13, .has_4tile = true, .is_dg2 = true, .codename = "dg2", .has_flatccs = true, }; static const struct intel_device_info intel_alderlake_s_info = { .graphics_ver = 12, .display_ver = 12, .is_alderlake_s = true, .codename = "alderlake_s" }; static const struct intel_device_info intel_raptorlake_s_info = { .graphics_ver = 12, .display_ver = 12, .is_raptorlake_s = true, .codename = "raptorlake_s" }; static const struct intel_device_info intel_alderlake_p_info = { .graphics_ver = 12, .display_ver = 13, .is_alderlake_p = true, .codename = "alderlake_p" }; static const struct intel_device_info intel_alderlake_n_info = { .graphics_ver = 12, .display_ver = 13, .is_alderlake_n = true, .codename = "alderlake_n" }; static const struct intel_device_info intel_ats_m_info = { .graphics_ver = 12, .graphics_rel = 55, .display_ver = 0, /* no display support */ .is_dg2 = true, .has_4tile = true, .codename = "ats_m", .has_flatccs = true, }; static const struct intel_device_info intel_meteorlake_info = { .graphics_ver = 12, .graphics_rel = 70, .display_ver = 14, .has_4tile = true, .has_oam = true, .is_meteorlake = true, .codename = "meteorlake", }; static const struct intel_device_info intel_pontevecchio_info = { .graphics_ver = 12, .graphics_rel = 60, .is_pontevecchio = true, .codename = "pontevecchio", }; static const struct intel_device_info intel_lunarlake_info = { .graphics_ver = 20, .graphics_rel = 4, .display_ver = 20, .has_4tile = true, .has_flatccs = true, .has_oam = true, .is_lunarlake = true, .codename = "lunarlake", }; static const struct intel_device_info intel_battlemage_info = { .graphics_ver = 20, .graphics_rel = 1, .display_ver = 14, .has_4tile = true, .has_flatccs = true, .is_battlemage = true, .codename = "battlemage", }; static const struct pci_id_match intel_device_match[] = { INTEL_I810_IDS(INTEL_VGA_DEVICE, &intel_i810_info), INTEL_I815_IDS(INTEL_VGA_DEVICE, &intel_i815_info), INTEL_I830_IDS(INTEL_VGA_DEVICE, &intel_i830_info), INTEL_I845G_IDS(INTEL_VGA_DEVICE, &intel_i845_info), INTEL_I85X_IDS(INTEL_VGA_DEVICE, &intel_i855_info), INTEL_I865G_IDS(INTEL_VGA_DEVICE, &intel_i865_info), INTEL_I915G_IDS(INTEL_VGA_DEVICE, &intel_i915_info), INTEL_I915GM_IDS(INTEL_VGA_DEVICE, &intel_i915m_info), INTEL_I945G_IDS(INTEL_VGA_DEVICE, &intel_i945_info), INTEL_I945GM_IDS(INTEL_VGA_DEVICE, &intel_i945m_info), INTEL_G33_IDS(INTEL_VGA_DEVICE, &intel_g33_info), INTEL_PNV_G_IDS(INTEL_VGA_DEVICE, &intel_pineview_g_info), INTEL_PNV_M_IDS(INTEL_VGA_DEVICE, &intel_pineview_m_info), INTEL_I965G_IDS(INTEL_VGA_DEVICE, &intel_i965_info), INTEL_I965GM_IDS(INTEL_VGA_DEVICE, &intel_i965m_info), INTEL_G45_IDS(INTEL_VGA_DEVICE, &intel_g45_info), INTEL_GM45_IDS(INTEL_VGA_DEVICE, &intel_gm45_info), INTEL_ILK_D_IDS(INTEL_VGA_DEVICE, &intel_ironlake_info), INTEL_ILK_M_IDS(INTEL_VGA_DEVICE, &intel_ironlake_m_info), INTEL_SNB_D_IDS(INTEL_VGA_DEVICE, &intel_sandybridge_info), INTEL_SNB_M_IDS(INTEL_VGA_DEVICE, &intel_sandybridge_m_info), INTEL_IVB_D_IDS(INTEL_VGA_DEVICE, &intel_ivybridge_info), INTEL_IVB_M_IDS(INTEL_VGA_DEVICE, &intel_ivybridge_m_info), INTEL_HSW_GT1_IDS(INTEL_VGA_DEVICE, &intel_haswell_gt1_info), INTEL_HSW_GT2_IDS(INTEL_VGA_DEVICE, &intel_haswell_gt2_info), INTEL_HSW_GT3_IDS(INTEL_VGA_DEVICE, &intel_haswell_gt3_info), INTEL_VLV_IDS(INTEL_VGA_DEVICE, &intel_valleyview_info), INTEL_BDW_GT1_IDS(INTEL_VGA_DEVICE, &intel_broadwell_gt1_info), INTEL_BDW_GT2_IDS(INTEL_VGA_DEVICE, &intel_broadwell_gt2_info), INTEL_BDW_GT3_IDS(INTEL_VGA_DEVICE, &intel_broadwell_gt3_info), INTEL_BDW_RSVD_IDS(INTEL_VGA_DEVICE, &intel_broadwell_unknown_info), INTEL_CHV_IDS(INTEL_VGA_DEVICE, &intel_cherryview_info), INTEL_SKL_GT1_IDS(INTEL_VGA_DEVICE, &intel_skylake_gt1_info), INTEL_SKL_GT2_IDS(INTEL_VGA_DEVICE, &intel_skylake_gt2_info), INTEL_SKL_GT3_IDS(INTEL_VGA_DEVICE, &intel_skylake_gt3_info), INTEL_SKL_GT4_IDS(INTEL_VGA_DEVICE, &intel_skylake_gt4_info), INTEL_BXT_IDS(INTEL_VGA_DEVICE, &intel_broxton_info), INTEL_KBL_GT1_IDS(INTEL_VGA_DEVICE, &intel_kabylake_gt1_info), INTEL_KBL_GT2_IDS(INTEL_VGA_DEVICE, &intel_kabylake_gt2_info), INTEL_KBL_GT3_IDS(INTEL_VGA_DEVICE, &intel_kabylake_gt3_info), INTEL_KBL_GT4_IDS(INTEL_VGA_DEVICE, &intel_kabylake_gt4_info), INTEL_AML_KBL_GT2_IDS(INTEL_VGA_DEVICE, &intel_kabylake_gt2_info), INTEL_GLK_IDS(INTEL_VGA_DEVICE, &intel_geminilake_info), INTEL_CFL_S_GT1_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt1_info), INTEL_CFL_S_GT2_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt2_info), INTEL_CFL_H_GT1_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt1_info), INTEL_CFL_H_GT2_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt2_info), INTEL_CFL_U_GT2_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt2_info), INTEL_CFL_U_GT3_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt3_info), INTEL_WHL_U_GT1_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt1_info), INTEL_WHL_U_GT2_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt2_info), INTEL_WHL_U_GT3_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt3_info), INTEL_AML_CFL_GT2_IDS(INTEL_VGA_DEVICE, &intel_coffeelake_gt2_info), INTEL_CML_GT1_IDS(INTEL_VGA_DEVICE, &intel_cometlake_gt1_info), INTEL_CML_GT2_IDS(INTEL_VGA_DEVICE, &intel_cometlake_gt2_info), INTEL_CML_U_GT1_IDS(INTEL_VGA_DEVICE, &intel_cometlake_gt1_info), INTEL_CML_U_GT2_IDS(INTEL_VGA_DEVICE, &intel_cometlake_gt2_info), INTEL_CNL_IDS(INTEL_VGA_DEVICE, &intel_cannonlake_info), INTEL_ICL_IDS(INTEL_VGA_DEVICE, &intel_icelake_info), INTEL_EHL_IDS(INTEL_VGA_DEVICE, &intel_elkhartlake_info), INTEL_JSL_IDS(INTEL_VGA_DEVICE, &intel_jasperlake_info), INTEL_TGL_GT1_IDS(INTEL_VGA_DEVICE, &intel_tigerlake_gt1_info), INTEL_TGL_GT2_IDS(INTEL_VGA_DEVICE, &intel_tigerlake_gt2_info), INTEL_RKL_IDS(INTEL_VGA_DEVICE, &intel_rocketlake_info), INTEL_DG1_IDS(INTEL_VGA_DEVICE, &intel_dg1_info), INTEL_DG2_IDS(INTEL_VGA_DEVICE, &intel_dg2_info), INTEL_ADLS_IDS(INTEL_VGA_DEVICE, &intel_alderlake_s_info), INTEL_RPLS_IDS(INTEL_VGA_DEVICE, &intel_raptorlake_s_info), INTEL_ADLP_IDS(INTEL_VGA_DEVICE, &intel_alderlake_p_info), INTEL_RPLU_IDS(INTEL_VGA_DEVICE, &intel_alderlake_p_info), INTEL_RPLP_IDS(INTEL_VGA_DEVICE, &intel_alderlake_p_info), INTEL_ADLN_IDS(INTEL_VGA_DEVICE, &intel_alderlake_n_info), INTEL_ATS_M_IDS(INTEL_VGA_DEVICE, &intel_ats_m_info), INTEL_MTL_IDS(INTEL_VGA_DEVICE, &intel_meteorlake_info), INTEL_PVC_IDS(INTEL_VGA_DEVICE, &intel_pontevecchio_info), XE_LNL_IDS(INTEL_VGA_DEVICE, &intel_lunarlake_info), XE_BMG_IDS(INTEL_VGA_DEVICE, &intel_battlemage_info), INTEL_VGA_DEVICE(PCI_MATCH_ANY, &intel_generic_info), }; /** * intel_get_device_info: * @devid: pci device id * * Looks up the Intel GFX device info for the given device id. * * Returns: * The associated intel_get_device_info */ const struct intel_device_info *intel_get_device_info(uint16_t devid) { static const struct intel_device_info *cache = &intel_generic_info; static uint16_t cached_devid; int i; if (cached_devid == devid) goto out; /* XXX Presort table and bsearch! */ for (i = 0; intel_device_match[i].device_id != PCI_MATCH_ANY; i++) { if (devid == intel_device_match[i].device_id) break; } cached_devid = devid; cache = (void *)intel_device_match[i].match_data; out: return cache; }aristocratos-btop-d43a485/src/linux/intel_gpu_top/intel_gpu_top.c000066400000000000000000000351111517514752700253600ustar00rootroot00000000000000/* * Copyright ยฉ 2007-2023 Intel Corporation * * 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 (including the next * paragraph) 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "intel_gpu_top.h" #include "i915_drm.h" #include "igt_perf.h" __attribute__((format(scanf,3,4))) static int igt_sysfs_scanf(int dir, const char *attr, const char *fmt, ...) { FILE *file; int fd; int ret = -1; fd = openat(dir, attr, O_RDONLY); if (fd < 0) return -1; file = fdopen(fd, "r"); if (file) { va_list ap; va_start(ap, fmt); ret = vfscanf(file, fmt, ap); va_end(ap); fclose(file); } else { close(fd); } return ret; } static int pmu_parse(struct pmu_counter *pmu, const char *path, const char *str) { locale_t locale, oldlocale; bool result = true; char buf[128] = {}; int dir; dir = open(path, O_RDONLY); if (dir < 0) return -errno; /* Replace user environment with plain C to match kernel format */ locale = newlocale(LC_ALL, "C", 0); oldlocale = uselocale(locale); result &= igt_sysfs_scanf(dir, "type", "%"PRIu64, &pmu->type) == 1; snprintf(buf, sizeof(buf) - 1, "events/%s", str); result &= igt_sysfs_scanf(dir, buf, "event=%"PRIx64, &pmu->config) == 1; snprintf(buf, sizeof(buf) - 1, "events/%s.scale", str); result &= igt_sysfs_scanf(dir, buf, "%lf", &pmu->scale) == 1; snprintf(buf, sizeof(buf) - 1, "events/%s.unit", str); result &= igt_sysfs_scanf(dir, buf, "%127s", buf) == 1; pmu->units = strdup(buf); uselocale(oldlocale); freelocale(locale); close(dir); if (!result) return -EINVAL; if (isnan(pmu->scale) || !pmu->scale) return -ERANGE; return 0; } static int rapl_parse(struct pmu_counter *pmu, const char *str) { const char *expected_units = "Joules"; int err; err = pmu_parse(pmu, "/sys/devices/power", str); if (err < 0) return err; if (!pmu->units || strcmp(pmu->units, expected_units)) { fprintf(stderr, "Unexpected units for RAPL %s: found '%s', expected '%s'\n", str, pmu->units, expected_units); } return 0; } static void rapl_open(struct pmu_counter *pmu, const char *domain, struct engines *engines) { int fd; if (rapl_parse(pmu, domain) < 0) return; fd = igt_perf_open_group(pmu->type, pmu->config, engines->rapl_fd); if (fd < 0) return; if (engines->rapl_fd == -1) engines->rapl_fd = fd; pmu->idx = engines->num_rapl++; pmu->present = true; } static void gpu_power_open(struct pmu_counter *pmu, struct engines *engines) { rapl_open(pmu, "energy-gpu", engines); } static void pkg_power_open(struct pmu_counter *pmu, struct engines *engines) { rapl_open(pmu, "energy-pkg", engines); } static uint64_t get_pmu_config(int dirfd, const char *name, const char *counter) { char buf[128], *p; int fd, ret; ret = snprintf(buf, sizeof(buf), "%s-%s", name, counter); if (ret < 0 || ret == sizeof(buf)) return -1; fd = openat(dirfd, buf, O_RDONLY); if (fd < 0) return -1; ret = read(fd, buf, sizeof(buf)); close(fd); if (ret <= 0) return -1; p = index(buf, '0'); if (!p) return -1; return strtoul(p, NULL, 0); } #define engine_ptr(engines, n) (&engines->engine + (n)) static const char *class_display_name(unsigned int class) { switch (class) { case I915_ENGINE_CLASS_RENDER: return "Render/3D"; case I915_ENGINE_CLASS_COPY: return "Blitter"; case I915_ENGINE_CLASS_VIDEO: return "Video"; case I915_ENGINE_CLASS_VIDEO_ENHANCE: return "VideoEnhance"; case I915_ENGINE_CLASS_COMPUTE: return "Compute"; default: return "[unknown]"; } } static const char *class_short_name(unsigned int class) { switch (class) { case I915_ENGINE_CLASS_RENDER: return "RCS"; case I915_ENGINE_CLASS_COPY: return "BCS"; case I915_ENGINE_CLASS_VIDEO: return "VCS"; case I915_ENGINE_CLASS_VIDEO_ENHANCE: return "VECS"; case I915_ENGINE_CLASS_COMPUTE: return "CCS"; default: return "UNKN"; } } static int engine_cmp(const void *__a, const void *__b) { const struct engine *a = (struct engine *)__a; const struct engine *b = (struct engine *)__b; if (a->class != b->class) return a->class - b->class; else return a->instance - b->instance; } #define is_igpu(x) (strcmp(x, "i915") == 0) struct engines *discover_engines(const char *device) { char sysfs_root[PATH_MAX]; struct engines *engines; struct dirent *dent; int ret = 0; DIR *d; snprintf(sysfs_root, sizeof(sysfs_root), "/sys/devices/%s/events", device); engines = malloc(sizeof(struct engines)); if (!engines) return NULL; memset(engines, 0, sizeof(*engines)); engines->num_engines = 0; engines->device = device; engines->discrete = !is_igpu(device); d = opendir(sysfs_root); if (!d) goto err; while ((dent = readdir(d)) != NULL) { const char *endswith = "-busy"; const unsigned int endlen = strlen(endswith); struct engine *engine = engine_ptr(engines, engines->num_engines); char buf[256]; if (dent->d_type != DT_REG) continue; if (strlen(dent->d_name) >= sizeof(buf)) { ret = ENAMETOOLONG; break; } strcpy(buf, dent->d_name); /* xxxN-busy */ if (strlen(buf) < (endlen + 4)) continue; if (strcmp(&buf[strlen(buf) - endlen], endswith)) continue; memset(engine, 0, sizeof(*engine)); buf[strlen(buf) - endlen] = 0; engine->name = strdup(buf); if (!engine->name) { ret = errno; break; } engine->busy.config = get_pmu_config(dirfd(d), engine->name, "busy"); if (engine->busy.config == -1) { ret = ENOENT; break; } /* Double check config is an engine config. */ if (engine->busy.config >= __I915_PMU_OTHER(0)) { free((void *)engine->name); continue; } engine->class = (engine->busy.config & (__I915_PMU_OTHER(0) - 1)) >> I915_PMU_CLASS_SHIFT; engine->instance = (engine->busy.config >> I915_PMU_SAMPLE_BITS) & ((1 << I915_PMU_SAMPLE_INSTANCE_BITS) - 1); ret = asprintf(&engine->display_name, "%s/%u", class_display_name(engine->class), engine->instance); if (ret <= 0) { ret = errno; break; } ret = asprintf(&engine->short_name, "%s/%u", class_short_name(engine->class), engine->instance); if (ret <= 0) { ret = errno; break; } engines->num_engines++; engines = realloc(engines, sizeof(struct engines) + engines->num_engines * sizeof(struct engine)); if (!engines) { ret = errno; break; } ret = 0; } if (ret) { errno = ret; goto err; } qsort(engine_ptr(engines, 0), engines->num_engines, sizeof(struct engine), engine_cmp); engines->root = d; return engines; err: free(engines); return NULL; } void free_engines(struct engines *engines) { struct pmu_counter **pmu, *free_list[] = { &engines->r_gpu, &engines->r_pkg, &engines->imc_reads, &engines->imc_writes, NULL }; unsigned int i; if (!engines) return; for (pmu = &free_list[0]; *pmu; pmu++) { if ((*pmu)->present) free((char *)(*pmu)->units); } for (i = 0; i < engines->num_engines; i++) { struct engine *engine = engine_ptr(engines, i); free((char *)engine->name); free((char *)engine->short_name); free((char *)engine->display_name); } closedir(engines->root); free(engines->class); free(engines); } #define _open_pmu(type, cnt, pmu, fd) \ ({ \ int fd__; \ \ fd__ = igt_perf_open_group((type), (pmu)->config, (fd)); \ if (fd__ >= 0) { \ if ((fd) == -1) \ (fd) = fd__; \ (pmu)->present = true; \ (pmu)->idx = (cnt)++; \ } \ \ fd__; \ }) static int imc_parse(struct pmu_counter *pmu, const char *str) { return pmu_parse(pmu, "/sys/devices/uncore_imc", str); } static void imc_open(struct pmu_counter *pmu, const char *domain, struct engines *engines) { int fd; if (imc_parse(pmu, domain) < 0) return; fd = igt_perf_open_group(pmu->type, pmu->config, engines->imc_fd); if (fd < 0) return; if (engines->imc_fd == -1) engines->imc_fd = fd; pmu->idx = engines->num_imc++; pmu->present = true; } static void imc_writes_open(struct pmu_counter *pmu, struct engines *engines) { imc_open(pmu, "data_writes", engines); } static void imc_reads_open(struct pmu_counter *pmu, struct engines *engines) { imc_open(pmu, "data_reads", engines); } static int get_num_gts(uint64_t type) { int fd, cnt; errno = 0; for (cnt = 0; cnt < MAX_GTS; cnt++) { fd = igt_perf_open(type, __I915_PMU_INTERRUPTS(cnt)); if (fd < 0) break; close(fd); } if (!cnt || (errno && errno != ENOENT)) cnt = -errno; return cnt; } static void init_aggregate_counters(struct engines *engines) { struct pmu_counter *pmu; pmu = &engines->freq_req; pmu->type = igt_perf_type_id(engines->device); pmu->config = I915_PMU_REQUESTED_FREQUENCY; pmu->present = true; pmu = &engines->freq_act; pmu->type = igt_perf_type_id(engines->device); pmu->config = I915_PMU_ACTUAL_FREQUENCY; pmu->present = true; pmu = &engines->rc6; pmu->type = igt_perf_type_id(engines->device); pmu->config = I915_PMU_RC6_RESIDENCY; pmu->present = true; } int pmu_init(struct engines *engines) { unsigned int i; int fd; uint64_t type = igt_perf_type_id(engines->device); engines->fd = -1; engines->num_counters = 0; engines->num_gts = get_num_gts(type); if (engines->num_gts <= 0) return -1; engines->irq.config = I915_PMU_INTERRUPTS; fd = _open_pmu(type, engines->num_counters, &engines->irq, engines->fd); if (fd < 0) return -1; init_aggregate_counters(engines); for (i = 0; i < engines->num_gts; i++) { engines->freq_req_gt[i].config = __I915_PMU_REQUESTED_FREQUENCY(i); _open_pmu(type, engines->num_counters, &engines->freq_req_gt[i], engines->fd); engines->freq_act_gt[i].config = __I915_PMU_ACTUAL_FREQUENCY(i); _open_pmu(type, engines->num_counters, &engines->freq_act_gt[i], engines->fd); engines->rc6_gt[i].config = __I915_PMU_RC6_RESIDENCY(i); _open_pmu(type, engines->num_counters, &engines->rc6_gt[i], engines->fd); } for (i = 0; i < engines->num_engines; i++) { struct engine *engine = engine_ptr(engines, i); struct { struct pmu_counter *pmu; const char *counter; } *cnt, counters[] = { { .pmu = &engine->busy, .counter = "busy" }, { .pmu = &engine->wait, .counter = "wait" }, { .pmu = &engine->sema, .counter = "sema" }, { .pmu = NULL, .counter = NULL }, }; for (cnt = counters; cnt->pmu; cnt++) { if (!cnt->pmu->config) cnt->pmu->config = get_pmu_config(dirfd(engines->root), engine->name, cnt->counter); fd = _open_pmu(type, engines->num_counters, cnt->pmu, engines->fd); if (fd >= 0) engine->num_counters++; } } engines->rapl_fd = -1; if (!engines->discrete) { gpu_power_open(&engines->r_gpu, engines); pkg_power_open(&engines->r_pkg, engines); } engines->imc_fd = -1; imc_reads_open(&engines->imc_reads, engines); imc_writes_open(&engines->imc_writes, engines); return 0; } static uint64_t pmu_read_multi(int fd, unsigned int num, uint64_t *val) { uint64_t buf[2 + num]; unsigned int i; ssize_t len; memset(buf, 0, sizeof(buf)); len = read(fd, buf, sizeof(buf)); assert(len == sizeof(buf)); for (i = 0; i < num; i++) val[i] = buf[2 + i]; return buf[1]; } double pmu_calc(struct pmu_pair *p, double d, double t, double s) { double v; v = p->cur - p->prev; v /= d; v /= t; v *= s; if (s == 100.0 && v > 100.0) v = 100.0; return v; } static void __update_sample(struct pmu_counter *counter, uint64_t val) { counter->val.prev = counter->val.cur; counter->val.cur = val; } static void update_sample(struct pmu_counter *counter, uint64_t *val) { if (counter->present) __update_sample(counter, val[counter->idx]); } void pmu_sample(struct engines *engines) { const int num_val = engines->num_counters; uint64_t val[2 + num_val]; unsigned int i; engines->ts.prev = engines->ts.cur; engines->ts.cur = pmu_read_multi(engines->fd, num_val, val); engines->freq_req.val.cur = engines->freq_req.val.prev = 0; engines->freq_act.val.cur = engines->freq_act.val.prev = 0; engines->rc6.val.cur = engines->rc6.val.prev = 0; for (i = 0; i < engines->num_gts; i++) { update_sample(&engines->freq_req_gt[i], val); engines->freq_req.val.cur += engines->freq_req_gt[i].val.cur; engines->freq_req.val.prev += engines->freq_req_gt[i].val.prev; update_sample(&engines->freq_act_gt[i], val); engines->freq_act.val.cur += engines->freq_act_gt[i].val.cur; engines->freq_act.val.prev += engines->freq_act_gt[i].val.prev; update_sample(&engines->rc6_gt[i], val); engines->rc6.val.cur += engines->rc6_gt[i].val.cur; engines->rc6.val.prev += engines->rc6_gt[i].val.prev; } engines->freq_req.val.cur /= engines->num_gts; engines->freq_req.val.prev /= engines->num_gts; engines->freq_act.val.cur /= engines->num_gts; engines->freq_act.val.prev /= engines->num_gts; engines->rc6.val.cur /= engines->num_gts; engines->rc6.val.prev /= engines->num_gts; update_sample(&engines->irq, val); for (i = 0; i < engines->num_engines; i++) { struct engine *engine = engine_ptr(engines, i); update_sample(&engine->busy, val); update_sample(&engine->sema, val); update_sample(&engine->wait, val); } if (engines->num_rapl) { pmu_read_multi(engines->rapl_fd, engines->num_rapl, val); update_sample(&engines->r_gpu, val); update_sample(&engines->r_pkg, val); } if (engines->num_imc) { pmu_read_multi(engines->imc_fd, engines->num_imc, val); update_sample(&engines->imc_reads, val); update_sample(&engines->imc_writes, val); } } aristocratos-btop-d43a485/src/linux/intel_gpu_top/intel_gpu_top.h000066400000000000000000000034761517514752700253760ustar00rootroot00000000000000#ifndef INTEL_GPU_TOP_H #define INTEL_GPU_TOP_H #include #include #include struct pmu_pair { uint64_t cur; uint64_t prev; }; struct pmu_counter { uint64_t type; uint64_t config; unsigned int idx; struct pmu_pair val; double scale; const char *units; bool present; }; struct engine_class { unsigned int engine_class; const char *name; unsigned int num_engines; }; struct engine { const char *name; char *display_name; char *short_name; unsigned int class; unsigned int instance; unsigned int num_counters; struct pmu_counter busy; struct pmu_counter wait; struct pmu_counter sema; }; #define MAX_GTS 4 struct engines { unsigned int num_engines; unsigned int num_classes; struct engine_class *class; unsigned int num_counters; DIR *root; int fd; struct pmu_pair ts; int rapl_fd; struct pmu_counter r_gpu, r_pkg; unsigned int num_rapl; int imc_fd; struct pmu_counter imc_reads; struct pmu_counter imc_writes; unsigned int num_imc; struct pmu_counter freq_req; struct pmu_counter freq_req_gt[MAX_GTS]; struct pmu_counter freq_act; struct pmu_counter freq_act_gt[MAX_GTS]; struct pmu_counter irq; struct pmu_counter rc6; struct pmu_counter rc6_gt[MAX_GTS]; bool discrete; char *device; int num_gts; /* Do not edit below this line. * This structure is reallocated every time a new engine is * found and size is increased by sizeof (engine). */ struct engine engine; }; struct engines *discover_engines(const char *device); void free_engines(struct engines *engines); int pmu_init(struct engines *engines); void pmu_sample(struct engines *engines); double pmu_calc(struct pmu_pair *p, double d, double t, double s); char* find_intel_gpu_dir(); char* get_intel_device_id(const char* vendor_path); char *get_intel_device_name(const char *device_id); #endifaristocratos-btop-d43a485/src/linux/intel_gpu_top/intel_name_lookup_shim.c000066400000000000000000000054571517514752700272460ustar00rootroot00000000000000#include #include #include #include #include #include #include "intel_gpu_top.h" #include "intel_chipset.h" #define VENDOR_ID "0x8086" #define SYSFS_PATH "/sys/class/drm" #define VENDOR_FILE "vendor" #define DEVICE_FILE "device" char* find_intel_gpu_dir() { DIR *dir; struct dirent *entry; static char path[256]; char vendor_path[256]; char vendor_id[16]; if ((dir = opendir(SYSFS_PATH)) == NULL) { perror("opendir"); return NULL; } while ((entry = readdir(dir)) != NULL) { // Construct the path to the vendor file snprintf(vendor_path, sizeof(vendor_path), "%s/%s/device/%s", SYSFS_PATH, entry->d_name, VENDOR_FILE); // Check if the vendor file exists if (access(vendor_path, F_OK) != -1) { FILE *file = fopen(vendor_path, "r"); if (file) { if (fgets(vendor_id, sizeof(vendor_id), file)) { // Trim the newline character vendor_id[strcspn(vendor_id, "\n")] = 0; if (strcmp(vendor_id, VENDOR_ID) == 0) { // Return the parent directory (i.e., /sys/class/drm/card*) snprintf(path, sizeof(path), "%s/%s", SYSFS_PATH, entry->d_name); fclose(file); closedir(dir); return path; } } fclose(file); } } } closedir(dir); return NULL; // Intel GPU not found } char* get_intel_device_id(const char* gpu_dir) { static char device_path[256]; char device_id[16]; // Construct the path to the device file snprintf(device_path, sizeof(device_path), "%s/device/%s", gpu_dir, DEVICE_FILE); FILE *file = fopen(device_path, "r"); if (file) { if (fgets(device_id, sizeof(device_id), file)) { fclose(file); // Trim the newline character device_id[strcspn(device_id, "\n")] = 0; // Return a copy of the device ID return strdup(device_id); } fclose(file); } else { perror("fopen"); } return NULL; } char *get_intel_device_name(const char *device_id) { uint16_t devid = strtol(device_id, NULL, 16); char dev_name[256]; char full_name[256]; const struct intel_device_info *info = intel_get_device_info(devid); if (info) { if (info->codename == NULL) { strcpy(dev_name, "(unknown)"); } else { strcpy(dev_name, info->codename); dev_name[0] = toupper(dev_name[0]); } snprintf(full_name, sizeof(full_name), "Intel %s (Gen%u)", dev_name, info->graphics_ver); return strdup(full_name); } return NULL; } aristocratos-btop-d43a485/src/linux/intel_gpu_top/source.txt000066400000000000000000000001351517514752700244030ustar00rootroot000000000000000f02dc176959e6296866b1bafd3982e277a5e44b https://gitlab.freedesktop.org/drm/igt-gpu-tools.gitaristocratos-btop-d43a485/src/linux/intel_gpu_top/xe_pciids.h000066400000000000000000000144251517514752700244710ustar00rootroot00000000000000/* SPDX-License-Identifier: MIT */ /* * Copyright ยฉ 2022 Intel Corporation */ #ifndef _XE_PCIIDS_H_ #define _XE_PCIIDS_H_ /* * Lists below can be turned into initializers for a struct pci_device_id * by defining INTEL_VGA_DEVICE: * * #define INTEL_VGA_DEVICE(id, info) { \ * 0x8086, id, \ * ~0, ~0, \ * 0x030000, 0xff0000, \ * (unsigned long) info } * * And then calling like: * * XE_TGL_12_GT1_IDS(INTEL_VGA_DEVICE, ## __VA_ARGS__) * * To turn them into something else, just provide a different macro passed as * first argument. */ /* TGL */ #define XE_TGL_GT1_IDS(MACRO__, ...) \ MACRO__(0x9A60, ## __VA_ARGS__), \ MACRO__(0x9A68, ## __VA_ARGS__), \ MACRO__(0x9A70, ## __VA_ARGS__) #define XE_TGL_GT2_IDS(MACRO__, ...) \ MACRO__(0x9A40, ## __VA_ARGS__), \ MACRO__(0x9A49, ## __VA_ARGS__), \ MACRO__(0x9A59, ## __VA_ARGS__), \ MACRO__(0x9A78, ## __VA_ARGS__), \ MACRO__(0x9AC0, ## __VA_ARGS__), \ MACRO__(0x9AC9, ## __VA_ARGS__), \ MACRO__(0x9AD9, ## __VA_ARGS__), \ MACRO__(0x9AF8, ## __VA_ARGS__) #define XE_TGL_IDS(MACRO__, ...) \ XE_TGL_GT1_IDS(MACRO__, ## __VA_ARGS__),\ XE_TGL_GT2_IDS(MACRO__, ## __VA_ARGS__) /* RKL */ #define XE_RKL_IDS(MACRO__, ...) \ MACRO__(0x4C80, ## __VA_ARGS__), \ MACRO__(0x4C8A, ## __VA_ARGS__), \ MACRO__(0x4C8B, ## __VA_ARGS__), \ MACRO__(0x4C8C, ## __VA_ARGS__), \ MACRO__(0x4C90, ## __VA_ARGS__), \ MACRO__(0x4C9A, ## __VA_ARGS__) /* DG1 */ #define XE_DG1_IDS(MACRO__, ...) \ MACRO__(0x4905, ## __VA_ARGS__), \ MACRO__(0x4906, ## __VA_ARGS__), \ MACRO__(0x4907, ## __VA_ARGS__), \ MACRO__(0x4908, ## __VA_ARGS__), \ MACRO__(0x4909, ## __VA_ARGS__) /* ADL-S */ #define XE_ADLS_IDS(MACRO__, ...) \ MACRO__(0x4680, ## __VA_ARGS__), \ MACRO__(0x4682, ## __VA_ARGS__), \ MACRO__(0x4688, ## __VA_ARGS__), \ MACRO__(0x468A, ## __VA_ARGS__), \ MACRO__(0x468B, ## __VA_ARGS__), \ MACRO__(0x4690, ## __VA_ARGS__), \ MACRO__(0x4692, ## __VA_ARGS__), \ MACRO__(0x4693, ## __VA_ARGS__) /* ADL-P */ #define XE_ADLP_IDS(MACRO__, ...) \ MACRO__(0x46A0, ## __VA_ARGS__), \ MACRO__(0x46A1, ## __VA_ARGS__), \ MACRO__(0x46A2, ## __VA_ARGS__), \ MACRO__(0x46A3, ## __VA_ARGS__), \ MACRO__(0x46A6, ## __VA_ARGS__), \ MACRO__(0x46A8, ## __VA_ARGS__), \ MACRO__(0x46AA, ## __VA_ARGS__), \ MACRO__(0x462A, ## __VA_ARGS__), \ MACRO__(0x4626, ## __VA_ARGS__), \ MACRO__(0x4628, ## __VA_ARGS__), \ MACRO__(0x46B0, ## __VA_ARGS__), \ MACRO__(0x46B1, ## __VA_ARGS__), \ MACRO__(0x46B2, ## __VA_ARGS__), \ MACRO__(0x46B3, ## __VA_ARGS__), \ MACRO__(0x46C0, ## __VA_ARGS__), \ MACRO__(0x46C1, ## __VA_ARGS__), \ MACRO__(0x46C2, ## __VA_ARGS__), \ MACRO__(0x46C3, ## __VA_ARGS__) /* ADL-N */ #define XE_ADLN_IDS(MACRO__, ...) \ MACRO__(0x46D0, ## __VA_ARGS__), \ MACRO__(0x46D1, ## __VA_ARGS__), \ MACRO__(0x46D2, ## __VA_ARGS__) /* RPL-S */ #define XE_RPLS_IDS(MACRO__, ...) \ MACRO__(0xA780, ## __VA_ARGS__), \ MACRO__(0xA781, ## __VA_ARGS__), \ MACRO__(0xA782, ## __VA_ARGS__), \ MACRO__(0xA783, ## __VA_ARGS__), \ MACRO__(0xA788, ## __VA_ARGS__), \ MACRO__(0xA789, ## __VA_ARGS__), \ MACRO__(0xA78A, ## __VA_ARGS__), \ MACRO__(0xA78B, ## __VA_ARGS__) /* RPL-U */ #define XE_RPLU_IDS(MACRO__, ...) \ MACRO__(0xA721, ## __VA_ARGS__), \ MACRO__(0xA7A1, ## __VA_ARGS__), \ MACRO__(0xA7A9, ## __VA_ARGS__), \ MACRO__(0xA7AC, ## __VA_ARGS__), \ MACRO__(0xA7AD, ## __VA_ARGS__) /* RPL-P */ #define XE_RPLP_IDS(MACRO__, ...) \ XE_RPLU_IDS(MACRO__, ## __VA_ARGS__), \ MACRO__(0xA720, ## __VA_ARGS__), \ MACRO__(0xA7A0, ## __VA_ARGS__), \ MACRO__(0xA7A8, ## __VA_ARGS__), \ MACRO__(0xA7AA, ## __VA_ARGS__), \ MACRO__(0xA7AB, ## __VA_ARGS__) /* DG2 */ #define XE_DG2_G10_IDS(MACRO__, ...) \ MACRO__(0x5690, ## __VA_ARGS__), \ MACRO__(0x5691, ## __VA_ARGS__), \ MACRO__(0x5692, ## __VA_ARGS__), \ MACRO__(0x56A0, ## __VA_ARGS__), \ MACRO__(0x56A1, ## __VA_ARGS__), \ MACRO__(0x56A2, ## __VA_ARGS__), \ MACRO__(0x56BE, ## __VA_ARGS__), \ MACRO__(0x56BF, ## __VA_ARGS__) #define XE_DG2_G11_IDS(MACRO__, ...) \ MACRO__(0x5693, ## __VA_ARGS__), \ MACRO__(0x5694, ## __VA_ARGS__), \ MACRO__(0x5695, ## __VA_ARGS__), \ MACRO__(0x56A5, ## __VA_ARGS__), \ MACRO__(0x56A6, ## __VA_ARGS__), \ MACRO__(0x56B0, ## __VA_ARGS__), \ MACRO__(0x56B1, ## __VA_ARGS__), \ MACRO__(0x56BA, ## __VA_ARGS__), \ MACRO__(0x56BB, ## __VA_ARGS__), \ MACRO__(0x56BC, ## __VA_ARGS__), \ MACRO__(0x56BD, ## __VA_ARGS__) #define XE_DG2_G12_IDS(MACRO__, ...) \ MACRO__(0x5696, ## __VA_ARGS__), \ MACRO__(0x5697, ## __VA_ARGS__), \ MACRO__(0x56A3, ## __VA_ARGS__), \ MACRO__(0x56A4, ## __VA_ARGS__), \ MACRO__(0x56B2, ## __VA_ARGS__), \ MACRO__(0x56B3, ## __VA_ARGS__) #define XE_DG2_IDS(MACRO__, ...) \ XE_DG2_G10_IDS(MACRO__, ## __VA_ARGS__),\ XE_DG2_G11_IDS(MACRO__, ## __VA_ARGS__),\ XE_DG2_G12_IDS(MACRO__, ## __VA_ARGS__) #define XE_ATS_M150_IDS(MACRO__, ...) \ MACRO__(0x56C0, ## __VA_ARGS__), \ MACRO__(0x56C2, ## __VA_ARGS__) #define XE_ATS_M75_IDS(MACRO__, ...) \ MACRO__(0x56C1, ## __VA_ARGS__) #define XE_ATS_M_IDS(MACRO__, ...) \ XE_ATS_M150_IDS(MACRO__, ## __VA_ARGS__),\ XE_ATS_M75_IDS(MACRO__, ## __VA_ARGS__) /* MTL / ARL */ #define XE_MTL_IDS(MACRO__, ...) \ MACRO__(0x7D40, ## __VA_ARGS__), \ MACRO__(0x7D41, ## __VA_ARGS__), \ MACRO__(0x7D45, ## __VA_ARGS__), \ MACRO__(0x7D51, ## __VA_ARGS__), \ MACRO__(0x7D55, ## __VA_ARGS__), \ MACRO__(0x7D60, ## __VA_ARGS__), \ MACRO__(0x7D67, ## __VA_ARGS__), \ MACRO__(0x7DD1, ## __VA_ARGS__), \ MACRO__(0x7DD5, ## __VA_ARGS__) /* PVC */ #define XE_PVC_IDS(MACRO__, ...) \ MACRO__(0x0B69, ## __VA_ARGS__), \ MACRO__(0x0B6E, ## __VA_ARGS__), \ MACRO__(0x0BD4, ## __VA_ARGS__), \ MACRO__(0x0BD5, ## __VA_ARGS__), \ MACRO__(0x0BD6, ## __VA_ARGS__), \ MACRO__(0x0BD7, ## __VA_ARGS__), \ MACRO__(0x0BD8, ## __VA_ARGS__), \ MACRO__(0x0BD9, ## __VA_ARGS__), \ MACRO__(0x0BDA, ## __VA_ARGS__), \ MACRO__(0x0BDB, ## __VA_ARGS__), \ MACRO__(0x0BE0, ## __VA_ARGS__), \ MACRO__(0x0BE1, ## __VA_ARGS__), \ MACRO__(0x0BE5, ## __VA_ARGS__) #define XE_LNL_IDS(MACRO__, ...) \ MACRO__(0x6420, ## __VA_ARGS__), \ MACRO__(0x64A0, ## __VA_ARGS__), \ MACRO__(0x64B0, ## __VA_ARGS__) #define XE_BMG_IDS(MACRO__, ...) \ MACRO__(0xE202, ## __VA_ARGS__), \ MACRO__(0xE20B, ## __VA_ARGS__), \ MACRO__(0xE20C, ## __VA_ARGS__), \ MACRO__(0xE20D, ## __VA_ARGS__), \ MACRO__(0xE212, ## __VA_ARGS__) #endif aristocratos-btop-d43a485/src/main.cpp000066400000000000000000000004661517514752700177720ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #include "btop.hpp" #include #include #include #include auto main(int argc, const char* argv[]) -> int { return btop_main(std::views::counted(std::next(argv), argc - 1) | std::ranges::to>()); } aristocratos-btop-d43a485/src/netbsd/000077500000000000000000000000001517514752700176135ustar00rootroot00000000000000aristocratos-btop-d43a485/src/netbsd/btop_collect.cpp000066400000000000000000001327741517514752700230060ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Copyright 2024 Santhosh Raju (fox@NetBSD.org) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include // man 3 getifaddrs: "BUGS: If both and are being included, must be included before " #include #include #include #include #include #include #include // for inet_ntop stuff #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../btop_config.hpp" #include "../btop_log.hpp" #include "../btop_shared.hpp" #include "../btop_tools.hpp" using std::clamp, std::string_literals::operator""s, std::cmp_equal, std::cmp_less, std::cmp_greater; using std::ifstream, std::numeric_limits, std::streamsize, std::round, std::max, std::min; namespace fs = std::filesystem; namespace rng = std::ranges; using namespace Tools; //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace Cpu { vector core_old_totals; vector core_old_idles; vector available_fields = {"total"}; vector available_sensors = {"Auto"}; cpu_info current_cpu; bool got_sensors = false, cpu_temp_only = false, supports_watts = false; //* Populate found_sensors map bool get_sensors(); //* Get current cpu clock speed string get_cpuHz(); //* Search /proc/cpuinfo for a cpu name string get_cpuName(); struct Sensor { fs::path path; string label; int64_t temp = 0; int64_t high = 0; int64_t crit = 0; }; string cpu_sensor; vector core_sensors; std::unordered_map core_mapping; } // namespace Cpu namespace Mem { double old_uptime; } namespace Shared { fs::path passwd_path; uint64_t totalMem; long pageSize, clkTck, coreCount, physicalCoreCount, arg_max; int totalMem_len, kfscale; long bootTime; size_t size; void init() { //? Shared global variables init int mib[2]; mib[0] = CTL_HW; mib[1] = HW_NCPU; int ncpu; size_t len = sizeof(ncpu); if (sysctl(mib, 2, &ncpu, &len, nullptr, 0) == -1) { Logger::warning("Could not determine number of cores, defaulting to 1."); } else { coreCount = ncpu; } size = sizeof(pageSize); if (sysctlbyname("hw.pagesize", &pageSize, &size, nullptr, 0) < 0) { pageSize = 4096; Logger::warning("Could not get system page size. Defaulting to 4096, processes memory usage might be incorrect."); } clkTck = sysconf(_SC_CLK_TCK); if (clkTck <= 0) { clkTck = 100; Logger::warning("Could not get system clock ticks per second. Defaulting to 100, processes cpu usage might be incorrect."); } size = sizeof(totalMem); if (sysctlbyname("hw.physmem64", &totalMem, &size, nullptr, 0) < 0) { Logger::warning("Could not get memory size"); } struct timeval result; size = sizeof(result); if (sysctlbyname("kern.boottime", &result, &size, nullptr, 0) < 0) { Logger::warning("Could not get boot time"); } else { bootTime = result.tv_sec; } size = sizeof(kfscale); if (sysctlbyname("kern.fscale", &kfscale, &size, nullptr, 0) == -1) { kfscale = 2048; } //* Get maximum length of process arguments arg_max = sysconf(_SC_ARG_MAX); //? Init for namespace Cpu Cpu::current_cpu.core_percent.insert(Cpu::current_cpu.core_percent.begin(), Shared::coreCount, {}); Cpu::current_cpu.temp.insert(Cpu::current_cpu.temp.begin(), Shared::coreCount + 1, {}); Cpu::core_old_totals.insert(Cpu::core_old_totals.begin(), Shared::coreCount, 0); Cpu::core_old_idles.insert(Cpu::core_old_idles.begin(), Shared::coreCount, 0); Cpu::collect(); for (auto &[field, vec] : Cpu::current_cpu.cpu_percent) { if (not vec.empty() and not v_contains(Cpu::available_fields, field)) Cpu::available_fields.push_back(field); } Cpu::cpuName = Cpu::get_cpuName(); Cpu::got_sensors = Cpu::get_sensors(); Cpu::core_mapping = Cpu::get_core_mapping(); //? Init for namespace Mem Mem::old_uptime = system_uptime(); Mem::collect(); } } // namespace Shared namespace Cpu { string cpuName; string cpuHz; bool has_battery = true; tuple current_bat; const array time_names = {"user", "nice", "system", "idle"}; std::unordered_map cpu_old = { {"totals", 0}, {"idles", 0}, {"user", 0}, {"nice", 0}, {"system", 0}, {"idle", 0} }; string get_cpuName() { string name; char buffer[1024]; size_t size = sizeof(buffer); if (sysctlbyname("hw.model", &buffer, &size, nullptr, 0) < 0) { Logger::error("Failed to get CPU name"); return name; } return trim_name(string(buffer)); } bool get_sensors() { got_sensors = false; prop_dictionary_t dict; prop_object_t fields_array; // List of common thermal sensors in NetBSD. const string sensors[6] = { "coretemp0", "acpitz0", "thinkpad0", "amdzentemp0", "coretemp1", "acpitz1" }; int fd = open(_PATH_SYSMON, O_RDONLY); if (fd == -1) { Logger::warning("failed to open {}", _PATH_SYSMON); return got_sensors; } if (prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &dict) != 0) { if (fd != -1) { close(fd); } Logger::warning("failed to open envsys dict"); return got_sensors; } close(fd); if (prop_dictionary_count(dict) == 0) { Logger::warning("no drivers registered for envsys"); return got_sensors; } // Search through a known list of sensors and break the loop on finding the first. for(const string &sensor : sensors) { fields_array = prop_dictionary_get(prop_dictionary_t(dict), sensor.c_str()); if (prop_object_type(fields_array) != PROP_TYPE_ARRAY) { Logger::warning("unknown device {}", sensor); } else { Cpu::cpu_sensor = sensor; break; } } if (prop_object_type(fields_array) != PROP_TYPE_ARRAY) { return got_sensors; } if (Config::getB("show_coretemp") and Config::getB("check_temp")) { got_sensors = true; } return got_sensors; } #define MUKTOC(v) ((v - 273150000) / 1000000.0) void update_sensors() { int64_t current_temp = -1; current_cpu.temp_max = 95; prop_dictionary_t dict, fields, props; int fd = open(_PATH_SYSMON, O_RDONLY); if (fd == -1) { Logger::warning("failed to open {}", _PATH_SYSMON); return; } if (prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &dict) != 0) { if (fd != -1) { close(fd); } Logger::warning("failed to open envsys dict"); return; } close(fd); if (prop_dictionary_count(dict) == 0) { Logger::warning("no drivers registered for envsys"); return; } prop_object_t fields_array = prop_dictionary_get(prop_dictionary_t(dict), Cpu::cpu_sensor.c_str()); if (prop_object_type(fields_array) != PROP_TYPE_ARRAY) { Logger::warning("unknown device {}", Cpu::cpu_sensor); return; } prop_object_iterator_t fields_iter = prop_array_iterator(prop_array_t(fields_array)); if (fields_iter == NULL) { return; } regex_t r; if (regcomp(&r, "(cpu[0-9]* )*temperature", REG_EXTENDED)) { Logger::warning("regcomp() failed"); return; } string prop_description = "no description"; char buf[64]; while ((fields = (prop_dictionary_t) prop_object_iterator_next(prop_object_iterator_t(fields_iter))) != NULL) { props = (prop_dictionary_t) prop_dictionary_get(fields, "device-properties"); if (props != NULL) continue; prop_object_t cur_value = prop_dictionary_get(fields, "cur-value"); prop_object_t max_value = prop_dictionary_get(fields, "critical-max"); prop_object_t description = prop_dictionary_get(fields, "description"); if (description == NULL || cur_value == NULL) { continue; } prop_string_copy_value(prop_string_t(description), buf, sizeof buf); prop_description = buf; if (regexec(&r, prop_description.c_str(), 0, NULL, 0) == 0) { current_temp = prop_number_signed_value(prop_number_t(cur_value)); if (max_value != NULL) { current_cpu.temp_max = MUKTOC(prop_number_signed_value(prop_number_t(max_value))); } } } regfree(&r); prop_object_iterator_release(fields_iter); prop_object_release(dict); if (current_temp > -1) { current_temp = MUKTOC(current_temp); for (int i = 0; i < Shared::coreCount; i++) { if (cmp_less(i + 1, current_cpu.temp.size())) { current_cpu.temp.at(i + 1).push_back(current_temp); if (current_cpu.temp.at(i + 1).size() > 20) { current_cpu.temp.at(i + 1).pop_front(); } } } current_cpu.temp.at(0).push_back(current_temp); if (current_cpu.temp.at(0).size() > 20) { current_cpu.temp.at(0).pop_front(); } } } string get_cpuHz() { unsigned int freq = 1; size_t size = sizeof(freq); if (sysctlbyname("hw.cpuspeed", &freq, &size, nullptr, 0) < 0) { return ""; } return std::to_string(freq / 1000.0 ).substr(0, 3); // seems to be in MHz } auto get_core_mapping() -> std::unordered_map { std::unordered_map core_map; if (cpu_temp_only) return core_map; for (long i = 0; i < Shared::coreCount; i++) { core_map[i] = i; } //? If core mapping from cpuinfo was incomplete try to guess remainder, if missing completely, map 0-0 1-1 2-2 etc. if (cmp_less(core_map.size(), Shared::coreCount)) { if (Shared::coreCount % 2 == 0 and (long) core_map.size() == Shared::coreCount / 2) { for (int i = 0, n = 0; i < Shared::coreCount / 2; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[Shared::coreCount / 2 + i] = n++; } } else { core_map.clear(); for (int i = 0, n = 0; i < Shared::coreCount; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[i] = n++; } } } //? Apply user set custom mapping if any const auto &custom_map = Config::getS("cpu_core_map"); if (not custom_map.empty()) { try { for (const auto &split : ssplit(custom_map)) { const auto vals = ssplit(split, ':'); if (vals.size() != 2) continue; int change_id = std::stoi(vals.at(0)); int new_id = std::stoi(vals.at(1)); if (not core_map.contains(change_id) or cmp_greater(new_id, core_sensors.size())) continue; core_map.at(change_id) = new_id; } } catch (...) { } } return core_map; } auto get_battery() -> tuple { if (not has_battery) return {0, 0.0, 0, ""}; prop_dictionary_t dict, fields, props; int64_t total_charge = 0; int64_t total_capacity = 0; int fd = open(_PATH_SYSMON, O_RDONLY); if (fd == -1) { Logger::warning("failed to open {}", _PATH_SYSMON); has_battery = false; return {0, 0.0, 0, ""}; } if (prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &dict) != 0) { if (fd != -1) { close(fd); } has_battery = false; Logger::warning("failed to open envsys dict"); return {0, 0.0, 0, ""}; } close(fd); if (prop_dictionary_count(dict) == 0) { has_battery = false; Logger::warning("no drivers registered for envsys"); return {0, 0.0, 0, ""}; } prop_object_t fields_array = prop_dictionary_get(prop_dictionary_t(dict), "acpibat0"); if (prop_object_type(fields_array) != PROP_TYPE_ARRAY) { has_battery = false; Logger::warning("unknown device 'acpibat0'"); return {0, 0.0, 0, ""}; } prop_object_iterator_t fields_iter = prop_array_iterator(prop_array_t(fields_array)); if (fields_iter == NULL) { has_battery = false; return {0, 0.0, 0, ""}; } /* only assume battery is not present if explicitly stated */ bool is_battery = false; int64_t is_present = 1; int64_t cur_charge = 0; int64_t max_charge = 0; string status = "unknown"; string prop_description = "no description"; char buf[64]; while ((fields = (prop_dictionary_t) prop_object_iterator_next(prop_object_iterator_t(fields_iter))) != NULL) { props = (prop_dictionary_t) prop_dictionary_get(fields, "device-properties"); if (props != NULL) continue; prop_object_t cur_value = prop_dictionary_get(fields, "cur-value"); prop_object_t max_value = prop_dictionary_get(fields, "max-value"); prop_object_t description = prop_dictionary_get(fields, "description"); if (description == NULL || cur_value == NULL) { continue; } prop_string_copy_value(prop_string_t(description), buf, sizeof buf); prop_description = buf; if (prop_description == "charge") { if (max_value == NULL) { continue; } cur_charge = prop_number_signed_value(prop_number_t(cur_value)); max_charge = prop_number_signed_value(prop_number_t(max_value)); } if (prop_description == "present") { is_present = prop_number_signed_value(prop_number_t(cur_value)); } if (prop_description == "charging") { status = prop_description; char buf[64]; prop_string_copy_value(prop_string_t(prop_dictionary_get(fields, "type")), buf, sizeof buf); string charging_type = buf; is_battery = charging_type == "Battery charge" ? true : false; } if (is_battery && is_present) { total_charge += cur_charge; total_capacity += max_charge; } } prop_object_iterator_release(fields_iter); prop_object_release(dict); uint32_t percent = ((double)total_charge / (double)total_capacity) * 100.0; if (percent == 100) { status = "full"; } return {percent, -1, -1, status}; } auto collect(bool no_update) -> cpu_info & { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto &cpu = current_cpu; if (getloadavg(cpu.load_avg.data(), cpu.load_avg.size()) < 0) { Logger::error("failed to get load averages"); } vector> cpu_time(Shared::coreCount); size_t size = sizeof(long) * CPUSTATES * Shared::coreCount; if (sysctlbyname("kern.cp_time", &cpu_time[0], &size, nullptr, 0) == -1) { Logger::error("failed to get CPU time"); } long long global_totals = 0; long long global_idles = 0; vector times_summed = {0, 0, 0, 0}; for (long i = 0; i < Shared::coreCount; i++) { vector times; //? 0=user, 1=nice, 2=system, 3=idle for (int x = 0; const unsigned int c_state : {CP_USER, CP_NICE, CP_SYS, CP_IDLE}) { auto val = cpu_time[i][c_state]; times.push_back(val); times_summed.at(x++) += val; } try { //? All values const long long totals = std::accumulate(times.begin(), times.end(), 0ll); //? Idle time const long long idles = times.at(3); global_totals += totals; global_idles += idles; //? Calculate cpu total for each core if (i > Shared::coreCount) break; const long long calc_totals = max(0ll, totals - core_old_totals.at(i)); const long long calc_idles = max(0ll, idles - core_old_idles.at(i)); core_old_totals.at(i) = totals; core_old_idles.at(i) = idles; cpu.core_percent.at(i).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph if (cpu.core_percent.at(i).size() > 40) cpu.core_percent.at(i).pop_front(); } catch (const std::exception& e) { Logger::error("Cpu::collect() : {}", e.what()); throw std::runtime_error(fmt::format("collect() : {}", e.what())); } } const long long calc_totals = max(1ll, global_totals - cpu_old.at("totals")); const long long calc_idles = max(1ll, global_idles - cpu_old.at("idles")); //? Populate cpu.cpu_percent with all fields from syscall for (int ii = 0; const auto &val : times_summed) { cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); cpu_old.at(time_names.at(ii)) = val; //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); ii++; } cpu_old.at("totals") = global_totals; cpu_old.at("idles") = global_idles; //? Total usage of cpu cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); if (Config::getB("show_cpu_freq")) { auto hz = get_cpuHz(); if (hz != "") { cpuHz = hz; } } if (Config::getB("check_temp") and got_sensors) update_sensors(); if (Config::getB("show_battery") and has_battery) current_bat = get_battery(); return current_cpu; } } // namespace Cpu namespace Mem { bool has_swap = false; vector fstab; fs::file_time_type fstab_time; int disk_ios = 0; vector last_found; mem_info current_mem{}; uint64_t get_totalMem() { return Shared::totalMem; } void assign_values(struct disk_info& disk, int64_t readBytes, int64_t writeBytes) { disk_ios++; if (disk.io_read.empty()) { disk.io_read.push_back(0); } else { disk.io_read.push_back(max((int64_t)0, (readBytes - disk.old_io.at(0)))); } disk.old_io.at(0) = readBytes; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); if (disk.io_write.empty()) { disk.io_write.push_back(0); } else { disk.io_write.push_back(max((int64_t)0, (writeBytes - disk.old_io.at(1)))); } disk.old_io.at(1) = writeBytes; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); // no io times - need to push something anyway or we'll get an ABORT if (disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(clamp((long)round((double)(disk.io_write.back() + disk.io_read.back()) / (1 << 20)), 0l, 100l)); while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } void collect_disk(std::unordered_map &disks, std::unordered_map &mapping) { uint64_t total_bytes_read = 0; uint64_t total_bytes_write = 0; int num_drives = 0; int mib[3] = { CTL_HW, HW_IOSTATS, sizeof(struct io_sysctl)}; size_t size; if (sysctl(mib, 3, NULL, &size, NULL, 0) == -1) { Logger::error("sysctl hw.drivestats failed"); return; } num_drives = size / sizeof(struct io_sysctl); auto drives = std::unique_ptr { reinterpret_cast(malloc(size)), free }; if (sysctl(mib, 3, drives.get(), &size, NULL, 0) == -1) { Logger::error("sysctl hw.iostats failed"); } for (int i = 0; i < num_drives; i++) { for (auto& [ignored, disk] : disks) { if (disk.dev.string().find(drives[i].name) != string::npos) { string mountpoint = mapping.at(disk.dev); total_bytes_read = drives[i].rbytes; total_bytes_write = drives[i].wbytes; assign_values(disk, total_bytes_read, total_bytes_write); } } } } auto collect(bool no_update) -> mem_info & { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; auto show_swap = Config::getB("show_swap"); auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; static bool snapped = (getenv("BTOP_SNAPPED") != nullptr); uint64_t memActive, memWired, memCached, memFree; size_t size; static int uvmexp_mib[] = {CTL_VM, VM_UVMEXP2}; struct uvmexp_sysctl uvmexp; size = sizeof(uvmexp); if (sysctl(uvmexp_mib, 2, &uvmexp, &size, NULL, 0) == -1) { Logger::error("uvmexp sysctl failed"); bzero(&uvmexp, sizeof(uvmexp)); } memActive = uvmexp.active * Shared::pageSize; memWired = uvmexp.wired * Shared::pageSize; memFree = uvmexp.free * Shared::pageSize; memCached = (uvmexp.filepages + uvmexp.execpages + uvmexp.anonpages) * Shared::pageSize; mem.stats.at("used") = memActive + memWired; mem.stats.at("available") = Shared::totalMem - (memActive + memWired); mem.stats.at("cached") = memCached; mem.stats.at("free") = memFree; if (show_swap) { mem.stats.at("swap_total") = uvmexp.swpages * Shared::pageSize; mem.stats.at("swap_used") = uvmexp.swpginuse * Shared::pageSize; mem.stats.at("swap_free") = (uvmexp.swpages - uvmexp.swpginuse) * Shared::pageSize; } if (show_swap and mem.stats.at("swap_total") > 0) { for (const auto &name : swap_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / mem.stats.at("swap_total"))); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } has_swap = true; } else has_swap = false; //? Calculate percentages for (const auto &name : mem_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / Shared::totalMem)); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } if (show_disks) { std::unordered_map mapping; // keep mapping from device -> mountpoint, since IOKit doesn't give us the mountpoint double uptime = system_uptime(); auto &disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; // auto only_physical = Config::getB("only_physical"); auto &disks = mem.disks; vector filter; if (not disks_filter.empty()) { filter = ssplit(disks_filter); if (filter.at(0).starts_with("exclude=")) { filter_exclude = true; filter.at(0) = filter.at(0).substr(8); } } struct statvfs *stvfs; int count = getmntinfo(&stvfs, MNT_WAIT); vector found; found.reserve(last_found.size()); for (int i = 0; i < count; i++) { auto fstype = string(stvfs[i].f_fstypename); if (fstype == "autofs" || fstype == "devfs" || fstype == "linprocfs" || fstype == "procfs" || fstype == "tmpfs" || fstype == "linsysfs" || fstype == "fdesckfs") { // in memory filesystems -> not useful to show continue; } std::error_code ec; string mountpoint = stvfs[i].f_mntonname; string dev = stvfs[i].f_mntfromname; mapping[dev] = mountpoint; //? Match filter if not empty if (not filter.empty()) { bool match = v_contains(filter, mountpoint); if ((filter_exclude and match) or (not filter_exclude and not match)) continue; } found.push_back(mountpoint); if (not disks.contains(mountpoint)) { disks[mountpoint] = disk_info{fs::canonical(dev, ec), fs::path(mountpoint).filename()}; if (disks.at(mountpoint).dev.empty()) disks.at(mountpoint).dev = dev; if (disks.at(mountpoint).name.empty()) disks.at(mountpoint).name = (mountpoint == "/" ? "root" : mountpoint); } if (not v_contains(last_found, mountpoint)) redraw = true; disks.at(mountpoint).free = stvfs[i].f_bfree; disks.at(mountpoint).total = stvfs[i].f_iosize; } //? Remove disks no longer mounted or filtered out if (swap_disk and has_swap) found.push_back("swap"); for (auto it = disks.begin(); it != disks.end();) { if (not v_contains(found, it->first)) it = disks.erase(it); else it++; } if (found.size() != last_found.size()) redraw = true; last_found = std::move(found); //? Get disk/partition stats for (auto &[mountpoint, disk] : disks) { if (std::error_code ec; not fs::exists(mountpoint, ec)) continue; struct statvfs vfs; if (statvfs(mountpoint.c_str(), &vfs) < 0) { Logger::warning("Failed to get disk/partition stats with statvfs() for: {}", mountpoint); continue; } disk.total = vfs.f_blocks * vfs.f_frsize; disk.free = vfs.f_bfree * vfs.f_frsize; disk.used = disk.total - disk.free; if (disk.total != 0) { disk.used_percent = round((double)disk.used * 100 / disk.total); disk.free_percent = 100 - disk.used_percent; } else { disk.used_percent = 0; disk.free_percent = 0; } } //? Setup disks order in UI and add swap if enabled mem.disks_order.clear(); if (snapped and disks.contains("/mnt")) mem.disks_order.push_back("/mnt"); else if (disks.contains("/")) mem.disks_order.push_back("/"); if (swap_disk and has_swap) { mem.disks_order.push_back("swap"); if (not disks.contains("swap")) disks["swap"] = {"", "swap"}; disks.at("swap").total = mem.stats.at("swap_total"); disks.at("swap").used = mem.stats.at("swap_used"); disks.at("swap").free = mem.stats.at("swap_free"); disks.at("swap").used_percent = mem.percent.at("swap_used").back(); disks.at("swap").free_percent = mem.percent.at("swap_free").back(); } for (const auto &name : last_found) if (not is_in(name, "/", "swap", "/dev")) mem.disks_order.push_back(name); disk_ios = 0; collect_disk(disks, mapping); old_uptime = uptime; } return mem; } } // namespace Mem namespace Net { std::unordered_map current_net; net_info empty_net = {}; vector interfaces; string selected_iface; int errors = 0; std::unordered_map graph_max = {{"download", {}}, {"upload", {}}}; std::unordered_map> max_count = {{"download", {}}, {"upload", {}}}; bool rescale = true; uint64_t timestamp = 0; auto collect(bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { //? Get interface list using getifaddrs() wrapper IfAddrsPtr if_addrs {}; if (if_addrs.get_status() != 0) { errors++; Logger::error("Net::collect() -> getifaddrs() failed with id {}", if_addrs.get_status()); redraw = true; return empty_net; } int family = 0; static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; //? Iteration over all items in getifaddrs() list for (auto *ifa = if_addrs.get(); ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr == nullptr) continue; family = ifa->ifa_addr->sa_family; const auto &iface = ifa->ifa_name; //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); // An interface can have more than one IP of the same family associated with it, // but we pick only the first one to show in the NET box. // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! net[iface].ipv4.clear(); net[iface].ipv6.clear(); } //? Get IPv4 address if (family == AF_INET) { if (net[iface].ipv4.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv4 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //? Get IPv6 address else if (family == AF_INET6) { if (net[iface].ipv6.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv6 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //else, ignoring family==AF_LINK (see man 3 getifaddrs) } std::unordered_map> ifstats; int mib[] = {CTL_NET, PF_ROUTE, 0, 0, NET_RT_IFLIST, 0}; size_t len; if (sysctl(mib, 6, nullptr, &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { std::unique_ptr buf(new char[len]); if (sysctl(mib, 6, buf.get(), &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { char *lim = buf.get() + len; char *next = nullptr; for (next = buf.get(); next < lim;) { struct if_msghdr *ifm = (struct if_msghdr *)next; next += ifm->ifm_msglen; struct if_data ifm_data = ifm->ifm_data; if (ifm->ifm_addrs & RTA_IFP) { struct sockaddr_dl *sdl = (struct sockaddr_dl *)(ifm + 1); char iface[32]; strncpy(iface, sdl->sdl_data, sdl->sdl_nlen); iface[sdl->sdl_nlen] = 0; ifstats[iface] = std::tuple(ifm_data.ifi_ibytes, ifm_data.ifi_obytes); } } } } //? Get total received and transmitted bytes + device address if no ip was found for (const auto &iface : interfaces) { for (const string dir : {"download", "upload"}) { auto &saved_stat = net.at(iface).stat.at(dir); auto &bandwidth = net.at(iface).bandwidth.at(dir); uint64_t val = dir == "download" ? std::get<0>(ifstats[iface]) : std::get<1>(ifstats[iface]); //? Update speed, total and top values if (val < saved_stat.last) { saved_stat.rollover += saved_stat.last; saved_stat.last = 0; } if (cmp_greater((unsigned long long)saved_stat.rollover + (unsigned long long)val, numeric_limits::max())) { saved_stat.rollover = 0; saved_stat.last = 0; } saved_stat.speed = round((double)(val - saved_stat.last) / ((double)(new_timestamp - timestamp) / 1000)); if (saved_stat.speed > saved_stat.top) saved_stat.top = saved_stat.speed; if (saved_stat.offset > val + saved_stat.rollover) saved_stat.offset = 0; saved_stat.total = (val + saved_stat.rollover) - saved_stat.offset; saved_stat.last = val; //? Add values to graph bandwidth.push_back(saved_stat.speed); while (cmp_greater(bandwidth.size(), width * 2)) bandwidth.pop_front(); //? Set counters for auto scaling if (net_auto and selected_iface == iface) { if (saved_stat.speed > graph_max[dir]) { ++max_count[dir][0]; if (max_count[dir][1] > 0) --max_count[dir][1]; } else if (graph_max[dir] > 10 << 10 and saved_stat.speed < graph_max[dir] / 10) { ++max_count[dir][1]; if (max_count[dir][0] > 0) --max_count[dir][0]; } } } } //? Clean up net map if needed if (net.size() > interfaces.size()) { for (auto it = net.begin(); it != net.end();) { if (not v_contains(interfaces, it->first)) it = net.erase(it); else it++; } } timestamp = new_timestamp; } //? Return empty net_info struct if no interfaces was found if (net.empty()) return empty_net; //? Find an interface to display if selected isn't set or valid if (selected_iface.empty() or not v_contains(interfaces, selected_iface)) { max_count["download"][0] = max_count["download"][1] = max_count["upload"][0] = max_count["upload"][1] = 0; redraw = true; if (net_auto) rescale = true; if (not config_iface.empty() and v_contains(interfaces, config_iface)) selected_iface = config_iface; else { //? Sort interfaces by total upload + download bytes auto sorted_interfaces = interfaces; rng::sort(sorted_interfaces, [&](const auto &a, const auto &b) { return cmp_greater(net.at(a).stat["download"].total + net.at(a).stat["upload"].total, net.at(b).stat["download"].total + net.at(b).stat["upload"].total); }); selected_iface.clear(); //? Try to set to a connected interface for (const auto &iface : sorted_interfaces) { if (net.at(iface).connected) selected_iface = iface; break; } //? If no interface is connected set to first available if (selected_iface.empty() and not sorted_interfaces.empty()) selected_iface = sorted_interfaces.at(0); else if (sorted_interfaces.empty()) return empty_net; } } //? Calculate max scale for graphs if needed if (net_auto) { bool sync = false; for (const auto &dir : {"download", "upload"}) { for (const auto &sel : {0, 1}) { if (rescale or max_count[dir][sel] >= 5) { const long long avg_speed = (net[selected_iface].bandwidth[dir].size() > 5 ? std::accumulate(net.at(selected_iface).bandwidth.at(dir).rbegin(), net.at(selected_iface).bandwidth.at(dir).rbegin() + 5, 0ll) / 5 : net[selected_iface].stat[dir].speed); graph_max[dir] = max(uint64_t(avg_speed * (sel == 0 ? 1.3 : 3.0)), (uint64_t)10 << 10); max_count[dir][0] = max_count[dir][1] = 0; redraw = true; if (net_sync) sync = true; break; } } //? Sync download/upload graphs if enabled if (sync) { const auto other = (string(dir) == "upload" ? "download" : "upload"); graph_max[other] = graph_max[dir]; max_count[other][0] = max_count[other][1] = 0; break; } } } rescale = false; return net.at(selected_iface); } } // namespace Net namespace Proc { vector current_procs; std::unordered_map uid_user; string current_sort; string current_filter; bool current_rev = false; bool is_tree_mode; fs::file_time_type passwd_time; uint64_t cputimes; int collapse = -1, expand = -1, toggle_children = -1, collapse_all = -1; uint64_t old_cputimes = 0; atomic numpids = 0; int filter_found = 0; detail_container detailed; static std::unordered_set dead_procs; string get_status(char s) { if (s & LSRUN) return "Running"; if (s & LSSLEEP) return "Sleeping"; if (s & SIDL) return "Idle"; if (s & SSTOP) return "Stopped"; if (s & SZOMB) return "Zombie"; return "Unknown"; } //* Get detailed info for selected process void _collect_details(const size_t pid, vector &procs) { if (pid != detailed.last_pid) { detailed = {}; detailed.last_pid = pid; detailed.skip_smaps = not Config::getB("proc_info_smaps"); } //? Copy proc_info for process from proc vector auto p_info = rng::find(procs, pid, &proc_info::pid); detailed.entry = *p_info; //? Update cpu percent deque for process cpu graph if (not Config::getB("proc_per_core")) detailed.entry.cpu_p *= Shared::coreCount; detailed.cpu_percent.push_back(clamp((long long)round(detailed.entry.cpu_p), 0ll, 100ll)); while (cmp_greater(detailed.cpu_percent.size(), width)) detailed.cpu_percent.pop_front(); //? Process runtime : current time - start time (both in unix time - seconds since epoch) struct timeval currentTime; gettimeofday(¤tTime, nullptr); // only interested in second granularity, so ignoring tc_usec if (detailed.entry.state != 'X') detailed.elapsed = sec_to_dhms(currentTime.tv_sec - detailed.entry.cpu_s); else detailed.elapsed = sec_to_dhms(detailed.entry.death_time); if (detailed.elapsed.size() > 8) detailed.elapsed.resize(detailed.elapsed.size() - 3); //? Get parent process name if (detailed.parent.empty()) { auto p_entry = rng::find(procs, detailed.entry.ppid, &proc_info::pid); if (p_entry != procs.end()) detailed.parent = p_entry->name; } //? Expand process status from single char to explanative string detailed.status = get_status(detailed.entry.state); detailed.mem_bytes.push_back(detailed.entry.mem); detailed.memory = floating_humanizer(detailed.entry.mem); if (detailed.first_mem == -1 or detailed.first_mem < detailed.mem_bytes.back() / 2 or detailed.first_mem > detailed.mem_bytes.back() * 4) { detailed.first_mem = min((uint64_t)detailed.mem_bytes.back() * 2, Mem::get_totalMem()); redraw = true; } while (cmp_greater(detailed.mem_bytes.size(), width)) detailed.mem_bytes.pop_front(); } //* Collects and sorts process information from /proc auto collect(bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); auto per_core = Config::getB("proc_per_core"); auto tree = Config::getB("proc_tree"); auto show_detailed = Config::getB("show_detailed"); const auto pause_proc_list = Config::getB("pause_proc_list"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); bool tree_mode_change = tree != is_tree_mode; if (sorted_change) { current_sort = sorting; current_rev = reverse; } if (tree_mode_change) is_tree_mode = tree; const int cmult = (per_core) ? Shared::coreCount : 1; bool got_detailed = false; static vector found; //* Use pids from last update if only changing filter, sorting or tree options if (no_update and not current_procs.empty()) { if (show_detailed and detailed_pid != detailed.last_pid) _collect_details(detailed_pid, current_procs); } else { //* ---------------------------------------------Collection start---------------------------------------------- should_filter = true; found.clear(); struct timeval currentTime; gettimeofday(¤tTime, nullptr); const double timeNow = currentTime.tv_sec + (currentTime.tv_usec / 1'000'000); int count = 0; char buf[_POSIX2_LINE_MAX]; Shared::KvmPtr kd {kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, buf)}; const struct kinfo_proc2* kprocs = kvm_getproc2(kd.get(), KERN_PROC_ALL, 0, sizeof(struct kinfo_proc2), &count); for (int i = 0; i < count; i++) { const struct kinfo_proc2* kproc = &kprocs[i]; const size_t pid = (size_t)kproc->p_pid; if (pid < 1) continue; found.push_back(pid); //? Check if pid already exists in current_procs bool no_cache = false; auto find_old = rng::find(current_procs, pid, &proc_info::pid); //? Only add new processes if not paused if (find_old == current_procs.end()) { if (not pause_proc_list) { current_procs.push_back({pid}); find_old = current_procs.end() - 1; no_cache = true; } else continue; } else if (dead_procs.contains(pid)) continue; auto &new_proc = *find_old; //? Get program name, command, username, parent pid, nice and status if (no_cache) { if (string(kproc->p_comm) == "idle"s) { current_procs.pop_back(); found.pop_back(); continue; } new_proc.name = kproc->p_comm; char** argv = kvm_getargv2(kd.get(), kproc, 0); if (argv) { for (int i = 0; argv[i] and cmp_less(new_proc.cmd.size(), 1000); i++) { new_proc.cmd += argv[i] + " "s; } if (not new_proc.cmd.empty()) new_proc.cmd.pop_back(); } if (new_proc.cmd.empty()) new_proc.cmd = new_proc.name; if (new_proc.cmd.size() > 1000) { new_proc.cmd.resize(1000); new_proc.cmd.shrink_to_fit(); } new_proc.ppid = kproc->p_ppid; new_proc.cpu_s = round(kproc->p_ustart_sec); struct passwd *pwd = getpwuid(kproc->p_uid); if (pwd) new_proc.user = pwd->pw_name; } new_proc.p_nice = kproc->p_nice; new_proc.state = kproc->p_stat; int cpu_t = 0; cpu_t = kproc->p_uctime_usec * 1'000'000 + kproc->p_uctime_sec; new_proc.mem = kproc->p_vm_rssize * Shared::pageSize; new_proc.threads = 1; // can't seem to find this in kinfo_proc //? Process cpu usage since last update new_proc.cpu_p = clamp((100.0 * kproc->p_pctcpu / Shared::kfscale) * cmult, 0.0, 100.0 * Shared::coreCount); //? Process cumulative cpu usage since process start new_proc.cpu_c = (double)(cpu_t * Shared::clkTck / 1'000'000) / max(1.0, timeNow - new_proc.cpu_s); //? Update cached value with latest cpu times new_proc.cpu_t = cpu_t; if (show_detailed and not got_detailed and new_proc.pid == detailed_pid) { got_detailed = true; } } //? Clear dead processes from current_procs if not paused if (not pause_proc_list) { auto eraser = rng::remove_if(current_procs, [&](const auto& element) { return not v_contains(found, element.pid); }); current_procs.erase(eraser.begin(), eraser.end()); if (!dead_procs.empty()) dead_procs.clear(); } //? Set correct state of dead processes if paused else { const bool keep_dead_proc_usage = Config::getB("keep_dead_proc_usage"); for (auto& r : current_procs) { if (rng::find(found, r.pid) == found.end()) { if (r.state != 'X') { struct timeval currentTime; gettimeofday(¤tTime, nullptr); r.death_time = currentTime.tv_sec - r.cpu_s; } r.state = 'X'; dead_procs.emplace(r.pid); //? Reset cpu usage for dead processes if paused and option is set if (!keep_dead_proc_usage) { r.cpu_p = 0.0; r.mem = 0; } } } } //? Update the details info box for process if active if (show_detailed and got_detailed) { _collect_details(detailed_pid, current_procs); } else if (show_detailed and not got_detailed and detailed.status != "Dead") { detailed.status = "Dead"; redraw = true; } old_cputimes = cputimes; } //* ---------------------------------------------Collection done----------------------------------------------- //* Match filter if defined if (should_filter) { filter_found = 0; for (auto& p : current_procs) { if (not tree and not filter.empty()) { if (not s_contains_ic(to_string(p.pid), filter) and not s_contains_ic(p.name, filter) and not s_contains_ic(p.cmd, filter) and not s_contains_ic(p.user, filter)) { p.filtered = true; filter_found++; } else { p.filtered = false; } } else { p.filtered = false; } } } //* Sort processes if ((sorted_change or tree_mode_change) or (not no_update and not pause_proc_list)) { proc_sorter(current_procs, sorting, reverse, tree); } //* Generate tree view if enabled if (tree and (not no_update or should_filter or sorted_change)) { bool locate_selection = false; if (auto find_pid = (collapse != -1 ? collapse : expand); find_pid != -1) { auto collapser = rng::find(current_procs, find_pid, &proc_info::pid); if (collapser != current_procs.end()) { if (collapse == expand) { collapser->collapsed = not collapser->collapsed; } else if (collapse > -1) { collapser->collapsed = true; } else if (expand > -1) { collapser->collapsed = false; } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } collapse = expand = -1; } if (collapse_all != -1) { toggle_tree_collapse(current_procs); collapse_all = -1; if (Config::ints.at("proc_selected") > 0) locate_selection = true; } if (should_filter or not filter.empty()) filter_found = 0; vector tree_procs; tree_procs.reserve(current_procs.size()); if (!pause_proc_list) { for (auto& p : current_procs) { if (not v_contains(found, p.ppid)) p.ppid = 0; } } //? Stable sort to retain selected sorting among processes with the same parent rng::stable_sort(current_procs, rng::less{}, & proc_info::ppid); //? Start recursive iteration over processes with the lowest shared parent pids for (auto& p : rng::equal_range(current_procs, current_procs.at(0).ppid, rng::less{}, &proc_info::ppid)) { _tree_gen(p, current_procs, tree_procs, 0, false, filter, false, no_update, should_filter); } //? Recursive sort over tree structure to account for collapsed processes in the tree int index = 0; tree_sort(tree_procs, sorting, reverse, (pause_proc_list and not (sorted_change or tree_mode_change)), index, current_procs.size()); //? Recursive construction of ASCII tree prefixes. for (auto t = tree_procs.begin(); t != tree_procs.end(); ++t) { _collect_prefixes(*t, t == tree_procs.end() - 1); } //? Final sort based on tree index rng::stable_sort(current_procs, rng::less {}, &proc_info::tree_index); //? Move current selection/view to the selected process when collapsing/expanding in the tree if (locate_selection) { int loc = rng::find(current_procs, Proc::selected_pid, &proc_info::pid)->tree_index; if (Config::ints.at("proc_start") >= loc or Config::ints.at("proc_start") <= loc - Proc::select_max) Config::ints.at("proc_start") = max(0, loc - 1); Config::ints.at("proc_selected") = loc - Config::ints.at("proc_start") + 1; } } numpids = (int)current_procs.size() - filter_found; return current_procs; } } // namespace Proc namespace Tools { double system_uptime() { struct timeval ts, currTime; std::size_t len = sizeof(ts); int mib[2] = {CTL_KERN, KERN_BOOTTIME}; if (sysctl(mib, 2, &ts, &len, nullptr, 0) != -1) { gettimeofday(&currTime, nullptr); return currTime.tv_sec - ts.tv_sec; } return 0.0; } } // namespace Tools aristocratos-btop-d43a485/src/openbsd/000077500000000000000000000000001517514752700177665ustar00rootroot00000000000000aristocratos-btop-d43a485/src/openbsd/btop_collect.cpp000066400000000000000000001260041517514752700231460ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include // man 3 getifaddrs: "BUGS: If both and are being included, must be included before " #include #include #include #include #include #include #include // for inet_ntop stuff #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../btop_config.hpp" #include "../btop_log.hpp" #include "../btop_shared.hpp" #include "../btop_tools.hpp" #include "./sysctlbyname.h" using std::clamp, std::string_literals::operator""s, std::cmp_equal, std::cmp_less, std::cmp_greater; using std::ifstream, std::numeric_limits, std::streamsize, std::round, std::max, std::min; namespace fs = std::filesystem; namespace rng = std::ranges; using namespace Tools; //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace Cpu { vector core_old_totals; vector core_old_idles; vector available_fields = {"total"}; vector available_sensors = {"Auto"}; cpu_info current_cpu; bool got_sensors = false, cpu_temp_only = false, supports_watts = false; //* Populate found_sensors map bool get_sensors(); //* Get current cpu clock speed string get_cpuHz(); //* Search /proc/cpuinfo for a cpu name string get_cpuName(); struct Sensor { fs::path path; string label; int64_t temp = 0; int64_t high = 0; int64_t crit = 0; }; string cpu_sensor; vector core_sensors; std::unordered_map core_mapping; } // namespace Cpu namespace Mem { double old_uptime; } namespace Shared { fs::path passwd_path; uint64_t totalMem; long pageSize, clkTck, coreCount, physicalCoreCount, arg_max; int totalMem_len, kfscale; long bootTime; void init() { //? Shared global variables init int mib[] = {CTL_HW, HW_NCPUONLINE}; int ncpu_online; size_t len = sizeof(ncpu_online); if (sysctl(mib, 2, &ncpu_online, &len, nullptr, 0) == -1) { Logger::warning("Could not determine number of cores, defaulting to 1."); } else { coreCount = ncpu_online; } pageSize = sysconf(_SC_PAGE_SIZE); if (pageSize <= 0) { pageSize = 4096; Logger::warning("Could not get system page size. Defaulting to 4096, processes memory usage might be incorrect."); } clkTck = sysconf(_SC_CLK_TCK); if (clkTck <= 0) { clkTck = 100; Logger::warning("Could not get system clock ticks per second. Defaulting to 100, processes cpu usage might be incorrect."); } int64_t memsize = 0; size_t size = sizeof(memsize); if (sysctlbyname("hw.physmem", &memsize, &size, nullptr, 0) < 0) { Logger::warning("Could not get memory size"); } totalMem = memsize; struct timeval result; size = sizeof(result); if (sysctlbyname("kern.boottime", &result, &size, nullptr, 0) < 0) { Logger::warning("Could not get boot time"); } else { bootTime = result.tv_sec; } size = sizeof(kfscale); if (sysctlbyname("kern.fscale", &kfscale, &size, nullptr, 0) == -1) { kfscale = 2048; } //* Get maximum length of process arguments arg_max = sysconf(_SC_ARG_MAX); //? Init for namespace Cpu Cpu::current_cpu.core_percent.insert(Cpu::current_cpu.core_percent.begin(), Shared::coreCount, {}); Cpu::current_cpu.temp.insert(Cpu::current_cpu.temp.begin(), Shared::coreCount + 1, {}); Cpu::core_old_totals.insert(Cpu::core_old_totals.begin(), Shared::coreCount, 0); Cpu::core_old_idles.insert(Cpu::core_old_idles.begin(), Shared::coreCount, 0); Cpu::collect(); for (auto &[field, vec] : Cpu::current_cpu.cpu_percent) { if (not vec.empty() and not v_contains(Cpu::available_fields, field)) Cpu::available_fields.push_back(field); } Cpu::cpuName = Cpu::get_cpuName(); Cpu::got_sensors = Cpu::get_sensors(); Cpu::core_mapping = Cpu::get_core_mapping(); //? Init for namespace Mem Mem::old_uptime = system_uptime(); Mem::collect(); } } // namespace Shared namespace Cpu { string cpuName; string cpuHz; bool has_battery = true; tuple current_bat; const array time_names = {"user", "nice", "system", "idle"}; std::unordered_map cpu_old = { {"totals", 0}, {"idles", 0}, {"user", 0}, {"nice", 0}, {"system", 0}, {"idle", 0} }; string get_cpuName() { string name; char buffer[1024]; size_t size = sizeof(buffer); if (sysctlbyname("hw.model", &buffer, &size, nullptr, 0) < 0) { Logger::error("Failed to get CPU name"); return name; } return trim_name(string(buffer)); } int64_t get_sensor(string device, vector types, int num) { struct sensordev sensordev; struct sensor sensor; size_t sdlen, slen; int dev; int mib[] = {CTL_HW, HW_SENSORS, 0, 0, 0}; sdlen = sizeof(sensordev); slen = sizeof(sensor); for (dev = 0;; dev++) { mib[2] = dev; if (sysctl(mib, 3, &sensordev, &sdlen, NULL, 0) == -1) { if (errno == ENXIO) continue; if (errno == ENOENT) break; } if (strstr(sensordev.xname, device.c_str())) { mib[4] = num; for (sensor_type type : types) { mib[3] = type; if (sysctl(mib, 5, &sensor, &slen, NULL, 0) == -1) { if (errno != ENOENT) { Logger::warning("sysctl"); continue; } } else return sensor.value; } } } return -1; } bool get_sensors() { got_sensors = false; if (Config::getB("show_coretemp") and Config::getB("check_temp")) { if (get_sensor(string("cpu0"), { SENSOR_TEMP }, 0) > 0) { got_sensors = true; current_cpu.temp_max = 100; // we don't have this info } else { Logger::warning("Could not get temp sensor"); } } return got_sensors; } #define MUKTOC(v) ((v - 273150000) / 1000000.0) void update_sensors() { int temp = 0; int p_temp = 0; temp = get_sensor(string("cpu0"), { SENSOR_TEMP }, 0); if (temp > -1) { temp = MUKTOC(temp); p_temp = temp; for (int i = 0; i < Shared::coreCount; i++) { if (cmp_less(i + 1, current_cpu.temp.size())) { current_cpu.temp.at(i + 1).push_back(temp); if (current_cpu.temp.at(i + 1).size() > 20) current_cpu.temp.at(i + 1).pop_front(); } } current_cpu.temp.at(0).push_back(p_temp); if (current_cpu.temp.at(0).size() > 20) current_cpu.temp.at(0).pop_front(); } } string get_cpuHz() { unsigned int freq = 1; size_t size = sizeof(freq); if (sysctlbyname("hw.cpuspeed", &freq, &size, nullptr, 0) < 0) { return ""; } return std::to_string(freq / 1000.0 ).substr(0, 3); // seems to be in MHz } auto get_core_mapping() -> std::unordered_map { std::unordered_map core_map; if (cpu_temp_only) return core_map; for (long i = 0; i < Shared::coreCount; i++) { core_map[i] = i; } //? If core mapping from cpuinfo was incomplete try to guess remainder, if missing completely, map 0-0 1-1 2-2 etc. if (cmp_less(core_map.size(), Shared::coreCount)) { if (Shared::coreCount % 2 == 0 and (long) core_map.size() == Shared::coreCount / 2) { for (int i = 0, n = 0; i < Shared::coreCount / 2; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[Shared::coreCount / 2 + i] = n++; } } else { core_map.clear(); for (int i = 0, n = 0; i < Shared::coreCount; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[i] = n++; } } } //? Apply user set custom mapping if any const auto &custom_map = Config::getS("cpu_core_map"); if (not custom_map.empty()) { try { for (const auto &split : ssplit(custom_map)) { const auto vals = ssplit(split, ':'); if (vals.size() != 2) continue; int change_id = std::stoi(vals.at(0)); int new_id = std::stoi(vals.at(1)); if (not core_map.contains(change_id) or cmp_greater(new_id, core_sensors.size())) continue; core_map.at(change_id) = new_id; } } catch (...) { } } return core_map; } auto get_battery() -> tuple { if (not has_battery) return {0, 0, 0, ""}; long seconds = -1; uint32_t percent = -1; float rate = -1.0f; string status = "discharging"; int64_t full, remaining, watts; full = get_sensor("acpibat0", { SENSOR_AMPHOUR, SENSOR_WATTHOUR }, 0); remaining = get_sensor("acpibat0", { SENSOR_AMPHOUR, SENSOR_WATTHOUR }, 3); watts = get_sensor("acpibat0", { SENSOR_WATTS }, 0); int64_t state = get_sensor("acpibat0", { SENSOR_INTEGER }, 0); if (full < 0) { has_battery = false; Logger::warning("failed to get battery"); } else { float_t f = full / 1000; float_t r = remaining / 1000; if (watts > 0) { supports_watts = true; rate = watts / 1000000.0f; // watts is given in ยตW } has_battery = true; percent = r / f * 100; if (percent == 100) { status = "full"; } switch (state) { case 0: status = "full"; percent = 100; break; case 2: status = "charging"; break; } } return {percent, rate, seconds, status}; } auto collect(bool no_update) -> cpu_info & { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto &cpu = current_cpu; if (getloadavg(cpu.load_avg.data(), cpu.load_avg.size()) < 0) { Logger::error("failed to get load averages"); } //? Read total physical CPU count for sysctl iteration //? (may differ from coreCount when SMT is disabled via hw.smt=0). int ncpu_total = Shared::coreCount; { int mib[] = {CTL_HW, HW_NCPU}; size_t len = sizeof(ncpu_total); sysctl(mib, 2, &ncpu_total, &len, nullptr, 0); } //? Re-query online CPU count in case it changed at runtime (e.g. hw.smt toggled). { int mib[] = {CTL_HW, HW_NCPUONLINE}; int ncpu_online = Shared::coreCount; size_t len = sizeof(ncpu_online); if (sysctl(mib, 2, &ncpu_online, &len, nullptr, 0) != -1 and ncpu_online != Shared::coreCount) { Shared::coreCount = ncpu_online; core_old_totals.resize(Shared::coreCount, 0); core_old_idles.resize(Shared::coreCount, 0); cpu.core_percent.resize(Shared::coreCount); cpu.temp.resize(Shared::coreCount + 1); Runner::coreNum_reset = true; } } auto cp_time = std::unique_ptr{ new struct cpustats[ncpu_total] }; size_t size = sizeof(struct cpustats); static int cpustats_mib[] = {CTL_KERN, KERN_CPUSTATS, /*fillme*/0}; for (int i = 0; i < ncpu_total; i++) { cpustats_mib[2] = i; if (sysctl(cpustats_mib, 3, &cp_time[i], &size, NULL, 0) == -1) { Logger::error("sysctl kern.cpustats failed"); } } long long global_totals = 0; long long global_idles = 0; vector times_summed = {0, 0, 0, 0}; //? j iterates all physical CPUs; offline ones are skipped //? i is the display slot index, incremented only for online CPUs for (long i = 0, j = 0; j < ncpu_total; j++) { if (!(cp_time[j].cs_flags & CPUSTATS_ONLINE)) continue; vector times; //? 0=user, 1=nice, 2=system, 3=idle for (int x = 0; const unsigned int c_state : {CP_USER, CP_NICE, CP_SYS, CP_IDLE}) { auto val = cp_time[j].cs_time[c_state]; times.push_back(val); times_summed.at(x++) += val; } try { //? All values const long long totals = std::accumulate(times.begin(), times.end(), 0ll); //? Idle time const long long idles = times.at(3); global_totals += totals; global_idles += idles; //? Calculate cpu total for each core const long long calc_totals = max(0ll, totals - core_old_totals.at(i)); const long long calc_idles = max(0ll, idles - core_old_idles.at(i)); core_old_totals.at(i) = totals; core_old_idles.at(i) = idles; cpu.core_percent.at(i).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph if (cpu.core_percent.at(i).size() > 40) cpu.core_percent.at(i).pop_front(); } catch (const std::exception &e) { Logger::error("Cpu::collect() : {}", e.what()); throw std::runtime_error(fmt::format("collect() : {}", e.what())); } i++; } const long long calc_totals = max(1ll, global_totals - cpu_old.at("totals")); const long long calc_idles = max(1ll, global_idles - cpu_old.at("idles")); //? Populate cpu.cpu_percent with all fields from syscall for (int ii = 0; const auto &val : times_summed) { cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); cpu_old.at(time_names.at(ii)) = val; //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); ii++; } cpu_old.at("totals") = global_totals; cpu_old.at("idles") = global_idles; //? Total usage of cpu cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); if (Config::getB("show_cpu_freq")) { auto hz = get_cpuHz(); if (hz != "") { cpuHz = hz; } } if (Config::getB("check_temp") and got_sensors) update_sensors(); if (Config::getB("show_battery") and has_battery) current_bat = get_battery(); return cpu; } } // namespace Cpu namespace Mem { bool has_swap = false; vector fstab; fs::file_time_type fstab_time; int disk_ios = 0; vector last_found; mem_info current_mem{}; uint64_t get_totalMem() { return Shared::totalMem; } void assign_values(struct disk_info& disk, int64_t readBytes, int64_t writeBytes) { disk_ios++; if (disk.io_read.empty()) { disk.io_read.push_back(0); } else { disk.io_read.push_back(max((int64_t)0, (readBytes - disk.old_io.at(0)))); } disk.old_io.at(0) = readBytes; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); if (disk.io_write.empty()) { disk.io_write.push_back(0); } else { disk.io_write.push_back(max((int64_t)0, (writeBytes - disk.old_io.at(1)))); } disk.old_io.at(1) = writeBytes; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); // no io times - need to push something anyway or we'll get an ABORT if (disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(clamp((long)round((double)(disk.io_write.back() + disk.io_read.back()) / (1 << 20)), 0l, 100l)); while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } void collect_disk(std::unordered_map &disks, std::unordered_map &mapping) { uint64_t total_bytes_read = 0; uint64_t total_bytes_write = 0; int num_drives = 0; int mib[2] = { CTL_HW, HW_DISKCOUNT }; size_t size; if (sysctl(mib, 2, &num_drives, &size, NULL, 0) >= 0) { mib[0] = CTL_HW; mib[1] = HW_DISKSTATS; size = num_drives * sizeof(struct diskstats); auto p = std::unique_ptr { reinterpret_cast(malloc(size)), free }; if (sysctl(mib, 2, p.get(), &size, NULL, 0) == -1) { Logger::error("failed to get disk stats"); return; } for (int i = 0; i < num_drives; i++) { for (auto& [ignored, disk] : disks) { if (disk.dev.string().find(p[i].ds_name) != string::npos) { string mountpoint = mapping.at(disk.dev); total_bytes_read = p[i].ds_rbytes; total_bytes_write = p[i].ds_wbytes; assign_values(disk, total_bytes_read, total_bytes_write); } } } } } auto collect(bool no_update) -> mem_info & { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; auto show_swap = Config::getB("show_swap"); auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; static bool snapped = (getenv("BTOP_SNAPPED") != nullptr); u_int memActive, memWire, cachedMem; // u_int freeMem; size_t size; static int uvmexp_mib[] = {CTL_VM, VM_UVMEXP}; static int bcstats_mib[] = {CTL_VFS, VFS_GENERIC, VFS_BCACHESTAT}; struct uvmexp uvmexp; struct bcachestats bcstats; size = sizeof(uvmexp); if (sysctl(uvmexp_mib, 2, &uvmexp, &size, NULL, 0) == -1) { Logger::error("sysctl failed"); bzero(&uvmexp, sizeof(uvmexp)); } size = sizeof(bcstats); if (sysctl(bcstats_mib, 3, &bcstats, &size, NULL, 0) == -1) { Logger::error("sysctl failed"); bzero(&bcstats, sizeof(bcstats)); } memActive = uvmexp.active * Shared::pageSize; memWire = uvmexp.wired; // freeMem = uvmexp.free * Shared::pageSize; cachedMem = bcstats.numbufpages * Shared::pageSize; mem.stats.at("used") = memActive; mem.stats.at("available") = Shared::totalMem - memActive - memWire; mem.stats.at("cached") = cachedMem; mem.stats.at("free") = Shared::totalMem - memActive - memWire; if (show_swap) { int total = uvmexp.swpages * Shared::pageSize; mem.stats.at("swap_total") = total; int swapped = uvmexp.swpgonly * Shared::pageSize; mem.stats.at("swap_used") = swapped; mem.stats.at("swap_free") = total - swapped; } if (show_swap and mem.stats.at("swap_total") > 0) { for (const auto &name : swap_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / mem.stats.at("swap_total"))); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } has_swap = true; } else has_swap = false; //? Calculate percentages for (const auto &name : mem_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / Shared::totalMem)); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } if (show_disks) { std::unordered_map mapping; // keep mapping from device -> mountpoint, since IOKit doesn't give us the mountpoint double uptime = system_uptime(); auto &disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; // auto only_physical = Config::getB("only_physical"); auto &disks = mem.disks; vector filter; if (not disks_filter.empty()) { filter = ssplit(disks_filter); if (filter.at(0).starts_with("exclude=")) { filter_exclude = true; filter.at(0) = filter.at(0).substr(8); } } struct statfs *stfs; int count = getmntinfo(&stfs, MNT_WAIT); vector found; found.reserve(last_found.size()); for (int i = 0; i < count; i++) { auto fstype = string(stfs[i].f_fstypename); if (fstype == "autofs" || fstype == "devfs" || fstype == "linprocfs" || fstype == "procfs" || fstype == "tmpfs" || fstype == "linsysfs" || fstype == "fdesckfs") { // in memory filesystems -> not useful to show continue; } std::error_code ec; string mountpoint = stfs[i].f_mntonname; string dev = stfs[i].f_mntfromname; mapping[dev] = mountpoint; //? Match filter if not empty if (not filter.empty()) { bool match = v_contains(filter, mountpoint); if ((filter_exclude and match) or (not filter_exclude and not match)) continue; } found.push_back(mountpoint); if (not disks.contains(mountpoint)) { disks[mountpoint] = disk_info{fs::canonical(dev, ec), fs::path(mountpoint).filename()}; if (disks.at(mountpoint).dev.empty()) disks.at(mountpoint).dev = dev; if (disks.at(mountpoint).name.empty()) disks.at(mountpoint).name = (mountpoint == "/" ? "root" : mountpoint); } if (not v_contains(last_found, mountpoint)) redraw = true; disks.at(mountpoint).free = stfs[i].f_bfree; disks.at(mountpoint).total = stfs[i].f_iosize; } //? Remove disks no longer mounted or filtered out if (swap_disk and has_swap) found.push_back("swap"); for (auto it = disks.begin(); it != disks.end();) { if (not v_contains(found, it->first)) it = disks.erase(it); else it++; } if (found.size() != last_found.size()) redraw = true; last_found = std::move(found); //? Get disk/partition stats for (auto &[mountpoint, disk] : disks) { if (std::error_code ec; not fs::exists(mountpoint, ec)) continue; struct statvfs vfs; if (statvfs(mountpoint.c_str(), &vfs) < 0) { Logger::warning("Failed to get disk/partition stats with statvfs() for: {}", mountpoint); continue; } disk.total = vfs.f_blocks * vfs.f_frsize; disk.free = vfs.f_bfree * vfs.f_frsize; disk.used = disk.total - disk.free; if (disk.total != 0) { disk.used_percent = round((double)disk.used * 100 / disk.total); disk.free_percent = 100 - disk.used_percent; } else { disk.used_percent = 0; disk.free_percent = 0; } } //? Setup disks order in UI and add swap if enabled mem.disks_order.clear(); if (snapped and disks.contains("/mnt")) mem.disks_order.push_back("/mnt"); else if (disks.contains("/")) mem.disks_order.push_back("/"); if (swap_disk and has_swap) { mem.disks_order.push_back("swap"); if (not disks.contains("swap")) disks["swap"] = {"", "swap"}; disks.at("swap").total = mem.stats.at("swap_total"); disks.at("swap").used = mem.stats.at("swap_used"); disks.at("swap").free = mem.stats.at("swap_free"); disks.at("swap").used_percent = mem.percent.at("swap_used").back(); disks.at("swap").free_percent = mem.percent.at("swap_free").back(); } for (const auto &name : last_found) if (not is_in(name, "/", "swap", "/dev")) mem.disks_order.push_back(name); disk_ios = 0; collect_disk(disks, mapping); old_uptime = uptime; } return mem; } } // namespace Mem namespace Net { std::unordered_map current_net; net_info empty_net = {}; vector interfaces; string selected_iface; int errors = 0; std::unordered_map graph_max = {{"download", {}}, {"upload", {}}}; std::unordered_map> max_count = {{"download", {}}, {"upload", {}}}; bool rescale = true; uint64_t timestamp = 0; auto collect(bool no_update) -> net_info & { auto &net = current_net; auto &config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { //? Get interface list using getifaddrs() wrapper IfAddrsPtr if_addrs {}; if (if_addrs.get_status() != 0) { errors++; Logger::error("Net::collect() -> getifaddrs() failed with id {}", if_addrs.get_status()); redraw = true; return empty_net; } int family = 0; static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; //? Iteration over all items in getifaddrs() list for (auto *ifa = if_addrs.get(); ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr == nullptr) continue; family = ifa->ifa_addr->sa_family; const auto &iface = ifa->ifa_name; //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); // An interface can have more than one IP of the same family associated with it, // but we pick only the first one to show in the NET box. // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! net[iface].ipv4.clear(); net[iface].ipv6.clear(); } //? Get IPv4 address if (family == AF_INET) { if (net[iface].ipv4.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv4 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //? Get IPv6 address else if (family == AF_INET6) { if (net[iface].ipv6.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv6 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //else, ignoring family==AF_LINK (see man 3 getifaddrs) } std::unordered_map> ifstats; int mib[] = {CTL_NET, PF_ROUTE, 0, 0, NET_RT_IFLIST, 0}; size_t len; if (sysctl(mib, 6, nullptr, &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { std::unique_ptr buf(new char[len]); if (sysctl(mib, 6, buf.get(), &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { char *lim = buf.get() + len; char *next = nullptr; for (next = buf.get(); next < lim;) { struct if_msghdr *ifm = (struct if_msghdr *)next; next += ifm->ifm_msglen; struct if_data ifm_data = ifm->ifm_data; if (ifm->ifm_addrs & RTA_IFP) { struct sockaddr_dl *sdl = (struct sockaddr_dl *)(ifm + 1); char iface[32]; strncpy(iface, sdl->sdl_data, sdl->sdl_nlen); iface[sdl->sdl_nlen] = 0; ifstats[iface] = std::tuple(ifm_data.ifi_ibytes, ifm_data.ifi_obytes); } } } } //? Get total received and transmitted bytes + device address if no ip was found for (const auto &iface : interfaces) { for (const string dir : {"download", "upload"}) { auto &saved_stat = net.at(iface).stat.at(dir); auto &bandwidth = net.at(iface).bandwidth.at(dir); uint64_t val = dir == "download" ? std::get<0>(ifstats[iface]) : std::get<1>(ifstats[iface]); //? Update speed, total and top values if (val < saved_stat.last) { saved_stat.rollover += saved_stat.last; saved_stat.last = 0; } if (cmp_greater((unsigned long long)saved_stat.rollover + (unsigned long long)val, numeric_limits::max())) { saved_stat.rollover = 0; saved_stat.last = 0; } saved_stat.speed = round((double)(val - saved_stat.last) / ((double)(new_timestamp - timestamp) / 1000)); if (saved_stat.speed > saved_stat.top) saved_stat.top = saved_stat.speed; if (saved_stat.offset > val + saved_stat.rollover) saved_stat.offset = 0; saved_stat.total = (val + saved_stat.rollover) - saved_stat.offset; saved_stat.last = val; //? Add values to graph bandwidth.push_back(saved_stat.speed); while (cmp_greater(bandwidth.size(), width * 2)) bandwidth.pop_front(); //? Set counters for auto scaling if (net_auto and selected_iface == iface) { if (saved_stat.speed > graph_max[dir]) { ++max_count[dir][0]; if (max_count[dir][1] > 0) --max_count[dir][1]; } else if (graph_max[dir] > 10 << 10 and saved_stat.speed < graph_max[dir] / 10) { ++max_count[dir][1]; if (max_count[dir][0] > 0) --max_count[dir][0]; } } } } //? Clean up net map if needed if (net.size() > interfaces.size()) { for (auto it = net.begin(); it != net.end();) { if (not v_contains(interfaces, it->first)) it = net.erase(it); else it++; } } timestamp = new_timestamp; } //? Return empty net_info struct if no interfaces was found if (net.empty()) return empty_net; //? Find an interface to display if selected isn't set or valid if (selected_iface.empty() or not v_contains(interfaces, selected_iface)) { max_count["download"][0] = max_count["download"][1] = max_count["upload"][0] = max_count["upload"][1] = 0; redraw = true; if (net_auto) rescale = true; if (not config_iface.empty() and v_contains(interfaces, config_iface)) selected_iface = config_iface; else { //? Sort interfaces by total upload + download bytes auto sorted_interfaces = interfaces; rng::sort(sorted_interfaces, [&](const auto &a, const auto &b) { return cmp_greater(net.at(a).stat["download"].total + net.at(a).stat["upload"].total, net.at(b).stat["download"].total + net.at(b).stat["upload"].total); }); selected_iface.clear(); //? Try to set to a connected interface for (const auto &iface : sorted_interfaces) { if (net.at(iface).connected) selected_iface = iface; break; } //? If no interface is connected set to first available if (selected_iface.empty() and not sorted_interfaces.empty()) selected_iface = sorted_interfaces.at(0); else if (sorted_interfaces.empty()) return empty_net; } } //? Calculate max scale for graphs if needed if (net_auto) { bool sync = false; for (const auto &dir : {"download", "upload"}) { for (const auto &sel : {0, 1}) { if (rescale or max_count[dir][sel] >= 5) { const long long avg_speed = (net[selected_iface].bandwidth[dir].size() > 5 ? std::accumulate(net.at(selected_iface).bandwidth.at(dir).rbegin(), net.at(selected_iface).bandwidth.at(dir).rbegin() + 5, 0ll) / 5 : net[selected_iface].stat[dir].speed); graph_max[dir] = max(uint64_t(avg_speed * (sel == 0 ? 1.3 : 3.0)), (uint64_t)10 << 10); max_count[dir][0] = max_count[dir][1] = 0; redraw = true; if (net_sync) sync = true; break; } } //? Sync download/upload graphs if enabled if (sync) { const auto other = (string(dir) == "upload" ? "download" : "upload"); graph_max[other] = graph_max[dir]; max_count[other][0] = max_count[other][1] = 0; break; } } } rescale = false; return net.at(selected_iface); } } // namespace Net namespace Proc { vector current_procs; std::unordered_map uid_user; string current_sort; string current_filter; bool current_rev = false; bool is_tree_mode; fs::file_time_type passwd_time; uint64_t cputimes; int collapse = -1, expand = -1, toggle_children = -1, collapse_all = -1; uint64_t old_cputimes = 0; atomic numpids = 0; int filter_found = 0; detail_container detailed; static std::unordered_set dead_procs; string get_status(char s) { if (s & SRUN) return "Running"; if (s & SSLEEP) return "Sleeping"; if (s & SIDL) return "Idle"; if (s & SSTOP) return "Stopped"; if (s & SZOMB) return "Zombie"; return "Unknown"; } //* Get detailed info for selected process void _collect_details(const size_t pid, vector &procs) { if (pid != detailed.last_pid) { detailed = {}; detailed.last_pid = pid; detailed.skip_smaps = not Config::getB("proc_info_smaps"); } //? Copy proc_info for process from proc vector auto p_info = rng::find(procs, pid, &proc_info::pid); detailed.entry = *p_info; //? Update cpu percent deque for process cpu graph if (not Config::getB("proc_per_core")) detailed.entry.cpu_p *= Shared::coreCount; detailed.cpu_percent.push_back(clamp((long long)round(detailed.entry.cpu_p), 0ll, 100ll)); while (cmp_greater(detailed.cpu_percent.size(), width)) detailed.cpu_percent.pop_front(); //? Process runtime : current time - start time (both in unix time - seconds since epoch) struct timeval currentTime; gettimeofday(¤tTime, nullptr); // only interested in second granularity, so ignoring tc_usec if (detailed.entry.state != 'X') detailed.elapsed = sec_to_dhms(currentTime.tv_sec - detailed.entry.cpu_s); else detailed.elapsed = sec_to_dhms(detailed.entry.death_time); if (detailed.elapsed.size() > 8) detailed.elapsed.resize(detailed.elapsed.size() - 3); //? Get parent process name if (detailed.parent.empty()) { auto p_entry = rng::find(procs, detailed.entry.ppid, &proc_info::pid); if (p_entry != procs.end()) detailed.parent = p_entry->name; } //? Expand process status from single char to explanative string detailed.status = get_status(detailed.entry.state); detailed.mem_bytes.push_back(detailed.entry.mem); detailed.memory = floating_humanizer(detailed.entry.mem); if (detailed.first_mem == -1 or detailed.first_mem < detailed.mem_bytes.back() / 2 or detailed.first_mem > detailed.mem_bytes.back() * 4) { detailed.first_mem = min((uint64_t)detailed.mem_bytes.back() * 2, Mem::get_totalMem()); redraw = true; } while (cmp_greater(detailed.mem_bytes.size(), width)) detailed.mem_bytes.pop_front(); } //* Collects and sorts process information from /proc auto collect(bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); auto per_core = Config::getB("proc_per_core"); auto tree = Config::getB("proc_tree"); auto show_detailed = Config::getB("show_detailed"); const auto pause_proc_list = Config::getB("pause_proc_list"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); bool tree_mode_change = tree != is_tree_mode; if (sorted_change) { current_sort = sorting; current_rev = reverse; } if (tree_mode_change) is_tree_mode = tree; const int cmult = (per_core) ? Shared::coreCount : 1; bool got_detailed = false; static vector found; //* Use pids from last update if only changing filter, sorting or tree options if (no_update and not current_procs.empty()) { if (show_detailed and detailed_pid != detailed.last_pid) _collect_details(detailed_pid, current_procs); } else { //* ---------------------------------------------Collection start---------------------------------------------- should_filter = true; found.clear(); struct timeval currentTime; gettimeofday(¤tTime, nullptr); const double timeNow = currentTime.tv_sec + (currentTime.tv_usec / 1'000'000); int count = 0; char buf[_POSIX2_LINE_MAX]; Shared::KvmPtr kd {kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, buf)}; const struct kinfo_proc* kprocs = kvm_getprocs(kd.get() , KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &count); for (int i = 0; i < count; i++) { const struct kinfo_proc* kproc = &kprocs[i]; const size_t pid = (size_t)kproc->p_pid; if (pid < 1) continue; found.push_back(pid); //? Check if pid already exists in current_procs bool no_cache = false; auto find_old = rng::find(current_procs, pid, &proc_info::pid); //? Only add new processes if not paused if (find_old == current_procs.end()) { if (not pause_proc_list) { current_procs.push_back({pid}); find_old = current_procs.end() - 1; no_cache = true; } else continue; } else if (dead_procs.contains(pid)) continue; auto &new_proc = *find_old; //? Get program name, command, username, parent pid, nice and status if (no_cache) { if (string(kproc->p_comm) == "idle"s) { current_procs.pop_back(); found.pop_back(); continue; } new_proc.name = kproc->p_comm; char** argv = kvm_getargv(kd.get(), kproc, 0); if (argv) { for (int i = 0; argv[i] and cmp_less(new_proc.cmd.size(), 1000); i++) { new_proc.cmd += argv[i] + " "s; } if (not new_proc.cmd.empty()) new_proc.cmd.pop_back(); } if (new_proc.cmd.empty()) new_proc.cmd = new_proc.name; if (new_proc.cmd.size() > 1000) { new_proc.cmd.resize(1000); new_proc.cmd.shrink_to_fit(); } new_proc.ppid = kproc->p_ppid; new_proc.cpu_s = round(kproc->p_ustart_sec); struct passwd *pwd = getpwuid(kproc->p_uid); if (pwd) new_proc.user = pwd->pw_name; } new_proc.p_nice = kproc->p_nice; new_proc.state = kproc->p_stat; int cpu_t = 0; cpu_t = kproc->p_uctime_usec * 1'000'000 + kproc->p_uctime_sec; new_proc.mem = kproc->p_vm_rssize * Shared::pageSize; new_proc.threads = 1; // can't seem to find this in kinfo_proc //? Process cpu usage since last update new_proc.cpu_p = clamp((100.0 * kproc->p_pctcpu / Shared::kfscale) * cmult, 0.0, 100.0 * Shared::coreCount); //? Process cumulative cpu usage since process start new_proc.cpu_c = (double)(cpu_t * Shared::clkTck / 1'000'000) / max(1.0, timeNow - new_proc.cpu_s); //? Update cached value with latest cpu times new_proc.cpu_t = cpu_t; if (show_detailed and not got_detailed and new_proc.pid == detailed_pid) { got_detailed = true; } } //? Clear dead processes from current_procs if not paused if (not pause_proc_list) { auto eraser = rng::remove_if(current_procs, [&](const auto& element) { return not v_contains(found, element.pid); }); current_procs.erase(eraser.begin(), eraser.end()); if (!dead_procs.empty()) dead_procs.clear(); } //? Set correct state of dead processes if paused else { const bool keep_dead_proc_usage = Config::getB("keep_dead_proc_usage"); for (auto& r : current_procs) { if (rng::find(found, r.pid) == found.end()) { if (r.state != 'X') { struct timeval currentTime; gettimeofday(¤tTime, nullptr); r.death_time = currentTime.tv_sec - r.cpu_s; } r.state = 'X'; dead_procs.emplace(r.pid); //? Reset cpu usage for dead processes if paused and option is set if (!keep_dead_proc_usage) { r.cpu_p = 0.0; r.mem = 0; } } } } //? Update the details info box for process if active if (show_detailed and got_detailed) { _collect_details(detailed_pid, current_procs); } else if (show_detailed and not got_detailed and detailed.status != "Dead") { detailed.status = "Dead"; redraw = true; } old_cputimes = cputimes; } //* ---------------------------------------------Collection done----------------------------------------------- //* Match filter if defined if (should_filter) { filter_found = 0; for (auto& p : current_procs) { if (not tree and not filter.empty()) { if (!matches_filter(p, filter)) { p.filtered = true; filter_found++; } else { p.filtered = false; } } else { p.filtered = false; } } } //* Sort processes if ((sorted_change or tree_mode_change) or (not no_update and not pause_proc_list)) { proc_sorter(current_procs, sorting, reverse, tree); } //* Generate tree view if enabled if (tree and (not no_update or should_filter or sorted_change)) { bool locate_selection = false; if (toggle_children != -1) { auto collapser = rng::find(current_procs, toggle_children, &proc_info::pid); if (collapser != current_procs.end()){ for (auto& p : current_procs) { if (p.ppid == collapser->pid) { auto child = rng::find(current_procs, p.pid, &proc_info::pid); if (child != current_procs.end()){ child->collapsed = not child->collapsed; } } } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } toggle_children = -1; } if (auto find_pid = (collapse != -1 ? collapse : expand); find_pid != -1) { auto collapser = rng::find(current_procs, find_pid, &proc_info::pid); if (collapser != current_procs.end()) { if (collapse == expand) { collapser->collapsed = not collapser->collapsed; } else if (collapse > -1) { collapser->collapsed = true; } else if (expand > -1) { collapser->collapsed = false; } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } collapse = expand = -1; } if (collapse_all != -1) { toggle_tree_collapse(current_procs); collapse_all = -1; if (Config::ints.at("proc_selected") > 0) locate_selection = true; } if (should_filter or not filter.empty()) filter_found = 0; vector tree_procs; tree_procs.reserve(current_procs.size()); if (!pause_proc_list) { for (auto& p : current_procs) { if (not v_contains(found, p.ppid)) p.ppid = 0; } } //? Stable sort to retain selected sorting among processes with the same parent rng::stable_sort(current_procs, rng::less{}, & proc_info::ppid); //? Start recursive iteration over processes with the lowest shared parent pids for (auto& p : rng::equal_range(current_procs, current_procs.at(0).ppid, rng::less{}, &proc_info::ppid)) { _tree_gen(p, current_procs, tree_procs, 0, false, filter, false, no_update, should_filter); } //? Recursive sort over tree structure to account for collapsed processes in the tree int index = 0; tree_sort(tree_procs, sorting, reverse, (pause_proc_list and not (sorted_change or tree_mode_change)), index, current_procs.size()); //? Recursive construction of ASCII tree prefixes. for (auto t = tree_procs.begin(); t != tree_procs.end(); ++t) { _collect_prefixes(*t, t == tree_procs.end() - 1); } //? Final sort based on tree index rng::stable_sort(current_procs, rng::less {}, &proc_info::tree_index); //? Move current selection/view to the selected process when collapsing/expanding in the tree if (locate_selection) { int loc = rng::find(current_procs, Proc::selected_pid, &proc_info::pid)->tree_index; if (Config::ints.at("proc_start") >= loc or Config::ints.at("proc_start") <= loc - Proc::select_max) Config::ints.at("proc_start") = max(0, loc - 1); Config::ints.at("proc_selected") = loc - Config::ints.at("proc_start") + 1; } } numpids = (int)current_procs.size() - filter_found; return current_procs; } } // namespace Proc namespace Tools { double system_uptime() { struct timeval ts, currTime; std::size_t len = sizeof(ts); int mib[2] = {CTL_KERN, KERN_BOOTTIME}; if (sysctl(mib, 2, &ts, &len, nullptr, 0) != -1) { gettimeofday(&currTime, nullptr); return currTime.tv_sec - ts.tv_sec; } return 0.0; } } // namespace Tools aristocratos-btop-d43a485/src/openbsd/internal.h000066400000000000000000000165141517514752700217620ustar00rootroot00000000000000/* * Copyright (c) 2019-2021 Brian Callahan * * 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. */ struct sysctls { const char *name; int mib0; int mib1; int mib2; } sysctlnames[] = { { "hw.machine", CTL_HW, HW_MACHINE, 0 }, { "hw.model", CTL_HW, HW_MODEL, 0 }, { "hw.ncpu", CTL_HW, HW_NCPU, 0 }, { "hw.byteorder", CTL_HW, HW_BYTEORDER, 0 }, { "hw.pagesize", CTL_HW, HW_PAGESIZE, 0 }, { "hw.disknames", CTL_HW, HW_DISKNAMES, 0 }, { "hw.diskcount", CTL_HW, HW_DISKCOUNT, 0 }, { "hw.sensors", CTL_HW, HW_SENSORS, 0 }, { "hw.model", CTL_HW, HW_MODEL, 0 }, { "hw.ncpu", CTL_HW, HW_NCPU, 0 }, { "hw.byteorder", CTL_HW, HW_BYTEORDER, 0 }, { "hw.pagesize", CTL_HW, HW_PAGESIZE, 0 }, { "hw.disknames", CTL_HW, HW_DISKNAMES, 0 }, { "hw.diskcount", CTL_HW, HW_DISKCOUNT, 0 }, { "hw.sensors", CTL_HW, HW_SENSORS, 0 }, { "hw.cpuspeed", CTL_HW, HW_CPUSPEED, 0 }, { "hw.setperf", CTL_HW, HW_SETPERF, 0 }, { "hw.vendor", CTL_HW, HW_VENDOR, 0 }, { "hw.product", CTL_HW, HW_PRODUCT, 0 }, { "hw.serialno", CTL_HW, HW_SERIALNO, 0 }, { "hw.uuid", CTL_HW, HW_UUID, 0 }, { "hw.physmem", CTL_HW, HW_PHYSMEM64, 0 }, { "hw.usermem", CTL_HW, HW_USERMEM64, 0 }, { "hw.ncpufound", CTL_HW, HW_NCPUFOUND, 0 }, { "hw.allowpowerdown", CTL_HW, HW_ALLOWPOWERDOWN, 0 }, { "hw.perfpolicy", CTL_HW, HW_PERFPOLICY, 0 }, { "hw.smt", CTL_HW, HW_SMT, 0 }, { "hw.ncpuonline", CTL_HW, HW_NCPUONLINE, 0 }, { "hw.cpuspeed", CTL_HW, HW_CPUSPEED, 0 }, { "hw.setperf", CTL_HW, HW_SETPERF, 0 }, { "hw.vendor", CTL_HW, HW_VENDOR, 0 }, { "hw.product", CTL_HW, HW_PRODUCT, 0 }, { "hw.serialno", CTL_HW, HW_SERIALNO, 0 }, { "hw.uuid", CTL_HW, HW_UUID, 0 }, { "hw.physmem", CTL_HW, HW_PHYSMEM64, 0 }, { "hw.usermem", CTL_HW, HW_USERMEM64, 0 }, { "hw.ncpufound", CTL_HW, HW_NCPUFOUND, 0 }, { "hw.allowpowerdown", CTL_HW, HW_ALLOWPOWERDOWN, 0 }, { "hw.perfpolicy", CTL_HW, HW_PERFPOLICY, 0 }, { "hw.smt", CTL_HW, HW_SMT, 0 }, { "hw.ncpuonline", CTL_HW, HW_NCPUONLINE, 0 }, { "kern.ostype", CTL_KERN, KERN_OSTYPE, 0 }, { "kern.osrelease", CTL_KERN, KERN_OSRELEASE, 0 }, { "kern.osrevision", CTL_KERN, KERN_OSREV, 0 }, { "kern.version", CTL_KERN, KERN_VERSION, 0 }, { "kern.maxvnodes", CTL_KERN, KERN_MAXVNODES, 0 }, { "kern.maxproc", CTL_KERN, KERN_MAXPROC, 0 }, { "kern.maxfiles", CTL_KERN, KERN_MAXFILES, 0 }, { "kern.argmax", CTL_KERN, KERN_ARGMAX, 0 }, { "kern.securelevel", CTL_KERN, KERN_SECURELVL, 0 }, { "kern.hostname", CTL_KERN, KERN_HOSTNAME, 0 }, { "kern.hostid", CTL_KERN, KERN_HOSTID, 0 }, { "kern.clockrate", CTL_KERN, KERN_CLOCKRATE, 0 }, { "kern.profiling", CTL_KERN, KERN_PROF, 0 }, { "kern.posix1version", CTL_KERN, KERN_POSIX1, 0 }, { "kern.ngroups", CTL_KERN, KERN_NGROUPS, 0 }, { "kern.job_control", CTL_KERN, KERN_JOB_CONTROL, 0 }, { "kern.saved_ids", CTL_KERN, KERN_SAVED_IDS, 0 }, { "kern.boottime", CTL_KERN, KERN_BOOTTIME, 0 }, { "kern.domainname", CTL_KERN, KERN_DOMAINNAME, 0 }, { "kern.maxpartitions", CTL_KERN, KERN_MAXPARTITIONS, 0 }, { "kern.rawpartition", CTL_KERN, KERN_RAWPARTITION, 0 }, { "kern.maxthread", CTL_KERN, KERN_MAXTHREAD, 0 }, { "kern.nthreads", CTL_KERN, KERN_NTHREADS, 0 }, { "kern.osversion", CTL_KERN, KERN_OSVERSION, 0 }, { "kern.somaxconn", CTL_KERN, KERN_SOMAXCONN, 0 }, { "kern.sominconn", CTL_KERN, KERN_SOMINCONN, 0 }, { "kern.nosuidcoredump", CTL_KERN, KERN_NOSUIDCOREDUMP, 0 }, { "kern.fsync", CTL_KERN, KERN_FSYNC, 0 }, { "kern.sysvmsg", CTL_KERN, KERN_SYSVMSG, 0 }, { "kern.sysvsem", CTL_KERN, KERN_SYSVSEM, 0 }, { "kern.sysvshm", CTL_KERN, KERN_SYSVSHM, 0 }, { "kern.msgbufsize", CTL_KERN, KERN_MSGBUFSIZE, 0 }, { "kern.malloc", CTL_KERN, KERN_MALLOCSTATS, 0 }, { "kern.cp_time", CTL_KERN, KERN_CPTIME, 0 }, { "kern.nchstats", CTL_KERN, KERN_NCHSTATS, 0 }, { "kern.forkstat", CTL_KERN, KERN_FORKSTAT, 0 }, { "kern.tty", CTL_KERN, KERN_TTY, 0 }, { "kern.ccpu", CTL_KERN, KERN_CCPU, 0 }, { "kern.fscale", CTL_KERN, KERN_FSCALE, 0 }, { "kern.nprocs", CTL_KERN, KERN_NPROCS, 0 }, { "kern.msgbuf", CTL_KERN, KERN_MSGBUF, 0 }, { "kern.pool", CTL_KERN, KERN_POOL, 0 }, { "kern.stackgap_random", CTL_KERN, KERN_STACKGAPRANDOM, 0 }, { "kern.sysvipc_info", CTL_KERN, KERN_SYSVIPC_INFO, 0 }, { "kern.allowkmem", CTL_KERN, KERN_ALLOWKMEM, 0 }, { "kern.witnesswatch", CTL_KERN, KERN_WITNESSWATCH, 0 }, { "kern.splassert", CTL_KERN, KERN_SPLASSERT, 0 }, { "kern.procargs", CTL_KERN, KERN_PROC_ARGS, 0 }, { "kern.nfiles", CTL_KERN, KERN_NFILES, 0 }, { "kern.ttycount", CTL_KERN, KERN_TTYCOUNT, 0 }, { "kern.numvnodes", CTL_KERN, KERN_NUMVNODES, 0 }, { "kern.mbstat", CTL_KERN, KERN_MBSTAT, 0 }, { "kern.witness", CTL_KERN, KERN_WITNESS, 0 }, { "kern.seminfo", CTL_KERN, KERN_SEMINFO, 0 }, { "kern.shminfo", CTL_KERN, KERN_SHMINFO, 0 }, { "kern.intrcnt", CTL_KERN, KERN_INTRCNT, 0 }, { "kern.watchdog", CTL_KERN, KERN_WATCHDOG, 0 }, { "kern.proc", CTL_KERN, KERN_PROC, 0 }, { "kern.maxclusters", CTL_KERN, KERN_MAXCLUSTERS, 0 }, { "kern.evcount", CTL_KERN, KERN_EVCOUNT, 0 }, { "kern.timecounter", CTL_KERN, KERN_TIMECOUNTER, 0 }, { "kern.maxlocksperuid", CTL_KERN, KERN_MAXLOCKSPERUID, 0 }, { "kern.cp_time2", CTL_KERN, KERN_CPTIME2, 0 }, { "kern.bufcachepercent", CTL_KERN, KERN_CACHEPCT, 0 }, { "kern.file", CTL_KERN, KERN_FILE, 0 }, { "kern.wxabort", CTL_KERN, KERN_WXABORT, 0 }, { "kern.consdev", CTL_KERN, KERN_CONSDEV, 0 }, { "kern.netlivelocks", CTL_KERN, KERN_NETLIVELOCKS, 0 }, { "kern.pool_debug", CTL_KERN, KERN_POOL_DEBUG, 0 }, { "kern.proc_cwd", CTL_KERN, KERN_PROC_CWD, 0 }, { "kern.proc_nobroadcastkill", CTL_KERN, KERN_PROC_NOBROADCASTKILL, 0 }, { "kern.proc_vmap", CTL_KERN, KERN_PROC_VMMAP, 0 }, { "kern.global_ptrace", CTL_KERN, KERN_GLOBAL_PTRACE, 0 }, { "kern.consbufsize", CTL_KERN, KERN_CONSBUFSIZE, 0 }, { "kern.consbuf", CTL_KERN, KERN_CONSBUF, 0 }, { "kern.audio", CTL_KERN, KERN_AUDIO, 0 }, { "kern.cpustats", CTL_KERN, KERN_CPUSTATS, 0 }, { "kern.pfstatus", CTL_KERN, KERN_PFSTATUS, 0 }, { "kern.timeout_stats", CTL_KERN, KERN_TIMEOUT_STATS, 0 }, { "kern.utc_offset", CTL_KERN, KERN_UTC_OFFSET, 0 }, { "vm.vmmeter", CTL_VM, VM_METER, 0 }, { "vm.loadavg", CTL_VM, VM_LOADAVG, 0 }, { "vm.psstrings", CTL_VM, VM_PSSTRINGS, 0 }, { "vm.uvmexp", CTL_VM, VM_UVMEXP, 0 }, { "vm.swapencrypt", CTL_VM, VM_SWAPENCRYPT, 0 }, { "vm.nkmempages", CTL_VM, VM_NKMEMPAGES, 0 }, { "vm.anonmin", CTL_VM, VM_ANONMIN, 0 }, { "vm.vtextmin", CTL_VM, VM_VTEXTMIN, 0 }, { "vm.vnodemin", CTL_VM, VM_VNODEMIN, 0 }, { "vm.maxslp", CTL_VM, VM_MAXSLP, 0 }, { "vm.uspace", CTL_VM, VM_USPACE, 0 }, { "vm.malloc_conf", CTL_VM, VM_MALLOC_CONF, 0 }, { NULL, 0, 0, 0 }, }; aristocratos-btop-d43a485/src/openbsd/sysctlbyname.cpp000066400000000000000000000025501517514752700232110ustar00rootroot00000000000000/* * Copyright (c) 2019-2021 Brian Callahan * * 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 #include #include #include #include #include "internal.h" #include "../btop_tools.hpp" int sysctlbyname(const char *name, void *oldp, size_t *oldlenp, void *newp, size_t newlen) { int i, mib[2]; for (i = 0; i < 132; i++) { // for (i = 0; i < sizeof(sysctlnames) / sizeof(sysctlnames[0]); i++) { if (!strcmp(name, sysctlnames[i].name)) { mib[0] = sysctlnames[i].mib0; mib[1] = sysctlnames[i].mib1; return sysctl(mib, 2, oldp, oldlenp, newp, newlen); } } errno = ENOENT; return (-1); } aristocratos-btop-d43a485/src/openbsd/sysctlbyname.h000066400000000000000000000016251517514752700226600ustar00rootroot00000000000000/* * Copyright (c) 2019 Brian Callahan * * 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 #include extern int sysctlbyname(const char *, void *, size_t *, void *, size_t); aristocratos-btop-d43a485/src/osx/000077500000000000000000000000001517514752700171455ustar00rootroot00000000000000aristocratos-btop-d43a485/src/osx/btop_collect.cpp000066400000000000000000002154671517514752700223410ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #include #include #include #include #include #include #include #include #include #include // BUGS // If both and are being included, must be // included before . // from: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/getifaddrs.3.html #include #include #include #include #include #include #include #include #include #include #include // for inet_ntop #include #include #include #include #include #include #include #include #include #include #include #include #include "../btop_config.hpp" #include "../btop_log.hpp" #include "../btop_shared.hpp" #include "../btop_tools.hpp" #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 #include "sensors.hpp" #endif #include "smc.hpp" #if defined(GPU_SUPPORT) #include #include //? IOReport C function declarations for Apple Silicon GPU metrics extern "C" { typedef struct IOReportSubscription* IOReportSubscriptionRef; CFDictionaryRef IOReportCopyChannelsInGroup(CFStringRef group, CFStringRef subgroup, uint64_t a, uint64_t b, uint64_t c); void IOReportMergeChannels(CFDictionaryRef a, CFDictionaryRef b, CFTypeRef cfnull); IOReportSubscriptionRef IOReportCreateSubscription(void* a, CFMutableDictionaryRef b, CFMutableDictionaryRef* c, uint64_t d, CFTypeRef cfnull); CFDictionaryRef IOReportCreateSamples(IOReportSubscriptionRef sub, CFMutableDictionaryRef chan, CFTypeRef cfnull); CFDictionaryRef IOReportCreateSamplesDelta(CFDictionaryRef a, CFDictionaryRef b, CFTypeRef cfnull); CFStringRef IOReportChannelGetGroup(CFDictionaryRef item); CFStringRef IOReportChannelGetSubGroup(CFDictionaryRef item); CFStringRef IOReportChannelGetChannelName(CFDictionaryRef item); int64_t IOReportSimpleGetIntegerValue(CFDictionaryRef item, int32_t idx); CFStringRef IOReportChannelGetUnitLabel(CFDictionaryRef item); int32_t IOReportStateGetCount(CFDictionaryRef item); CFStringRef IOReportStateGetNameForIndex(CFDictionaryRef item, int32_t idx); int64_t IOReportStateGetResidency(CFDictionaryRef item, int32_t idx); //? IOHIDEvent declarations for GPU temperature typedef struct __IOHIDEvent* IOHIDEventRef; typedef struct __IOHIDServiceClient* IOHIDServiceClientRef; typedef struct __IOHIDEventSystemClient* IOHIDEventSystemClientRef; #ifdef __LP64__ typedef double IOHIDFloat; #else typedef float IOHIDFloat; #endif IOHIDEventSystemClientRef IOHIDEventSystemClientCreate(CFAllocatorRef allocator); int IOHIDEventSystemClientSetMatching(IOHIDEventSystemClientRef client, CFDictionaryRef match); CFArrayRef IOHIDEventSystemClientCopyServices(IOHIDEventSystemClientRef client); IOHIDEventRef IOHIDServiceClientCopyEvent(IOHIDServiceClientRef sc, int64_t type, int32_t a, int64_t b); CFStringRef IOHIDServiceClientCopyProperty(IOHIDServiceClientRef service, CFStringRef property); IOHIDFloat IOHIDEventGetFloatValue(IOHIDEventRef event, int32_t field); } #endif // GPU_SUPPORT #if __MAC_OS_X_VERSION_MIN_REQUIRED < 120000 #define kIOMainPortDefault kIOMasterPortDefault #endif using std::clamp, std::string_literals::operator""s, std::cmp_equal, std::cmp_less, std::cmp_greater; using std::ifstream, std::numeric_limits, std::streamsize, std::round, std::max, std::min; namespace fs = std::filesystem; namespace rng = std::ranges; using namespace Tools; //? RAII wrapper for CoreFoundation types โ€” releases via CFRelease() on destruction template struct CFRef { T ref; CFRef() : ref(nullptr) {} CFRef(T ref) : ref(ref) {} ~CFRef() { if (ref) CFRelease((CFTypeRef)ref); } CFRef(const CFRef&) = delete; CFRef& operator=(const CFRef&) = delete; CFRef(CFRef&& other) noexcept : ref(other.ref) { other.ref = nullptr; } CFRef& operator=(CFRef&& other) noexcept { if (this != &other) { reset(); ref = other.ref; other.ref = nullptr; } return *this; } operator T() const { return ref; } T get() const { return ref; } T* ptr() { return &ref; } void reset(T new_ref = nullptr) { if (ref) CFRelease((CFTypeRef)ref); ref = new_ref; } T release() { T r = ref; ref = nullptr; return r; } }; //? RAII wrapper for IOKit object types โ€” releases via IOObjectRelease() on destruction struct IORef { io_object_t ref; IORef() : ref(0) {} IORef(io_object_t ref) : ref(ref) {} ~IORef() { if (ref) IOObjectRelease(ref); } IORef(const IORef&) = delete; IORef& operator=(const IORef&) = delete; operator io_object_t() const { return ref; } io_object_t get() const { return ref; } io_object_t* ptr() { return &ref; } }; //? --------------------------------------------------- FUNCTIONS ----------------------------------------------------- namespace Cpu { vector core_old_totals; vector core_old_idles; vector available_fields = {"Auto", "total"}; vector available_sensors = {"Auto"}; cpu_info current_cpu; bool got_sensors = false, cpu_temp_only = false, supports_watts = false; int core_offset = 0; //* Populate found_sensors map bool get_sensors(); //* Get current cpu clock speed string get_cpuHz(); //* Search /proc/cpuinfo for a cpu name string get_cpuName(); struct Sensor { fs::path path; string label; int64_t temp = 0; int64_t high = 0; int64_t crit = 0; }; string cpu_sensor; vector core_sensors; std::unordered_map core_mapping; } // namespace Cpu namespace Mem { double old_uptime; } #if defined(GPU_SUPPORT) namespace Gpu { vector gpus; //? Stub shutdown for backends not available on macOS namespace Nvml { bool shutdown() { return false; } } namespace Rsmi { bool shutdown() { return false; } } //? Apple Silicon GPU data collection via IOReport namespace AppleSilicon { bool initialized = false; unsigned int device_count = 0; //? Forward declaration template bool collect(gpu_info* gpus_slice); //? IOReport subscription state IOReportSubscriptionRef ior_sub = nullptr; CFMutableDictionaryRef ior_chan = nullptr; CFDictionaryRef prev_sample = nullptr; uint64_t prev_sample_time = 0; //? GPU frequency table from DVFS vector gpu_freqs; static string cfstring_to_string(CFStringRef cfstr) { if (not cfstr) return ""; char buf[256]; if (CFStringGetCString(cfstr, buf, sizeof(buf), kCFStringEncodingUTF8)) return string(buf); return ""; } static string get_chip_name() { char buf[256]; size_t size = sizeof(buf); if (sysctlbyname("machdep.cpu.brand_string", buf, &size, nullptr, 0) == 0) return string(buf); return "Apple Silicon GPU"; } static uint64_t get_mach_time_ms() { static mach_timebase_info_data_t timebase = {0, 0}; if (timebase.denom == 0) mach_timebase_info(&timebase); return (mach_absolute_time() * timebase.numer / timebase.denom) / 1000000; } //? Read GPU DVFS frequency table from IORegistry pmgr node static void get_gpu_freqs_from_pmgr() { io_iterator_t iter_raw; //? matchDict ownership is consumed by IOServiceGetMatchingServices CFMutableDictionaryRef matchDict = IOServiceMatching("AppleARMIODevice"); if (IOServiceGetMatchingServices(kIOMainPortDefault, matchDict, &iter_raw) != kIOReturnSuccess) return; IORef iter(iter_raw); io_object_t entry_raw; while ((entry_raw = IOIteratorNext(iter)) != 0) { IORef entry(entry_raw); char name[128]; if (IORegistryEntryGetName(entry, name) == kIOReturnSuccess and string(name) == "pmgr") { CFMutableDictionaryRef props_raw = nullptr; if (IORegistryEntryCreateCFProperties(entry, &props_raw, kCFAllocatorDefault, 0) == kIOReturnSuccess and props_raw) { CFRef props(props_raw); CFDataRef dvfs_data = (CFDataRef)CFDictionaryGetValue(props, CFSTR("voltage-states9")); if (dvfs_data) { auto len = CFDataGetLength(dvfs_data); auto ptr = CFDataGetBytePtr(dvfs_data); //? Pairs of (freq, voltage), 4 bytes each for (CFIndex i = 0; i + 7 < len; i += 8) { uint32_t freq = 0; memcpy(&freq, ptr + i, 4); if (freq > 0) gpu_freqs.push_back(freq / (1000 * 1000)); // Hz -> MHz } } } } } } bool init() { if (initialized) return false; //? Get GPU frequency table get_gpu_freqs_from_pmgr(); //? Set up IOReport channels for GPU Stats and Energy Model CFRef gpu_stats_group(CFStringCreateWithCString(kCFAllocatorDefault, "GPU Stats", kCFStringEncodingUTF8)); CFRef gpu_perf_subgroup(CFStringCreateWithCString(kCFAllocatorDefault, "GPU Performance States", kCFStringEncodingUTF8)); CFRef energy_group(CFStringCreateWithCString(kCFAllocatorDefault, "Energy Model", kCFStringEncodingUTF8)); CFRef gpu_chan(IOReportCopyChannelsInGroup(gpu_stats_group, gpu_perf_subgroup, 0, 0, 0)); CFRef energy_chan(IOReportCopyChannelsInGroup(energy_group, nullptr, 0, 0, 0)); if (not gpu_chan.get() and not energy_chan.get()) { Logger::info("Apple Silicon GPU: No IOReport channels found, GPU monitoring unavailable"); return false; } //? Merge channels into a single subscription if (gpu_chan.get() and energy_chan.get()) { IOReportMergeChannels(gpu_chan, energy_chan, nullptr); } CFDictionaryRef base_chan = gpu_chan.get() ? gpu_chan.get() : energy_chan.get(); auto size = CFDictionaryGetCount(base_chan); ior_chan = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, size, base_chan); //? Create IOReport subscription CFMutableDictionaryRef sub_dict = nullptr; ior_sub = IOReportCreateSubscription(nullptr, ior_chan, &sub_dict, 0, nullptr); if (not ior_sub) { Logger::warning("Apple Silicon GPU: Failed to create IOReport subscription"); CFRelease(ior_chan); ior_chan = nullptr; return false; } device_count = 1; //? Apple Silicon has one integrated GPU gpus.resize(gpus.size() + device_count); gpu_names.resize(gpu_names.size() + device_count); initialized = true; //? Take initial sample for delta computation prev_sample = IOReportCreateSamples(ior_sub, ior_chan, nullptr); prev_sample_time = get_mach_time_ms(); //? Run init collect to populate names and supported functions collect<1>(gpus.data()); return true; } bool shutdown() { if (not initialized) return false; if (prev_sample) { CFRelease(prev_sample); prev_sample = nullptr; } if (ior_chan) { CFRelease(ior_chan); ior_chan = nullptr; } if (ior_sub) { CFRelease((CFTypeRef)ior_sub); ior_sub = nullptr; } initialized = false; return true; } //? Read GPU temperature via IOHIDEventSystem thermal sensors static long long get_gpu_temp_iohid() { #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 constexpr int kHIDPage_AppleVendor = 0xff00; constexpr int kHIDUsage_TemperatureSensor = 5; constexpr int64_t kIOHIDEventTypeTemperature = 15; CFStringRef keys[2] = { CFSTR("PrimaryUsagePage"), CFSTR("PrimaryUsage") }; int page = kHIDPage_AppleVendor, usage = kHIDUsage_TemperatureSensor; CFRef num0(CFNumberCreate(nullptr, kCFNumberSInt32Type, &page)); CFRef num1(CFNumberCreate(nullptr, kCFNumberSInt32Type, &usage)); const void* values[] = { num0.get(), num1.get() }; CFRef match(CFDictionaryCreate(nullptr, (const void**)keys, values, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); CFRef system(IOHIDEventSystemClientCreate(kCFAllocatorDefault)); if (not system.get()) return -1; IOHIDEventSystemClientSetMatching(system, match); CFRef services(IOHIDEventSystemClientCopyServices(system)); if (not services.get()) return -1; double gpu_temp_sum = 0; int gpu_temp_count = 0; long count = CFArrayGetCount(services); for (long i = 0; i < count; i++) { auto sc = (IOHIDServiceClientRef)CFArrayGetValueAtIndex(services, i); if (not sc) continue; CFRef name(IOHIDServiceClientCopyProperty(sc, CFSTR("Product"))); if (not name.get()) continue; char buf[200]; CFStringGetCString(name, buf, 200, kCFStringEncodingASCII); string n(buf); //? Legacy Apple Silicon uses "GPU MTR Temp Sensor*" names. //? On newer Apple Silicon we can see PMU TP*g sensors for GPU temperatures. bool is_gpu_sensor = n.find("GPU") != string::npos; if (not is_gpu_sensor and n.rfind("PMU TP", 0) == 0 and not n.empty() and n.back() == 'g') { is_gpu_sensor = true; } if (is_gpu_sensor) { CFRef event(IOHIDServiceClientCopyEvent(sc, kIOHIDEventTypeTemperature, 0, 0)); if (event.get()) { double temp = IOHIDEventGetFloatValue(event, kIOHIDEventTypeTemperature << 16); if (temp > 0 and temp < 150) { gpu_temp_sum += temp; gpu_temp_count++; } } } } if (gpu_temp_count > 0) return static_cast(round(gpu_temp_sum / gpu_temp_count)); #endif return -1; } template bool collect(gpu_info* gpus_slice) { if (not initialized) return false; if constexpr (is_init) { //? Device name string chip = get_chip_name(); gpu_names[0] = chip + " GPU"; //? Power max (typical Apple Silicon GPU TDP ~15-20W) gpus_slice[0].pwr_max_usage = 20000; // 20W in mW gpu_pwr_total_max += gpus_slice[0].pwr_max_usage; //? Temperature max gpus_slice[0].temp_max = 110; //? Memory total (unified memory architecture โ€” GPU shares system RAM) int64_t memsize = 0; size_t size = sizeof(memsize); if (sysctlbyname("hw.memsize", &memsize, &size, nullptr, 0) == 0) gpus_slice[0].mem_total = memsize; //? Supported functions gpus_slice[0].supported_functions = { .gpu_utilization = true, .mem_utilization = true, .gpu_clock = not gpu_freqs.empty(), .mem_clock = false, .pwr_usage = true, .pwr_state = false, .temp_info = true, .mem_total = true, .mem_used = true, .pcie_txrx = false, .encoder_utilization = false, .decoder_utilization = false }; } //? Take new IOReport sample and compute delta CFDictionaryRef cur_sample = IOReportCreateSamples(ior_sub, ior_chan, nullptr); if (not cur_sample) return false; uint64_t cur_time = get_mach_time_ms(); uint64_t dt = cur_time - prev_sample_time; if (dt == 0) dt = 1; CFRef delta; if (prev_sample) { delta.reset(IOReportCreateSamplesDelta(prev_sample, cur_sample, nullptr)); CFRelease(prev_sample); } prev_sample = cur_sample; prev_sample_time = cur_time; if (not delta.get()) return false; //? Parse delta samples CFArrayRef channels = (CFArrayRef)CFDictionaryGetValue(delta, CFSTR("IOReportChannels")); if (not channels) return false; long long gpu_utilization = 0; bool got_gpu_util = false; double gpu_power_watts = 0; bool got_gpu_power = false; long chan_count = CFArrayGetCount(channels); for (long i = 0; i < chan_count; i++) { CFDictionaryRef item = (CFDictionaryRef)CFArrayGetValueAtIndex(channels, i); if (not item) continue; string group = cfstring_to_string(IOReportChannelGetGroup(item)); string subgroup = cfstring_to_string(IOReportChannelGetSubGroup(item)); string channel = cfstring_to_string(IOReportChannelGetChannelName(item)); //? GPU utilization from residency states if (group == "GPU Stats" and subgroup == "GPU Performance States" and channel == "GPUPH") { int32_t state_count = IOReportStateGetCount(item); if (state_count <= 0) continue; int64_t total_residency = 0; int64_t active_residency = 0; double weighted_freq = 0; //? Find offset past IDLE/OFF/DOWN states int offset = 0; for (int32_t s = 0; s < state_count; s++) { string name = cfstring_to_string(IOReportStateGetNameForIndex(item, s)); if (name == "IDLE" or name == "OFF" or name == "DOWN") offset = s + 1; total_residency += IOReportStateGetResidency(item, s); } int freq_count = static_cast(gpu_freqs.size()); for (int32_t s = offset; s < state_count; s++) { int64_t res = IOReportStateGetResidency(item, s); active_residency += res; int freq_idx = s - offset; if (freq_idx < freq_count and active_residency > 0) weighted_freq += static_cast(res) * gpu_freqs[freq_idx]; } if (total_residency > 0) { double usage_ratio = static_cast(active_residency) / static_cast(total_residency); gpu_utilization = clamp(static_cast(round(usage_ratio * 100.0)), 0ll, 100ll); got_gpu_util = true; //? Calculate average frequency if (active_residency > 0 and not gpu_freqs.empty()) { double avg_freq = weighted_freq / static_cast(active_residency); gpus_slice[0].gpu_clock_speed = static_cast(round(avg_freq)); } } } //? GPU power from Energy Model if (group == "Energy Model" and channel == "GPU Energy") { string unit = cfstring_to_string(IOReportChannelGetUnitLabel(item)); int64_t val = IOReportSimpleGetIntegerValue(item, 0); double energy = static_cast(val); double divisor = static_cast(dt) / 1000.0; // dt is in ms if (unit.find("nJ") != string::npos) energy /= 1e9; else if (unit.find("uJ") != string::npos or unit.find("\xc2\xb5J") != string::npos) energy /= 1e6; else if (unit.find("mJ") != string::npos) energy /= 1e3; //? energy is now in Joules if (divisor > 0) { gpu_power_watts = energy / divisor; got_gpu_power = true; } } } //? Store GPU utilization if (got_gpu_util) { gpus_slice[0].gpu_percent.at("gpu-totals").push_back(gpu_utilization); gpus_slice[0].mem_utilization_percent.push_back(gpu_utilization); } //? Store power usage (convert W to mW) if (got_gpu_power) { gpus_slice[0].pwr_usage = static_cast(round(gpu_power_watts * 1000.0)); if (gpus_slice[0].pwr_usage > gpus_slice[0].pwr_max_usage) gpus_slice[0].pwr_max_usage = gpus_slice[0].pwr_usage; gpus_slice[0].gpu_percent.at("gpu-pwr-totals").push_back( clamp(static_cast(round(static_cast(gpus_slice[0].pwr_usage) * 100.0 / static_cast(gpus_slice[0].pwr_max_usage))), 0ll, 100ll)); } //? GPU temperature if (gpus_slice[0].supported_functions.temp_info and Config::getB("check_temp")) { long long temp = get_gpu_temp_iohid(); if (temp > 0) gpus_slice[0].temp.push_back(temp); } //? Memory usage (unified memory โ€” report system memory usage) if (gpus_slice[0].supported_functions.mem_total) { vm_size_t page_size; mach_port_t mach_port = mach_host_self(); vm_statistics64_data_t vm_stats; mach_msg_type_number_t count = sizeof(vm_stats) / sizeof(natural_t); host_page_size(mach_port, &page_size); if (host_statistics64(mach_port, HOST_VM_INFO64, (host_info64_t)&vm_stats, &count) == KERN_SUCCESS) { long long used = (static_cast(vm_stats.active_count) + static_cast(vm_stats.inactive_count) + static_cast(vm_stats.wire_count) + static_cast(vm_stats.speculative_count) + static_cast(vm_stats.compressor_page_count) - static_cast(vm_stats.purgeable_count) - static_cast(vm_stats.external_page_count)) * static_cast(page_size); if (used < 0) used = 0; gpus_slice[0].mem_used = used; if (gpus_slice[0].mem_total > 0) { auto used_pct = static_cast(round(static_cast(used) * 100.0 / static_cast(gpus_slice[0].mem_total))); gpus_slice[0].gpu_percent.at("gpu-vram-totals").push_back(clamp(used_pct, 0ll, 100ll)); } } } return true; } //? Explicit template instantiations template bool collect(gpu_info*); template bool collect(gpu_info*); } // namespace AppleSilicon //? Collect data from Apple Silicon GPU auto collect(bool no_update) -> vector& { if (Runner::stopping or (no_update and not gpus.empty())) return gpus; AppleSilicon::collect<0>(gpus.data()); //* Calculate averages long long avg = 0; long long mem_usage_total = 0; long long mem_total = 0; long long pwr_total = 0; for (auto& gpu : gpus) { if (gpu.supported_functions.gpu_utilization and not gpu.gpu_percent.at("gpu-totals").empty()) avg += gpu.gpu_percent.at("gpu-totals").back(); if (gpu.supported_functions.mem_used) mem_usage_total += gpu.mem_used; if (gpu.supported_functions.mem_total) mem_total += gpu.mem_total; if (gpu.supported_functions.pwr_usage) pwr_total += gpu.pwr_usage; //* Trim vectors if there are more values than needed for graphs if (width != 0) { while (cmp_greater(gpu.gpu_percent.at("gpu-totals").size(), width * 2)) gpu.gpu_percent.at("gpu-totals").pop_front(); while (cmp_greater(gpu.mem_utilization_percent.size(), width)) gpu.mem_utilization_percent.pop_front(); while (cmp_greater(gpu.gpu_percent.at("gpu-pwr-totals").size(), width)) gpu.gpu_percent.at("gpu-pwr-totals").pop_front(); while (cmp_greater(gpu.temp.size(), 18)) gpu.temp.pop_front(); while (cmp_greater(gpu.gpu_percent.at("gpu-vram-totals").size(), width/2)) gpu.gpu_percent.at("gpu-vram-totals").pop_front(); } } if (not gpus.empty()) { shared_gpu_percent.at("gpu-average").push_back(avg / static_cast(gpus.size())); if (mem_total != 0) shared_gpu_percent.at("gpu-vram-total").push_back(mem_usage_total * 100 / mem_total); if (gpu_pwr_total_max != 0) shared_gpu_percent.at("gpu-pwr-total").push_back(pwr_total * 100 / gpu_pwr_total_max); } if (width != 0) { while (cmp_greater(shared_gpu_percent.at("gpu-average").size(), width * 2)) shared_gpu_percent.at("gpu-average").pop_front(); while (cmp_greater(shared_gpu_percent.at("gpu-vram-total").size(), width)) shared_gpu_percent.at("gpu-vram-total").pop_front(); while (cmp_greater(shared_gpu_percent.at("gpu-pwr-total").size(), width)) shared_gpu_percent.at("gpu-pwr-total").pop_front(); } return gpus; } } // namespace Gpu #endif // GPU_SUPPORT class MachProcessorInfo { public: processor_info_array_t info_array; mach_msg_type_number_t info_count; MachProcessorInfo() {} virtual ~MachProcessorInfo() {vm_deallocate(mach_task_self(), (vm_address_t)info_array, (vm_size_t)sizeof(processor_info_array_t) * info_count);} }; namespace Shared { fs::path passwd_path; uint64_t totalMem; long pageSize, coreCount, clkTck, physicalCoreCount, arg_max; double machTck; int totalMem_len; void init() { //? Shared global variables init coreCount = sysconf(_SC_NPROCESSORS_ONLN); // this returns all logical cores (threads) if (coreCount < 1) { coreCount = 1; Logger::warning("Could not determine number of cores, defaulting to 1."); } size_t physicalCoreCountSize = sizeof(physicalCoreCount); if (sysctlbyname("hw.physicalcpu", &physicalCoreCount, &physicalCoreCountSize, nullptr, 0) < 0) { Logger::error("Could not get physical core count"); } pageSize = sysconf(_SC_PAGE_SIZE); if (pageSize <= 0) { pageSize = 4096; Logger::warning("Could not get system page size. Defaulting to 4096, processes memory usage might be incorrect."); } mach_timebase_info_data_t convf; if (mach_timebase_info(&convf) == KERN_SUCCESS) { machTck = convf.numer / convf.denom; } else { Logger::warning("Could not get mach clock tick conversion factor. Defaulting to 100, processes cpu usage might be incorrect."); machTck = 100; } clkTck = sysconf(_SC_CLK_TCK); if (clkTck <= 0) { clkTck = 100; Logger::warning("Could not get system clock ticks per second. Defaulting to 100, processes cpu usage might be incorrect."); } int64_t memsize = 0; size_t size = sizeof(memsize); if (sysctlbyname("hw.memsize", &memsize, &size, nullptr, 0) < 0) { Logger::warning("Could not get memory size"); } totalMem = memsize; //* Get maximum length of process arguments arg_max = sysconf(_SC_ARG_MAX); //? Init for namespace Cpu Cpu::current_cpu.core_percent.insert(Cpu::current_cpu.core_percent.begin(), Shared::coreCount, {}); Cpu::current_cpu.temp.insert(Cpu::current_cpu.temp.begin(), Shared::coreCount + 1, {}); Cpu::core_old_totals.insert(Cpu::core_old_totals.begin(), Shared::coreCount, 0); Cpu::core_old_idles.insert(Cpu::core_old_idles.begin(), Shared::coreCount, 0); Cpu::collect(); for (auto &[field, vec] : Cpu::current_cpu.cpu_percent) { if (not vec.empty() and not v_contains(Cpu::available_fields, field)) Cpu::available_fields.push_back(field); } Cpu::cpuName = Cpu::get_cpuName(); Cpu::got_sensors = Cpu::get_sensors(); Cpu::core_mapping = Cpu::get_core_mapping(); //? Init for namespace Gpu #ifdef GPU_SUPPORT auto shown_gpus = Config::getS("shown_gpus"); if (shown_gpus.contains("apple")) { Gpu::AppleSilicon::init(); } if (not Gpu::gpu_names.empty()) { for (auto const& [key, _] : Gpu::gpus[0].gpu_percent) Cpu::available_fields.push_back(key); for (auto const& [key, _] : Gpu::shared_gpu_percent) Cpu::available_fields.push_back(key); using namespace Gpu; count = gpus.size(); gpu_b_height_offsets.resize(gpus.size()); for (size_t i = 0; i < gpu_b_height_offsets.size(); ++i) gpu_b_height_offsets[i] = gpus[i].supported_functions.gpu_utilization + gpus[i].supported_functions.pwr_usage + (gpus[i].supported_functions.encoder_utilization or gpus[i].supported_functions.decoder_utilization) + (gpus[i].supported_functions.mem_total or gpus[i].supported_functions.mem_used) * (1 + 2*(gpus[i].supported_functions.mem_total and gpus[i].supported_functions.mem_used) + 2*gpus[i].supported_functions.mem_utilization); } #endif //? Init for namespace Mem Mem::old_uptime = system_uptime(); Mem::collect(); } } // namespace Shared namespace Cpu { string cpuName; string cpuHz; bool has_battery = true; bool macM1 = false; tuple current_bat; const array time_names = {"user", "nice", "system", "idle"}; std::unordered_map cpu_old = { {"totals", 0}, {"idles", 0}, {"user", 0}, {"nice", 0}, {"system", 0}, {"idle", 0} }; string get_cpuName() { string name; char buffer[1024]; size_t size = sizeof(buffer); if (sysctlbyname("machdep.cpu.brand_string", &buffer, &size, nullptr, 0) < 0) { Logger::error("Failed to get CPU name"); return name; } return trim_name(string(buffer)); } bool get_sensors() { Logger::debug("get_sensors(): show_coretemp={} check_temp={}", Config::getB("show_coretemp"), Config::getB("check_temp")); got_sensors = false; if (Config::getB("show_coretemp") and Config::getB("check_temp")) { #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 ThermalSensors sensors; std::vector core_temps; if (sensors.getSensors(core_temps) > 0) { Logger::debug("M1 sensors found"); got_sensors = true; cpu_temp_only = core_temps.empty(); macM1 = true; } else { #endif // try SMC (intel) Logger::debug("checking intel"); try { SMCConnection smcCon; Logger::debug("SMC connection established"); long long t = smcCon.getTemp(-1); // check if we have package T if (t > -1) { Logger::debug("intel sensors found"); got_sensors = true; t = smcCon.getTemp(0); if (t == -1) { // for some macs the core offset is 1 - check if we get a sane value with 1 if (smcCon.getTemp(1) > -1) { Logger::debug("intel sensors with offset 1"); core_offset = 1; } } } else { Logger::debug("no intel sensors found"); got_sensors = false; } } catch (std::runtime_error &e) { Logger::debug("SMC not available: {}", e.what()); // ignore, we don't have temp (common in VMs) got_sensors = false; } #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 } #endif } return got_sensors; } void update_sensors() { current_cpu.temp_max = 95; // we have no idea how to get the critical temp try { if (macM1) { #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 ThermalSensors sensors; std::vector core_temps; current_cpu.temp.at(0).push_back(sensors.getSensors(core_temps)); if (current_cpu.temp.at(0).size() > 20) current_cpu.temp.at(0).pop_front(); cpu_temp_only = core_temps.empty(); if (Config::getB("show_coretemp") and not core_temps.empty()) { for (int core = 0; core < Shared::coreCount; core++) { size_t sensor_index = static_cast(core) * core_temps.size() / Shared::coreCount; long long temp = core_temps.at(sensor_index); if (cmp_less(core + 1, current_cpu.temp.size())) { current_cpu.temp.at(core + 1).push_back(temp); if (current_cpu.temp.at(core + 1).size() > 20) current_cpu.temp.at(core + 1).pop_front(); } } } #endif } else { SMCConnection smcCon; int threadsPerCore = Shared::coreCount / Shared::physicalCoreCount; long long packageT = smcCon.getTemp(-1); // -1 returns package T current_cpu.temp.at(0).push_back(packageT); for (int core = 0; core < Shared::coreCount; core++) { long long temp = smcCon.getTemp((core / threadsPerCore) + core_offset); // same temp for all threads of same physical core if (cmp_less(core + 1, current_cpu.temp.size())) { current_cpu.temp.at(core + 1).push_back(temp); if (current_cpu.temp.at(core + 1).size() > 20) current_cpu.temp.at(core + 1).pop_front(); } } } } catch (std::runtime_error &e) { got_sensors = false; Logger::error("failed getting CPU temp"); } } string get_cpuHz() { unsigned int freq = 1; size_t size = sizeof(freq); int mib[] = {CTL_HW, HW_CPU_FREQ}; if (sysctl(mib, 2, &freq, &size, nullptr, 0) < 0) { // this fails on Apple Silicon macs. Apparently you're not allowed to know return ""; } return std::to_string(freq / 1000.0 / 1000.0 / 1000.0).substr(0, 3); } auto get_core_mapping() -> std::unordered_map { std::unordered_map core_map; if (cpu_temp_only) return core_map; natural_t cpu_count; natural_t i; MachProcessorInfo info {}; kern_return_t error; error = host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &cpu_count, &info.info_array, &info.info_count); if (error != KERN_SUCCESS) { Logger::error("Failed getting CPU info"); return core_map; } for (i = 0; i < cpu_count; i++) { core_map[i] = i; } //? If core mapping from cpuinfo was incomplete try to guess remainder, if missing completely, map 0-0 1-1 2-2 etc. if (cmp_less(core_map.size(), Shared::coreCount)) { if (Shared::coreCount % 2 == 0 and (long) core_map.size() == Shared::coreCount / 2) { for (int i = 0, n = 0; i < Shared::coreCount / 2; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[Shared::coreCount / 2 + i] = n++; } } else { core_map.clear(); for (int i = 0, n = 0; i < Shared::coreCount; i++) { if (std::cmp_greater_equal(n, core_sensors.size())) n = 0; core_map[i] = n++; } } } //? Apply user set custom mapping if any const auto &custom_map = Config::getS("cpu_core_map"); if (not custom_map.empty()) { try { for (const auto &split : ssplit(custom_map)) { const auto vals = ssplit(split, ':'); if (vals.size() != 2) continue; int change_id = std::stoi(vals.at(0)); int new_id = std::stoi(vals.at(1)); if (not core_map.contains(change_id) or cmp_greater(new_id, core_sensors.size())) continue; core_map.at(change_id) = new_id; } } catch (...) { } } return core_map; } class IOPSInfo_Wrap { CFTypeRef data; public: IOPSInfo_Wrap() { data = IOPSCopyPowerSourcesInfo(); } CFTypeRef& operator()() { return data; } ~IOPSInfo_Wrap() { CFRelease(data); } }; class IOPSList_Wrap { CFArrayRef data; public: IOPSList_Wrap(CFTypeRef cft_ref) { data = IOPSCopyPowerSourcesList(cft_ref); } CFArrayRef& operator()() { return data; } ~IOPSList_Wrap() { CFRelease(data); } }; auto get_battery() -> tuple { if (not has_battery) return {0, 0, 0, ""}; uint32_t percent = -1; long seconds = -1; string status = "discharging"; IOPSInfo_Wrap ps_info{}; if (ps_info()) { IOPSList_Wrap one_ps_descriptor(ps_info()); if (one_ps_descriptor()) { if (CFArrayGetCount(one_ps_descriptor())) { CFDictionaryRef one_ps = IOPSGetPowerSourceDescription(ps_info(), CFArrayGetValueAtIndex(one_ps_descriptor(), 0)); has_battery = true; CFNumberRef remaining = (CFNumberRef)CFDictionaryGetValue(one_ps, CFSTR(kIOPSTimeToEmptyKey)); int32_t estimatedMinutesRemaining; if (remaining) { CFNumberGetValue(remaining, kCFNumberSInt32Type, &estimatedMinutesRemaining); seconds = estimatedMinutesRemaining * 60; } CFNumberRef charge = (CFNumberRef)CFDictionaryGetValue(one_ps, CFSTR(kIOPSCurrentCapacityKey)); if (charge) { CFNumberGetValue(charge, kCFNumberSInt32Type, &percent); } CFBooleanRef charging = (CFBooleanRef)CFDictionaryGetValue(one_ps, CFSTR(kIOPSIsChargingKey)); if (charging) { bool isCharging = CFBooleanGetValue(charging); if (isCharging) { status = "charging"; } } if (percent == 100) { status = "full"; } } else { has_battery = false; } } else { has_battery = false; } } return {percent, -1, seconds, status}; } auto collect(bool no_update) -> cpu_info & { if (Runner::stopping or (no_update and not current_cpu.cpu_percent.at("total").empty())) return current_cpu; auto &cpu = current_cpu; if (getloadavg(cpu.load_avg.data(), cpu.load_avg.size()) < 0) { Logger::error("failed to get load averages"); } natural_t cpu_count; natural_t i; kern_return_t error; processor_cpu_load_info_data_t *cpu_load_info = nullptr; MachProcessorInfo info{}; error = host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &cpu_count, &info.info_array, &info.info_count); if (error != KERN_SUCCESS) { Logger::error("Failed getting CPU load info"); } cpu_load_info = (processor_cpu_load_info_data_t *)info.info_array; long long global_totals = 0; long long global_idles = 0; vector times_summed = {0, 0, 0, 0}; for (i = 0; i < cpu_count; i++) { vector times; //? 0=user, 1=nice, 2=system, 3=idle for (int x = 0; const unsigned int c_state : {CPU_STATE_USER, CPU_STATE_NICE, CPU_STATE_SYSTEM, CPU_STATE_IDLE}) { auto val = cpu_load_info[i].cpu_ticks[c_state]; times.push_back(val); times_summed.at(x++) += val; } try { //? All values const long long totals = std::accumulate(times.begin(), times.end(), 0ll); //? Idle time const long long idles = times.at(3); global_totals += totals; global_idles += idles; //? Calculate cpu total for each core if (i > Shared::coreCount) break; const long long calc_totals = max(0ll, totals - core_old_totals.at(i)); const long long calc_idles = max(0ll, idles - core_old_idles.at(i)); core_old_totals.at(i) = totals; core_old_idles.at(i) = idles; cpu.core_percent.at(i).push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph if (cpu.core_percent.at(i).size() > 40) cpu.core_percent.at(i).pop_front(); } catch (const std::exception &e) { Logger::error("Cpu::collect() : {}", e.what()); throw std::runtime_error(fmt::format("collect() : {}", e.what())); } } const long long calc_totals = max(1ll, global_totals - cpu_old.at("totals")); const long long calc_idles = max(1ll, global_idles - cpu_old.at("idles")); //? Populate cpu.cpu_percent with all fields from syscall for (int ii = 0; const auto &val : times_summed) { cpu.cpu_percent.at(time_names.at(ii)).push_back(clamp((long long)round((double)(val - cpu_old.at(time_names.at(ii))) * 100 / calc_totals), 0ll, 100ll)); cpu_old.at(time_names.at(ii)) = val; //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at(time_names.at(ii)).size(), width * 2)) cpu.cpu_percent.at(time_names.at(ii)).pop_front(); ii++; } cpu_old.at("totals") = global_totals; cpu_old.at("idles") = global_idles; //? Total usage of cpu cpu.cpu_percent.at("total").push_back(clamp((long long)round((double)(calc_totals - calc_idles) * 100 / calc_totals), 0ll, 100ll)); //? Reduce size if there are more values than needed for graph while (cmp_greater(cpu.cpu_percent.at("total").size(), width * 2)) cpu.cpu_percent.at("total").pop_front(); if (Config::getB("show_cpu_freq")) { auto hz = get_cpuHz(); if (hz != "") { cpuHz = hz; } } if (Config::getB("check_temp") and got_sensors) update_sensors(); if (Config::getB("show_battery") and has_battery) current_bat = get_battery(); return cpu; } } // namespace Cpu namespace Mem { bool has_swap = false; vector fstab; fs::file_time_type fstab_time; int disk_ios = 0; vector last_found; static std::mutex iokit_mutex; // Protect concurrent IOKit calls static std::mutex interface_mutex; // Protect concurrent interface access during USB device changes mem_info current_mem{}; uint64_t get_totalMem() { return Shared::totalMem; } int64_t getCFNumber(CFDictionaryRef dict, const void *key) { CFNumberRef ref = (CFNumberRef)CFDictionaryGetValue(dict, key); if (ref) { int64_t value; CFNumberGetValue(ref, kCFNumberSInt64Type, &value); return value; } return 0; } string getCFString(io_registry_entry_t volumeRef, CFStringRef key) { CFStringRef bsdNameRef = (CFStringRef)IORegistryEntryCreateCFProperty(volumeRef, key, kCFAllocatorDefault, 0); if (bsdNameRef) { char buf[200]; CFStringGetCString(bsdNameRef, buf, 200, kCFStringEncodingASCII); CFRelease(bsdNameRef); return string(buf); } return ""; } bool isWhole(io_registry_entry_t volumeRef) { CFBooleanRef isWhole = (CFBooleanRef)IORegistryEntryCreateCFProperty(volumeRef, CFSTR("Whole"), kCFAllocatorDefault, 0); Boolean val = CFBooleanGetValue(isWhole); CFRelease(isWhole); return bool(val); } class IOObject { public: IOObject(string name, io_object_t& obj) : name(name), object(obj) {} virtual ~IOObject() { IOObjectRelease(object); } private: string name; io_object_t &object; }; void collect_disk(std::unordered_map &disks, std::unordered_map &mapping) { // Lock mutex to prevent concurrent IOKit access std::lock_guard lock(iokit_mutex); io_registry_entry_t drive; io_iterator_t drive_list; /* Get the list of all drive objects. */ if (IOServiceGetMatchingServices(kIOMainPortDefault, IOServiceMatching("IOMediaBSDClient"), &drive_list)) { Logger::error("Error in IOServiceGetMatchingServices()"); return; } auto d = IOObject("drive list", drive_list); // dummy var so it gets destroyed while ((drive = IOIteratorNext(drive_list)) != 0) { auto dr = IOObject("drive", drive); io_registry_entry_t volumeRef; IORegistryEntryGetParentEntry(drive, kIOServicePlane, &volumeRef); if (volumeRef) { if (!isWhole(volumeRef)) { string bsdName = getCFString(volumeRef, CFSTR("BSD Name")); string device = getCFString(volumeRef, CFSTR("VolGroupMntFromName")); if (!mapping.contains(device)) { device = "/dev/" + bsdName; // try again with BSD name - not all volumes seem to have VolGroupMntFromName property } if (device != "") { if (mapping.contains(device)) { string mountpoint = mapping.at(device); if (disks.contains(mountpoint)) { auto& disk = disks.at(mountpoint); CFDictionaryRef properties; IORegistryEntryCreateCFProperties(volumeRef, (CFMutableDictionaryRef *)&properties, kCFAllocatorDefault, 0); if (properties) { CFDictionaryRef statistics = (CFDictionaryRef)CFDictionaryGetValue(properties, CFSTR("Statistics")); if (statistics) { disk_ios++; int64_t readBytes = getCFNumber(statistics, CFSTR("Bytes read from block device")); if (disk.io_read.empty()) disk.io_read.push_back(0); else disk.io_read.push_back(max((int64_t)0, (readBytes - disk.old_io.at(0)))); disk.old_io.at(0) = readBytes; while (cmp_greater(disk.io_read.size(), width * 2)) disk.io_read.pop_front(); int64_t writeBytes = getCFNumber(statistics, CFSTR("Bytes written to block device")); if (disk.io_write.empty()) disk.io_write.push_back(0); else disk.io_write.push_back(max((int64_t)0, (writeBytes - disk.old_io.at(1)))); disk.old_io.at(1) = writeBytes; while (cmp_greater(disk.io_write.size(), width * 2)) disk.io_write.pop_front(); // IOKit does not give us IO times, (use IO read + IO write with 1 MiB being 100% to get some activity indication) if (disk.io_activity.empty()) disk.io_activity.push_back(0); else disk.io_activity.push_back(clamp((long)round((double)(disk.io_write.back() + disk.io_read.back()) / (1 << 20)), 0l, 100l)); while (cmp_greater(disk.io_activity.size(), width * 2)) disk.io_activity.pop_front(); } } CFRelease(properties); } } } } } } } auto collect(bool no_update) -> mem_info & { if (Runner::stopping or (no_update and not current_mem.percent.at("used").empty())) return current_mem; auto show_swap = Config::getB("show_swap"); auto show_disks = Config::getB("show_disks"); auto swap_disk = Config::getB("swap_disk"); auto &mem = current_mem; static bool snapped = (getenv("BTOP_SNAPPED") != nullptr); vm_statistics64 p; mach_msg_type_number_t info_size = HOST_VM_INFO64_COUNT; if (host_statistics64(mach_host_self(), HOST_VM_INFO64, (host_info64_t)&p, &info_size) == 0) { mem.stats.at("free") = p.free_count * Shared::pageSize; mem.stats.at("cached") = p.external_page_count * Shared::pageSize; mem.stats.at("used") = (p.active_count + p.wire_count) * Shared::pageSize; mem.stats.at("available") = Shared::totalMem - mem.stats.at("used"); } int mib[2] = {CTL_VM, VM_SWAPUSAGE}; struct xsw_usage swap; size_t len = sizeof(struct xsw_usage); if (sysctl(mib, 2, &swap, &len, nullptr, 0) == 0) { mem.stats.at("swap_total") = swap.xsu_total; mem.stats.at("swap_free") = swap.xsu_avail; mem.stats.at("swap_used") = swap.xsu_used; } if (show_swap and mem.stats.at("swap_total") > 0) { for (const auto &name : swap_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / mem.stats.at("swap_total"))); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } has_swap = true; } else has_swap = false; //? Calculate percentages for (const auto &name : mem_names) { mem.percent.at(name).push_back(round((double)mem.stats.at(name) * 100 / Shared::totalMem)); while (cmp_greater(mem.percent.at(name).size(), width * 2)) mem.percent.at(name).pop_front(); } if (show_disks) { std::unordered_map mapping; // keep mapping from device -> mountpoint, since IOKit doesn't give us the mountpoint double uptime = system_uptime(); auto &disks_filter = Config::getS("disks_filter"); bool filter_exclude = false; // auto only_physical = Config::getB("only_physical"); auto &disks = mem.disks; vector filter; if (not disks_filter.empty()) { filter = ssplit(disks_filter); if (filter.at(0).starts_with("exclude=")) { filter_exclude = true; filter.at(0) = filter.at(0).substr(8); } } struct statfs *stfs; int count = getmntinfo(&stfs, MNT_WAIT); vector found; found.reserve(last_found.size()); for (int i = 0; i < count; i++) { std::error_code ec; string mountpoint = stfs[i].f_mntonname; string dev = stfs[i].f_mntfromname; mapping[dev] = mountpoint; if (string(stfs[i].f_fstypename) == "autofs") { continue; } //? Match filter if not empty if (not filter.empty()) { bool match = v_contains(filter, mountpoint); if ((filter_exclude and match) or (not filter_exclude and not match)) continue; } found.push_back(mountpoint); if (not disks.contains(mountpoint)) { disks[mountpoint] = disk_info{fs::canonical(dev, ec), fs::path(mountpoint).filename()}; if (disks.at(mountpoint).dev.empty()) disks.at(mountpoint).dev = dev; if (disks.at(mountpoint).name.empty()) disks.at(mountpoint).name = (mountpoint == "/" ? "root" : mountpoint); } if (not v_contains(last_found, mountpoint)) redraw = true; disks.at(mountpoint).free = stfs[i].f_bfree; disks.at(mountpoint).total = stfs[i].f_iosize; } //? Remove disks no longer mounted or filtered out if (swap_disk and has_swap) found.push_back("swap"); for (auto it = disks.begin(); it != disks.end();) { if (not v_contains(found, it->first)) it = disks.erase(it); else it++; } if (found.size() != last_found.size()) redraw = true; last_found = std::move(found); //? Get disk/partition stats for (auto &[mountpoint, disk] : disks) { if (std::error_code ec; not fs::exists(mountpoint, ec)) continue; struct statvfs vfs; if (statvfs(mountpoint.c_str(), &vfs) < 0) { Logger::warning("Failed to get disk/partition stats with statvfs() for: {}", mountpoint); continue; } disk.total = vfs.f_blocks * vfs.f_frsize; disk.free = vfs.f_bfree * vfs.f_frsize; disk.used = disk.total - disk.free; if (disk.total != 0) { disk.used_percent = round((double)disk.used * 100 / disk.total); disk.free_percent = 100 - disk.used_percent; } else { disk.used_percent = 0; disk.free_percent = 0; } } //? Setup disks order in UI and add swap if enabled mem.disks_order.clear(); if (snapped and disks.contains("/mnt")) mem.disks_order.push_back("/mnt"); else if (disks.contains("/")) mem.disks_order.push_back("/"); if (swap_disk and has_swap) { mem.disks_order.push_back("swap"); if (not disks.contains("swap")) disks["swap"] = {"", "swap"}; disks.at("swap").total = mem.stats.at("swap_total"); disks.at("swap").used = mem.stats.at("swap_used"); disks.at("swap").free = mem.stats.at("swap_free"); disks.at("swap").used_percent = mem.percent.at("swap_used").back(); disks.at("swap").free_percent = mem.percent.at("swap_free").back(); } for (const auto &name : last_found) if (not is_in(name, "/", "swap", "/dev")) mem.disks_order.push_back(name); disk_ios = 0; collect_disk(disks, mapping); old_uptime = uptime; } return mem; } } // namespace Mem namespace Net { std::unordered_map current_net; net_info empty_net = {}; vector interfaces; string selected_iface; int errors = 0; std::unordered_map graph_max = {{"download", {}}, {"upload", {}}}; std::unordered_map> max_count = {{"download", {}}, {"upload", {}}}; bool rescale = true; uint64_t timestamp = 0; //* RAII wrapper for getifaddrs class getifaddr_wrapper { struct ifaddrs *ifaddr; public: int status; getifaddr_wrapper() { status = getifaddrs(&ifaddr); } ~getifaddr_wrapper() { freeifaddrs(ifaddr); } auto operator()() -> struct ifaddrs * { return ifaddr; } }; auto collect(bool no_update) -> net_info & { // Lock mutex to prevent concurrent interface access during USB device changes std::lock_guard lock(Mem::interface_mutex); auto &net = current_net; auto &config_iface = Config::getS("net_iface"); auto net_sync = Config::getB("net_sync"); auto net_auto = Config::getB("net_auto"); auto new_timestamp = time_ms(); if (not no_update and errors < 3) { //? Get interface list using getifaddrs() wrapper getifaddr_wrapper if_wrap{}; if (if_wrap.status != 0) { errors++; Logger::error("Net::collect() -> getifaddrs() failed with id {}", if_wrap.status); redraw = true; return empty_net; } int family = 0; static_assert(INET6_ADDRSTRLEN >= INET_ADDRSTRLEN); // 46 >= 16, compile-time assurance. enum { IPBUFFER_MAXSIZE = INET6_ADDRSTRLEN }; // manually using the known biggest value, guarded by the above static_assert char ip[IPBUFFER_MAXSIZE]; interfaces.clear(); string ipv4, ipv6; //? Iteration over all items in getifaddrs() list for (auto *ifa = if_wrap(); ifa != nullptr; ifa = ifa->ifa_next) { if (ifa->ifa_addr == nullptr) continue; family = ifa->ifa_addr->sa_family; const auto &iface = ifa->ifa_name; //? Update available interfaces vector and get status of interface if (not v_contains(interfaces, iface)) { interfaces.push_back(iface); net[iface].connected = (ifa->ifa_flags & IFF_RUNNING); // An interface can have more than one IP of the same family associated with it, // but we pick only the first one to show in the NET box. // Note: Interfaces without any IPv4 and IPv6 set are still valid and monitorable! net[iface].ipv4.clear(); net[iface].ipv6.clear(); } //? Get IPv4 address if (family == AF_INET) { if (net[iface].ipv4.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv4 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv4 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } //? Get IPv6 address else if (family == AF_INET6) { if (net[iface].ipv6.empty()) { if (nullptr != inet_ntop(family, &(reinterpret_cast(ifa->ifa_addr)->sin6_addr), ip, IPBUFFER_MAXSIZE)) { net[iface].ipv6 = ip; } else { int errsv = errno; Logger::error("Net::collect() -> Failed to convert IPv6 to string for iface {}, errno: {}", iface, strerror(errsv)); } } } // else, ignoring family==AF_LINK (see man 3 getifaddrs) } std::unordered_map> ifstats; int mib[] = {CTL_NET, PF_ROUTE, 0, 0, NET_RT_IFLIST2, 0}; size_t len; if (sysctl(mib, 6, nullptr, &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { std::unique_ptr buf(new char[len]); if (sysctl(mib, 6, buf.get(), &len, nullptr, 0) < 0) { Logger::error("failed getting network interfaces"); } else { char *lim = buf.get() + len; char *next = nullptr; for (next = buf.get(); next < lim;) { struct if_msghdr *ifm = (struct if_msghdr *)next; next += ifm->ifm_msglen; if (ifm->ifm_type == RTM_IFINFO2) { struct if_msghdr2 *if2m = (struct if_msghdr2 *)ifm; struct sockaddr_dl *sdl = (struct sockaddr_dl *)(if2m + 1); char iface[32]; strncpy(iface, sdl->sdl_data, sdl->sdl_nlen); iface[sdl->sdl_nlen] = 0; ifstats[iface] = std::tuple(if2m->ifm_data.ifi_ibytes, if2m->ifm_data.ifi_obytes); } } } } //? Get total received and transmitted bytes + device address if no ip was found for (const auto &iface : interfaces) { for (const string dir : {"download", "upload"}) { auto &saved_stat = net.at(iface).stat.at(dir); auto &bandwidth = net.at(iface).bandwidth.at(dir); uint64_t val = dir == "download" ? std::get<0>(ifstats[iface]) : std::get<1>(ifstats[iface]); //? Update speed, total and top values if (val < saved_stat.last) { saved_stat.rollover += saved_stat.last; saved_stat.last = 0; } if (cmp_greater((unsigned long long)saved_stat.rollover + (unsigned long long)val, numeric_limits::max())) { saved_stat.rollover = 0; saved_stat.last = 0; } saved_stat.speed = round((double)(val - saved_stat.last) / ((double)(new_timestamp - timestamp) / 1000)); if (saved_stat.speed > saved_stat.top) saved_stat.top = saved_stat.speed; if (saved_stat.offset > val + saved_stat.rollover) saved_stat.offset = 0; saved_stat.total = (val + saved_stat.rollover) - saved_stat.offset; saved_stat.last = val; //? Add values to graph bandwidth.push_back(saved_stat.speed); while (cmp_greater(bandwidth.size(), width * 2)) bandwidth.pop_front(); //? Set counters for auto scaling if (net_auto and selected_iface == iface) { if (saved_stat.speed > graph_max[dir]) { ++max_count[dir][0]; if (max_count[dir][1] > 0) --max_count[dir][1]; } else if (graph_max[dir] > 10 << 10 and saved_stat.speed < graph_max[dir] / 10) { ++max_count[dir][1]; if (max_count[dir][0] > 0) --max_count[dir][0]; } } } } //? Clean up net map if needed if (net.size() > interfaces.size()) { for (auto it = net.begin(); it != net.end();) { if (not v_contains(interfaces, it->first)) it = net.erase(it); else it++; } } timestamp = new_timestamp; } //? Return empty net_info struct if no interfaces was found if (net.empty()) return empty_net; //? Find an interface to display if selected isn't set or valid if (selected_iface.empty() or not v_contains(interfaces, selected_iface)) { max_count["download"][0] = max_count["download"][1] = max_count["upload"][0] = max_count["upload"][1] = 0; redraw = true; if (net_auto) rescale = true; if (not config_iface.empty() and v_contains(interfaces, config_iface)) selected_iface = config_iface; else { //? Sort interfaces by total upload + download bytes auto sorted_interfaces = interfaces; rng::sort(sorted_interfaces, [&](const auto &a, const auto &b) { return cmp_greater(net.at(a).stat["download"].total + net.at(a).stat["upload"].total, net.at(b).stat["download"].total + net.at(b).stat["upload"].total); }); selected_iface.clear(); //? Try to set to a connected interface for (const auto &iface : sorted_interfaces) { if (net.at(iface).connected) selected_iface = iface; break; } //? If no interface is connected set to first available if (selected_iface.empty() and not sorted_interfaces.empty()) selected_iface = sorted_interfaces.at(0); else if (sorted_interfaces.empty()) return empty_net; } } //? Calculate max scale for graphs if needed if (net_auto) { bool sync = false; for (const auto &dir : {"download", "upload"}) { for (const auto &sel : {0, 1}) { if (rescale or max_count[dir][sel] >= 5) { const long long avg_speed = (net[selected_iface].bandwidth[dir].size() > 5 ? std::accumulate(net.at(selected_iface).bandwidth.at(dir).rbegin(), net.at(selected_iface).bandwidth.at(dir).rbegin() + 5, 0ll) / 5 : net[selected_iface].stat[dir].speed); graph_max[dir] = max(uint64_t(avg_speed * (sel == 0 ? 1.3 : 3.0)), (uint64_t)10 << 10); max_count[dir][0] = max_count[dir][1] = 0; redraw = true; if (net_sync) sync = true; break; } } //? Sync download/upload graphs if enabled if (sync) { const auto other = (string(dir) == "upload" ? "download" : "upload"); graph_max[other] = graph_max[dir]; max_count[other][0] = max_count[other][1] = 0; break; } } } rescale = false; return net.at(selected_iface); } } // namespace Net namespace Proc { vector current_procs; std::unordered_map uid_user; string current_sort; string current_filter; bool current_rev = false; bool is_tree_mode; fs::file_time_type passwd_time; uint64_t cputimes; int collapse = -1, expand = -1, toggle_children = -1, collapse_all = -1; uint64_t old_cputimes = 0; atomic numpids = 0; int filter_found = 0; detail_container detailed; static std::unordered_set dead_procs; string get_status(char s) { if (s & SRUN) return "Running"; if (s & SSLEEP) return "Sleeping"; if (s & SIDL) return "Idle"; if (s & SSTOP) return "Stopped"; if (s & SZOMB) return "Zombie"; return "Unknown"; } //* Get detailed info for selected process void _collect_details(const size_t pid, vector &procs) { if (pid != detailed.last_pid) { detailed = {}; detailed.last_pid = pid; detailed.skip_smaps = not Config::getB("proc_info_smaps"); } //? Copy proc_info for process from proc vector auto p_info = rng::find(procs, pid, &proc_info::pid); detailed.entry = *p_info; //? Update cpu percent deque for process cpu graph if (not Config::getB("proc_per_core")) detailed.entry.cpu_p *= Shared::coreCount; detailed.cpu_percent.push_back(clamp((long long)round(detailed.entry.cpu_p), 0ll, 100ll)); while (cmp_greater(detailed.cpu_percent.size(), width)) detailed.cpu_percent.pop_front(); //? Process runtime : current time - start time (both in unix time - seconds since epoch) struct timeval currentTime; gettimeofday(¤tTime, nullptr); //? Get elapsed time if process isn't dead if (detailed.entry.state != 'X') detailed.elapsed = sec_to_dhms(currentTime.tv_sec - (detailed.entry.cpu_s / 1'000'000)); else detailed.elapsed = sec_to_dhms(detailed.entry.death_time); if (detailed.elapsed.size() > 8) detailed.elapsed.resize(detailed.elapsed.size() - 3); //? Get parent process name if (detailed.parent.empty()) { auto p_entry = rng::find(procs, detailed.entry.ppid, &proc_info::pid); if (p_entry != procs.end()) detailed.parent = p_entry->name; } //? Expand process status from single char to explanative string detailed.status = get_status(detailed.entry.state); detailed.mem_bytes.push_back(detailed.entry.mem); detailed.memory = floating_humanizer(detailed.entry.mem); if (detailed.first_mem == -1 or detailed.first_mem < detailed.mem_bytes.back() / 2 or detailed.first_mem > detailed.mem_bytes.back() * 4) { detailed.first_mem = min((uint64_t)detailed.mem_bytes.back() * 2, Mem::get_totalMem()); redraw = true; } while (cmp_greater(detailed.mem_bytes.size(), width)) detailed.mem_bytes.pop_front(); rusage_info_current rusage; if (proc_pid_rusage(pid, RUSAGE_INFO_CURRENT, (void **)&rusage) == 0) { // this fails for processes we don't own - same as in Linux detailed.io_read = floating_humanizer(rusage.ri_diskio_bytesread); detailed.io_write = floating_humanizer(rusage.ri_diskio_byteswritten); } } //* Collects and sorts process information from /proc auto collect(bool no_update) -> vector & { const auto &sorting = Config::getS("proc_sorting"); auto reverse = Config::getB("proc_reversed"); const auto &filter = Config::getS("proc_filter"); auto per_core = Config::getB("proc_per_core"); auto tree = Config::getB("proc_tree"); auto show_detailed = Config::getB("show_detailed"); const auto pause_proc_list = Config::getB("pause_proc_list"); const size_t detailed_pid = Config::getI("detailed_pid"); bool should_filter = current_filter != filter; if (should_filter) current_filter = filter; bool sorted_change = (sorting != current_sort or reverse != current_rev or should_filter); bool tree_mode_change = tree != is_tree_mode; if (sorted_change) { current_sort = sorting; current_rev = reverse; } if (tree_mode_change) is_tree_mode = tree; const int cmult = (per_core) ? Shared::coreCount : 1; bool got_detailed = false; static vector found; //* Use pids from last update if only changing filter, sorting or tree options if (no_update and not current_procs.empty()) { if (show_detailed and detailed_pid != detailed.last_pid) _collect_details(detailed_pid, current_procs); } else { //* ---------------------------------------------Collection start---------------------------------------------- { //* Get CPU totals natural_t cpu_count; kern_return_t error; processor_cpu_load_info_data_t *cpu_load_info = nullptr; MachProcessorInfo info{}; error = host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &cpu_count, &info.info_array, &info.info_count); if (error != KERN_SUCCESS) { Logger::error("Failed getting CPU load info"); } cpu_load_info = (processor_cpu_load_info_data_t *)info.info_array; cputimes = 0; for (natural_t i = 0; i < cpu_count; i++) { cputimes += (cpu_load_info[i].cpu_ticks[CPU_STATE_USER] + cpu_load_info[i].cpu_ticks[CPU_STATE_NICE] + cpu_load_info[i].cpu_ticks[CPU_STATE_SYSTEM] + cpu_load_info[i].cpu_ticks[CPU_STATE_IDLE]); } } should_filter = true; int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0}; found.clear(); size_t size = 0; const auto timeNow = time_micros(); if (sysctl(mib, 4, nullptr, &size, nullptr, 0) < 0 || size == 0) { Logger::error("Unable to get size of kproc_infos"); } uint64_t cpu_t = 0; std::unique_ptr processes(new kinfo_proc[size / sizeof(kinfo_proc)]); if (sysctl(mib, 4, processes.get(), &size, nullptr, 0) == 0) { size_t count = size / sizeof(struct kinfo_proc); for (size_t i = 0; i < count; i++) { //* iterate over all processes in kinfo_proc struct kinfo_proc& kproc = processes.get()[i]; const size_t pid = (size_t)kproc.kp_proc.p_pid; if (pid < 1) continue; found.push_back(pid); //? Check if pid already exists in current_procs bool no_cache = false; auto find_old = rng::find(current_procs, pid, &proc_info::pid); //? Only add new processes if not paused if (find_old == current_procs.end()) { if (not pause_proc_list) { current_procs.push_back({pid}); find_old = current_procs.end() - 1; no_cache = true; } else continue; } else if (dead_procs.contains(pid)) continue; auto &new_proc = *find_old; //? Get program name, command, username, parent pid, nice and status if (no_cache) { char fullname[PROC_PIDPATHINFO_MAXSIZE]; int rc = proc_pidpath(pid, fullname, sizeof(fullname)); string f_name = ""; if (rc != 0) { f_name = std::string(fullname); size_t lastSlash = f_name.find_last_of('/'); f_name = f_name.substr(lastSlash + 1); } new_proc.name = f_name; //? Get process arguments if possible, fallback to process path in case of failure if (Shared::arg_max > 0) { std::unique_ptr proc_chars(new char[Shared::arg_max]); int mib[] = {CTL_KERN, KERN_PROCARGS2, (int)pid}; size_t argmax = Shared::arg_max; if (sysctl(mib, 3, proc_chars.get(), &argmax, nullptr, 0) == 0) { int argc = 0; memcpy(&argc, &proc_chars.get()[0], sizeof(argc)); std::string_view proc_args(proc_chars.get(), argmax); if (size_t null_pos = proc_args.find('\0', sizeof(argc)); null_pos != string::npos) { if (size_t start_pos = proc_args.find_first_not_of('\0', null_pos); start_pos != string::npos) { while (argc-- > 0 and null_pos != string::npos and cmp_less(new_proc.cmd.size(), 1000)) { null_pos = proc_args.find('\0', start_pos); new_proc.cmd += (string)proc_args.substr(start_pos, null_pos - start_pos) + ' '; start_pos = null_pos + 1; } } } if (not new_proc.cmd.empty()) new_proc.cmd.pop_back(); } } if (new_proc.cmd.empty()) new_proc.cmd = f_name; if (new_proc.cmd.size() > 1000) { new_proc.cmd.resize(1000); new_proc.cmd.shrink_to_fit(); } new_proc.ppid = kproc.kp_eproc.e_ppid; new_proc.cpu_s = kproc.kp_proc.p_starttime.tv_sec * 1'000'000 + kproc.kp_proc.p_starttime.tv_usec; struct passwd *pwd = getpwuid(kproc.kp_eproc.e_ucred.cr_uid); if (pwd != nullptr) { new_proc.user = pwd->pw_name; } else { new_proc.user = std::to_string(kproc.kp_eproc.e_ucred.cr_uid); } } new_proc.p_nice = kproc.kp_proc.p_nice; new_proc.state = kproc.kp_proc.p_stat; //? Get threads, mem and cpu usage struct proc_taskinfo pti{}; if (sizeof(pti) == proc_pidinfo(new_proc.pid, PROC_PIDTASKINFO, 0, &pti, sizeof(pti))) { new_proc.threads = pti.pti_threadnum; new_proc.mem = pti.pti_resident_size; cpu_t = pti.pti_total_user + pti.pti_total_system; if (new_proc.cpu_t == 0) new_proc.cpu_t = cpu_t; } else { // Reset memory value if process info cannot be accessed (bad permissions or zombie processes) new_proc.threads = 0; new_proc.mem = 0; cpu_t = new_proc.cpu_t; } //? Process cpu usage since last update new_proc.cpu_p = clamp(round(((cpu_t - new_proc.cpu_t) * Shared::machTck) / ((cputimes - old_cputimes) * Shared::clkTck)) * cmult / 1000.0, 0.0, 100.0 * Shared::coreCount); //? Process cumulative cpu usage since process start new_proc.cpu_c = (double)(cpu_t * Shared::machTck) / (timeNow - new_proc.cpu_s); //? Update cached value with latest cpu times new_proc.cpu_t = cpu_t; if (show_detailed and not got_detailed and new_proc.pid == detailed_pid) { got_detailed = true; } } //? Clear dead processes from current_procs if not paused if (not pause_proc_list) { auto eraser = rng::remove_if(current_procs, [&](const auto& element) { return not v_contains(found, element.pid); }); current_procs.erase(eraser.begin(), eraser.end()); if (!dead_procs.empty()) dead_procs.clear(); } //? Set correct state of dead processes if paused else { const bool keep_dead_proc_usage = Config::getB("keep_dead_proc_usage"); for (auto& r : current_procs) { if (rng::find(found, r.pid) == found.end()) { if (r.state != 'X') { struct timeval currentTime; gettimeofday(¤tTime, nullptr); r.death_time = currentTime.tv_sec - (r.cpu_s / 1'000'000); } r.state = 'X'; dead_procs.emplace(r.pid); //? Reset cpu usage for dead processes if paused and option is set if (!keep_dead_proc_usage) { r.cpu_p = 0.0; r.mem = 0; } } } } //? Update the details info box for process if active if (show_detailed and got_detailed) { _collect_details(detailed_pid, current_procs); } else if (show_detailed and not got_detailed and detailed.status != "Dead") { detailed.status = "Dead"; redraw = true; } old_cputimes = cputimes; } } //* ---------------------------------------------Collection done----------------------------------------------- //* Match filter if defined if (should_filter) { filter_found = 0; for (auto &p : current_procs) { if (not tree and not filter.empty()) { if (!matches_filter(p, filter)) { p.filtered = true; filter_found++; } else { p.filtered = false; } } else { p.filtered = false; } } } //* Sort processes if ((sorted_change or tree_mode_change) or (not no_update and not pause_proc_list)) { proc_sorter(current_procs, sorting, reverse, tree); } //* Generate tree view if enabled if (tree and (not no_update or should_filter or sorted_change)) { bool locate_selection = false; if (toggle_children != -1) { auto collapser = rng::find(current_procs, toggle_children, &proc_info::pid); if (collapser != current_procs.end()){ for (auto& p : current_procs) { if (p.ppid == collapser->pid) { auto child = rng::find(current_procs, p.pid, &proc_info::pid); if (child != current_procs.end()){ child->collapsed = not child->collapsed; } } } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } toggle_children = -1; } if (auto find_pid = (collapse != -1 ? collapse : expand); find_pid != -1) { auto collapser = rng::find(current_procs, find_pid, &proc_info::pid); if (collapser != current_procs.end()) { if (collapse == expand) { collapser->collapsed = not collapser->collapsed; } else if (collapse > -1) { collapser->collapsed = true; } else if (expand > -1) { collapser->collapsed = false; } if (Config::ints.at("proc_selected") > 0) locate_selection = true; } collapse = expand = -1; } if (collapse_all != -1) { toggle_tree_collapse(current_procs); collapse_all = -1; if (Config::ints.at("proc_selected") > 0) locate_selection = true; } if (should_filter or not filter.empty()) filter_found = 0; vector tree_procs; tree_procs.reserve(current_procs.size()); if (!pause_proc_list) { for (auto& p : current_procs) { if (not v_contains(found, p.ppid)) p.ppid = 0; } } //? Stable sort to retain selected sorting among processes with the same parent rng::stable_sort(current_procs, rng::less{}, & proc_info::ppid); //? Start recursive iteration over processes with the lowest shared parent pids for (auto& p : rng::equal_range(current_procs, current_procs.at(0).ppid, rng::less{}, &proc_info::ppid)) { _tree_gen(p, current_procs, tree_procs, 0, false, filter, false, no_update, should_filter); } //? Recursive sort over tree structure to account for collapsed processes in the tree int index = 0; tree_sort(tree_procs, sorting, reverse, (pause_proc_list and not (sorted_change or tree_mode_change)), index, current_procs.size()); //? Recursive construction of ASCII tree prefixes. for (auto t = tree_procs.begin(); t != tree_procs.end(); ++t) { _collect_prefixes(*t, t == tree_procs.end() - 1); } //? Final sort based on tree index rng::stable_sort(current_procs, rng::less {}, &proc_info::tree_index); //? Move current selection/view to the selected process when collapsing/expanding in the tree if (locate_selection) { int loc = rng::find(current_procs, Proc::selected_pid, &proc_info::pid)->tree_index; if (Config::ints.at("proc_start") >= loc or Config::ints.at("proc_start") <= loc - Proc::select_max) Config::ints.at("proc_start") = max(0, loc - 1); Config::ints.at("proc_selected") = loc - Config::ints.at("proc_start") + 1; } } numpids = (int)current_procs.size() - filter_found; return current_procs; } } // namespace Proc namespace Tools { double system_uptime() { struct timeval ts, currTime; std::size_t len = sizeof(ts); int mib[2] = {CTL_KERN, KERN_BOOTTIME}; if (sysctl(mib, 2, &ts, &len, nullptr, 0) != -1) { gettimeofday(&currTime, nullptr); return currTime.tv_sec - ts.tv_sec; } return 0.0; } } // namespace Tools aristocratos-btop-d43a485/src/osx/sensors.cpp000066400000000000000000000151231517514752700213470ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 #include "sensors.hpp" #include #include #include #include #include #include #include #include extern "C" { typedef struct __IOHIDEvent *IOHIDEventRef; typedef struct __IOHIDServiceClient *IOHIDServiceClientRef; #ifdef __LP64__ typedef double IOHIDFloat; #else typedef float IOHIDFloat; #endif #define IOHIDEventFieldBase(type) (type << 16) #define kIOHIDEventTypeTemperature 15 IOHIDEventSystemClientRef IOHIDEventSystemClientCreate(CFAllocatorRef allocator); int IOHIDEventSystemClientSetMatching(IOHIDEventSystemClientRef client, CFDictionaryRef match); int IOHIDEventSystemClientSetMatchingMultiple(IOHIDEventSystemClientRef client, CFArrayRef match); IOHIDEventRef IOHIDServiceClientCopyEvent(IOHIDServiceClientRef, int64_t, int32_t, int64_t); CFStringRef IOHIDServiceClientCopyProperty(IOHIDServiceClientRef service, CFStringRef property); IOHIDFloat IOHIDEventGetFloatValue(IOHIDEventRef event, int32_t field); // create a dict ref, like for temperature sensor {"PrimaryUsagePage":0xff00, "PrimaryUsage":0x5} CFDictionaryRef matching(int page, int usage) { CFNumberRef nums[2]; CFStringRef keys[2]; keys[0] = CFStringCreateWithCString(0, "PrimaryUsagePage", 0); keys[1] = CFStringCreateWithCString(0, "PrimaryUsage", 0); nums[0] = CFNumberCreate(0, kCFNumberSInt32Type, &page); nums[1] = CFNumberCreate(0, kCFNumberSInt32Type, &usage); CFDictionaryRef dict = CFDictionaryCreate(0, (const void **)keys, (const void **)nums, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFRelease(keys[0]); CFRelease(keys[1]); return dict; } double getValue(IOHIDServiceClientRef sc) { IOHIDEventRef event = IOHIDServiceClientCopyEvent(sc, kIOHIDEventTypeTemperature, 0, 0); // here we use ...CopyEvent IOHIDFloat temp = 0.0; if (event != 0) { temp = IOHIDEventGetFloatValue(event, IOHIDEventFieldBase(kIOHIDEventTypeTemperature)); CFRelease(event); } return temp; } } // extern C namespace { int parse_sensor_index(const std::string& name, const std::string& prefix) { if (name.rfind(prefix, 0) != 0) return -1; size_t pos = prefix.size(); if (pos >= name.size() or not std::isdigit(static_cast(name.at(pos)))) return -1; int value = 0; while (pos < name.size() and std::isdigit(static_cast(name.at(pos)))) { value = (value * 10) + (name.at(pos) - '0'); pos++; } return value; } long long avg_to_long(const std::vector& temps) { if (temps.empty()) return 0ll; return round(std::accumulate(temps.begin(), temps.end(), 0ll) / temps.size()); } } long long Cpu::ThermalSensors::getSensors() { std::vector unused_core_temps; return getSensors(unused_core_temps); } long long Cpu::ThermalSensors::getSensors(std::vector& core_temps) { CFDictionaryRef thermalSensors = matching(0xff00, 5); // 65280_10 = FF00_16 // thermalSensors's PrimaryUsagePage should be 0xff00 for M1 chip, instead of 0xff05 // can be checked by ioreg -lfx IOHIDEventSystemClientRef system = IOHIDEventSystemClientCreate(kCFAllocatorDefault); IOHIDEventSystemClientSetMatching(system, thermalSensors); CFArrayRef matchingsrvs = IOHIDEventSystemClientCopyServices(system); std::vector acc_temps; std::vector tdie_temps; std::vector soc_temps; std::unordered_map > acc_named_temps; std::unordered_map > tdie_indexed_temps; if (matchingsrvs) { long count = CFArrayGetCount(matchingsrvs); for (int i = 0; i < count; i++) { IOHIDServiceClientRef sc = (IOHIDServiceClientRef)CFArrayGetValueAtIndex(matchingsrvs, i); if (sc) { CFStringRef name = IOHIDServiceClientCopyProperty(sc, CFSTR("Product")); // here we use ...CopyProperty if (name) { char buf[200]; CFStringGetCString(name, buf, 200, kCFStringEncodingASCII); std::string n(buf); // this is just a guess, nobody knows which sensors mean what // on my system PMU tdie 3 and 9 are missing... // there is also PMU tdev1-8 but it has negative values?? // there is also eACC for efficiency package but it only has 2 entries // and pACC for performance but it has 7 entries (2 - 9) WTF double temp = getValue(sc); if (temp > 0 and temp < 150) { if (n.rfind("eACC", 0) == 0 or n.rfind("pACC", 0) == 0) { acc_temps.push_back(temp); acc_named_temps[n].push_back(temp); } else if (n.rfind("PMU tdie", 0) == 0) { tdie_temps.push_back(temp); int index = parse_sensor_index(n, "PMU tdie"); if (index >= 0) tdie_indexed_temps[index].push_back(temp); } else if (n.rfind("SOC MTR Temp Sensor", 0) == 0) { soc_temps.push_back(temp); } } CFRelease(name); } } } CFRelease(matchingsrvs); } CFRelease(system); CFRelease(thermalSensors); core_temps.clear(); if (not tdie_indexed_temps.empty()) { std::vector indexes; indexes.reserve(tdie_indexed_temps.size()); for (const auto& indexed_temp : tdie_indexed_temps) { indexes.push_back(indexed_temp.first); } std::sort(indexes.begin(), indexes.end()); for (const auto& index : indexes) { auto avg = avg_to_long(tdie_indexed_temps.at(index)); if (avg > 0) core_temps.push_back(avg); } } else if (not acc_named_temps.empty()) { std::vector names; names.reserve(acc_named_temps.size()); for (const auto& named_temp : acc_named_temps) { names.push_back(named_temp.first); } std::sort(names.begin(), names.end()); for (const auto& name : names) { auto avg = avg_to_long(acc_named_temps.at(name)); if (avg > 0) core_temps.push_back(avg); } } const auto &temps = not acc_temps.empty() ? acc_temps : (not tdie_temps.empty() ? tdie_temps : soc_temps); return avg_to_long(temps); } #endif aristocratos-btop-d43a485/src/osx/sensors.hpp000066400000000000000000000015741517514752700213610ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include #include #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101504 namespace Cpu { class ThermalSensors { public: long long getSensors(); long long getSensors(std::vector& core_temps); }; } // namespace Cpu #endif aristocratos-btop-d43a485/src/osx/smc.cpp000066400000000000000000000113101517514752700204270ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #include "smc.hpp" static constexpr size_t MaxIndexCount = sizeof("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") - 1; static constexpr const char *KeyIndexes = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; static UInt32 _strtoul(char *str, int size, int base) { UInt32 total = 0; int i; for (i = 0; i < size; i++) { if (base == 16) { total += str[i] << (size - 1 - i) * 8; } else { total += (unsigned char)(str[i] << (size - 1 - i) * 8); } } return total; } static void _ultostr(char *str, UInt32 val) { str[0] = '\0'; snprintf(str, 5, "%c%c%c%c", (unsigned int)val >> 24, (unsigned int)val >> 16, (unsigned int)val >> 8, (unsigned int)val); } namespace Cpu { SMCConnection::SMCConnection() { CFMutableDictionaryRef matchingDictionary = IOServiceMatching("AppleSMC"); result = IOServiceGetMatchingServices(0, matchingDictionary, &iterator); if (result != kIOReturnSuccess) { throw std::runtime_error("failed to get AppleSMC"); } device = IOIteratorNext(iterator); IOObjectRelease(iterator); if (device == 0) { throw std::runtime_error("failed to get SMC device"); } result = IOServiceOpen(device, mach_task_self(), 0, &conn); IOObjectRelease(device); if (result != kIOReturnSuccess) { throw std::runtime_error("failed to get SMC connection"); } } SMCConnection::~SMCConnection() { IOServiceClose(conn); } long long SMCConnection::getSMCTemp(char *key) { SMCVal_t val; kern_return_t result; result = SMCReadKey(key, &val); if (result == kIOReturnSuccess) { if (val.dataSize > 0) { if (strcmp(val.dataType, DATATYPE_SP78) == 0) { // convert sp78 value to temperature int intValue = val.bytes[0] * 256 + (unsigned char)val.bytes[1]; return static_cast(intValue / 256.0); } } } return -1; } // core means physical core in SMC, while in core map it's cpu threads :-/ Only an issue on hackintosh? // this means we can only get the T per physical core // another issue with the SMC API is that the key is always 4 chars -> what with systems with more than 9 physical cores? // no Mac models with more than 18 threads are released, so no problem so far // according to VirtualSMC docs (hackintosh fake SMC) the enumeration follows with alphabetic chars - not implemented yet here (nor in VirtualSMC) long long SMCConnection::getTemp(int core) { char key[] = SMC_KEY_CPU_TEMP; if (core >= 0) { if ((size_t)core > MaxIndexCount) { return -1; } snprintf(key, 5, "TC%1cc", KeyIndexes[core]); } long long result = getSMCTemp(key); if (result == -1) { // try again with C snprintf(key, 5, "TC%1cC", KeyIndexes[core]); result = getSMCTemp(key); } return result; } kern_return_t SMCConnection::SMCReadKey(UInt32Char_t key, SMCVal_t *val) { kern_return_t result; SMCKeyData_t inputStructure; SMCKeyData_t outputStructure; memset(&inputStructure, 0, sizeof(SMCKeyData_t)); memset(&outputStructure, 0, sizeof(SMCKeyData_t)); memset(val, 0, sizeof(SMCVal_t)); inputStructure.key = _strtoul(key, 4, 16); inputStructure.data8 = SMC_CMD_READ_KEYINFO; result = SMCCall(KERNEL_INDEX_SMC, &inputStructure, &outputStructure); if (result != kIOReturnSuccess) return result; val->dataSize = outputStructure.keyInfo.dataSize; _ultostr(val->dataType, outputStructure.keyInfo.dataType); inputStructure.keyInfo.dataSize = val->dataSize; inputStructure.data8 = SMC_CMD_READ_BYTES; result = SMCCall(KERNEL_INDEX_SMC, &inputStructure, &outputStructure); if (result != kIOReturnSuccess) return result; memcpy(val->bytes, outputStructure.bytes, sizeof(outputStructure.bytes)); return kIOReturnSuccess; } kern_return_t SMCConnection::SMCCall(int index, SMCKeyData_t *inputStructure, SMCKeyData_t *outputStructure) { size_t structureInputSize; size_t structureOutputSize; structureInputSize = sizeof(SMCKeyData_t); structureOutputSize = sizeof(SMCKeyData_t); return IOConnectCallStructMethod(conn, index, // inputStructure inputStructure, structureInputSize, // outputStructure outputStructure, &structureOutputSize); } } // namespace Cpu aristocratos-btop-d43a485/src/osx/smc.hpp000066400000000000000000000051761517514752700204510ustar00rootroot00000000000000/* Copyright 2021 Aristocratos (jakob@qvantnet.com) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. indent = tab tab-size = 4 */ #pragma once #include #include #include #include #include #define VERSION "0.01" #define KERNEL_INDEX_SMC 2 #define SMC_CMD_READ_BYTES 5 #define SMC_CMD_WRITE_BYTES 6 #define SMC_CMD_READ_INDEX 8 #define SMC_CMD_READ_KEYINFO 9 #define SMC_CMD_READ_PLIMIT 11 #define SMC_CMD_READ_VERS 12 #define DATATYPE_FPE2 "fpe2" #define DATATYPE_UINT8 "ui8 " #define DATATYPE_UINT16 "ui16" #define DATATYPE_UINT32 "ui32" #define DATATYPE_SP78 "sp78" // key values #define SMC_KEY_CPU_TEMP "TC0P" // proximity temp? #define SMC_KEY_CPU_DIODE_TEMP "TC0D" // diode temp? #define SMC_KEY_CPU_DIE_TEMP "TC0F" // die temp? #define SMC_KEY_CPU1_TEMP "TC1C" #define SMC_KEY_CPU2_TEMP "TC2C" // etc #define SMC_KEY_FAN0_RPM_CUR "F0Ac" typedef struct { char major; char minor; char build; char reserved[1]; UInt16 release; } SMCKeyData_vers_t; typedef struct { UInt16 version; UInt16 length; UInt32 cpuPLimit; UInt32 gpuPLimit; UInt32 memPLimit; } SMCKeyData_pLimitData_t; typedef struct { UInt32 dataSize; UInt32 dataType; char dataAttributes; } SMCKeyData_keyInfo_t; typedef char SMCBytes_t[32]; typedef struct { UInt32 key; SMCKeyData_vers_t vers; SMCKeyData_pLimitData_t pLimitData; SMCKeyData_keyInfo_t keyInfo; char result; char status; char data8; UInt32 data32; SMCBytes_t bytes; } SMCKeyData_t; typedef char UInt32Char_t[5]; typedef struct { UInt32Char_t key; UInt32 dataSize; UInt32Char_t dataType; SMCBytes_t bytes; } SMCVal_t; namespace Cpu { class SMCConnection { public: SMCConnection(); virtual ~SMCConnection(); long long getTemp(int core); private: kern_return_t SMCReadKey(UInt32Char_t key, SMCVal_t *val); long long getSMCTemp(char *key); kern_return_t SMCCall(int index, SMCKeyData_t *inputStructure, SMCKeyData_t *outputStructure); io_connect_t conn; kern_return_t result; mach_port_t masterPort; io_iterator_t iterator; io_object_t device; }; } // namespace Cpu aristocratos-btop-d43a485/tests/000077500000000000000000000000001517514752700167075ustar00rootroot00000000000000aristocratos-btop-d43a485/tests/CMakeLists.txt000066400000000000000000000010561517514752700214510ustar00rootroot00000000000000# SPDX-License-Identifier: Apache-2.0 include(FetchContent) FetchContent_Declare( googletest GIT_REPOSITORY https://github.com/google/googletest.git GIT_TAG v1.17.0 FIND_PACKAGE_ARGS NAMES GTest ) FetchContent_MakeAvailable(googletest) add_library(libbtop_test) target_include_directories(libbtop_test PUBLIC ${PROJECT_SOURCE_DIR}/src) target_link_libraries(libbtop_test libbtop GTest::gtest_main) add_executable(btop_test cpu_names.cpp tools.cpp) target_link_libraries(btop_test libbtop_test) include(GoogleTest) gtest_discover_tests(btop_test) aristocratos-btop-d43a485/tests/cpu_names.cpp000066400000000000000000000036101517514752700213650ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #include "btop_shared.hpp" #include TEST(cpu_names, amd) { EXPECT_EQ(Cpu::trim_name("AMD Ryzen AI 7 PRO 360 w/ Radeon 880M"), "Ryzen AI 7 PRO 360"); EXPECT_EQ(Cpu::trim_name("AMD Ryzen 7 PRO 4750G with Radeon Graphics"), "Ryzen 7 PRO 4750G"); EXPECT_EQ(Cpu::trim_name("AMD Ryzen Threadripper PRO 3975WX 32-Cores"), "Ryzen Threadripper PRO 3975WX"); EXPECT_EQ(Cpu::trim_name("AMD Ryzen 7 5700X 8-Core Processor"), "Ryzen 7 5700X"); EXPECT_EQ(Cpu::trim_name("AMD EPYC 7543 32-Core Processor"), "EPYC 7543 32-"); } TEST(cpu_names, intel) { EXPECT_EQ(Cpu::trim_name("Intel(R) Pentium(R) III CPU family 1400MHz"), "family"); EXPECT_EQ(Cpu::trim_name("Intel(R) Pentium(R) CPU P6200 @ 2.13GHz"), "P6200"); EXPECT_EQ(Cpu::trim_name("Intel(R) Core(TM) i7 CPU Q 840 @ 1.87GHz"), "Q"); EXPECT_EQ(Cpu::trim_name("Intel(R) Core(TM) i5-4570 CPU @ 3.20GHz"), "i5-4570"); EXPECT_EQ(Cpu::trim_name("Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz"), "i7-8700"); EXPECT_EQ(Cpu::trim_name("Intel(R) Core(TM) i5-10600 CPU @ 3.30GHz"), "i5-10600"); EXPECT_EQ(Cpu::trim_name("12th Gen Intel(R) Core(TM) i5-12600"), "12th Gen i5-12600"); EXPECT_EQ(Cpu::trim_name("13th Gen Intel(R) Core(TM) i5-13500"), "13th Gen i5-13500"); EXPECT_EQ(Cpu::trim_name("Intel(R) Core(TM) i5-14600"), "i5-14600"); EXPECT_EQ(Cpu::trim_name("Intel(R) Xeon(R) CPU E5-2690 v3 @ 2.60GHz"), "E5-2690"); EXPECT_EQ(Cpu::trim_name("Intel(R) Xeon(R) CPU E5-2690 v4 @ 2.60GHz"), "E5-2690"); EXPECT_EQ(Cpu::trim_name("Intel(R) Xeon(R) Silver 4410Y"), "Xeon Silver 4410Y"); EXPECT_EQ(Cpu::trim_name("Intel(R) Xeon(R) Gold 6138 CPU @ 2.00GHz"), "@"); EXPECT_EQ(Cpu::trim_name("Intel(R) Xeon(R) Gold 6240 CPU @ 2.60GHz"), "@"); EXPECT_EQ(Cpu::trim_name("INTEL(R) XEON(R) GOLD 6548Y+"), "INTEL XEON GOLD 6548Y+"); EXPECT_EQ(Cpu::trim_name("Intel(R) Xeon(R) Platinum 8368Q CPU @ 2.60GHz"), "@"); } aristocratos-btop-d43a485/tests/tools.cpp000066400000000000000000000012021517514752700205460ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 #include #include #include "btop_tools.hpp" TEST(tools, string_split) { EXPECT_EQ(Tools::ssplit(""), std::vector {}); EXPECT_EQ(Tools::ssplit("foo"), std::vector { "foo" }); { auto actual = Tools::ssplit("foo bar baz "); auto expected = std::vector { "foo", "bar", "baz" }; EXPECT_EQ(actual, expected); } { auto actual = Tools::ssplit("foobo oho barbo bo bazbo", 'o'); auto expected = std::vector { "f", "b", " ", "h", " barb", " b", " bazb" }; EXPECT_EQ(actual, expected); } } aristocratos-btop-d43a485/themes/000077500000000000000000000000001517514752700170325ustar00rootroot00000000000000aristocratos-btop-d43a485/themes/HotPurpleTrafficLight.theme000066400000000000000000000044771517514752700243030ustar00rootroot00000000000000#HotPurpleTrafficLight #by Pete Allebone - mess with the best... you know the rest. #Designed to flash up bright red with danger when loads are high and attention is needed. # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#000000" # Main text color theme[main_fg]="#d1d1e0" # Title color for boxes theme[title]="#d1d1e0" # Highlight color for keyboard shortcuts theme[hi_fg]="#9933ff" # Background color of selected item in processes box theme[selected_bg]="#6666ff" # Foreground color of selected item in processes box theme[selected_fg]="#d1d1e0" # Color of inactive/disabled text theme[inactive_fg]="#9999ff" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#9933ff" # Background color of the percentage meters theme[meter_bg]="#4d4dff" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#9933ff" # Cpu box outline color theme[cpu_box]="#a64dff" # Memory/disks box outline color theme[mem_box]="#a64dff" # Net up/down box outline color theme[net_box]="#a64dff" # Processes box outline color theme[proc_box]="#a64dff" # Box divider line and small boxes line color theme[div_line]="#4d4dff" # Temperature graph colors theme[temp_start]="#00ff00" theme[temp_mid]="#ff9933" theme[temp_end]="#ff0000" # CPU graph colors theme[cpu_start]="#00ff00" theme[cpu_mid]="#ccff66" theme[cpu_end]="#ff0000" # Mem/Disk free meter theme[free_end]="#00ff00" theme[free_mid]="#ccff66" theme[free_start]="#ff0000" # Mem/Disk cached meter theme[cached_start]="#00ff00" theme[cached_mid]="#ccff66" theme[cached_end]="#ff0000" # Mem/Disk available meter theme[available_start]="#ff0000" theme[available_mid]="#ccff66" theme[available_end]="#00ff00" # Mem/Disk used meter theme[used_start]="#00ff00" theme[used_mid]="#ccff66" theme[used_end]="#ff0000" # Download graph colors theme[download_start]="#00ff00" theme[download_mid]="#ff9933" theme[download_end]="#ff0000" # Upload graph colors theme[upload_start]="#00ff00" theme[upload_mid]="#ff9933" theme[upload_end]="#ff0000" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#9999ff" theme[process_mid]="#4d4dff" theme[process_end]="#a64dff" aristocratos-btop-d43a485/themes/adapta.theme000066400000000000000000000042501517514752700213110ustar00rootroot00000000000000#Bashtop Adapta theme #by olokelo # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="" # Main text color theme[main_fg]="#cfd8dc" # Title color for boxes theme[title]="#ff" # Highlight color for keyboard shortcuts theme[hi_fg]="#90" # Background color of selected item in processes box theme[selected_bg]="#bb0040" # Foreground color of selected item in processes box theme[selected_fg]="#ff" # Color of inactive/disabled text theme[inactive_fg]="#40" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#55bcea" # Cpu box outline color theme[cpu_box]="#00bcd4" # Memory/disks box outline color theme[mem_box]="#00bcd4" # Net up/down box outline color theme[net_box]="#00bcd4" # Processes box outline color theme[proc_box]="#00bcd4" # Box divider line and small boxes line color theme[div_line]="#50" # Temperature graph colors theme[temp_start]="#00bcd4" theme[temp_mid]="#d4d400" theme[temp_end]="#ff0040" # CPU graph colors theme[cpu_start]="#00bcd4" theme[cpu_mid]="#d4d400" theme[cpu_end]="#ff0040" # Mem/Disk free meter theme[free_start]="#00bcd4" theme[free_mid]="#1090a0" theme[free_end]="#206f79" # Mem/Disk cached meter theme[cached_start]="#991199" theme[cached_mid]="#770a55" theme[cached_end]="#550055" # Mem/Disk available meter theme[available_start]="#00b0ff" theme[available_mid]="#1099cc" theme[available_end]="#2070aa" # Mem/Disk used meter theme[used_start]="#ff0040" theme[used_mid]="#ff2060" theme[used_end]="#ff4080" # Download graph colors theme[download_start]="#00bcd4" theme[download_mid]="#991199" theme[download_end]="#ff0040" # Upload graph colors theme[upload_start]="#00bcd4" theme[upload_mid]="#991199" theme[upload_end]="#ff0040" aristocratos-btop-d43a485/themes/adwaita-dark.theme000066400000000000000000000034741517514752700224170ustar00rootroot00000000000000#Bashtop Adwaita Dark theme #by k0tran # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#1d1d1d" # Main text color theme[main_fg]="#deddda" # Title color for boxes theme[title]="#deddda" # Highlight color for keyboard shortcuts theme[hi_fg]="#62a0ea" # Background color of selected item in processes box theme[selected_bg]="#1c71d8" # Foreground color of selected item in processes box theme[selected_fg]="#ffffff" # Color of inactive/disabled text theme[inactive_fg]="#77767b" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#1a5fb4" # Cpu box outline color theme[cpu_box]="#77767b" # Memory/disks box outline color theme[mem_box]="#77767b" # Net up/down box outline color theme[net_box]="#77767b" # Processes box outline color theme[proc_box]="#77767b" # Box divider line and small boxes line color theme[div_line]="#77767b" # Temperature graph colors theme[temp_start]="#62a0ea" theme[temp_mid]="#1c71d8" theme[temp_end]="#e01b24" # CPU graph colors theme[cpu_start]="#62a0ea" theme[cpu_mid]="#1c71d8" theme[cpu_end]="#e01b24" # Mem/Disk free meter theme[free_start]="#62a0ea" theme[free_mid]="#1c71d8" theme[free_end]="#c01b24" # Mem/Disk cached meter theme[cached_start]="#62a0ea" theme[cached_mid]="#1c71d8" theme[cached_end]="#c01b24" # Mem/Disk available meter theme[available_start]="#62a0ea" theme[available_mid]="#1c71d8" theme[available_end]="#c01b24" # Mem/Disk used meter theme[used_start]="#62a0ea" theme[used_mid]="#1c71d8" theme[used_end]="#c01b24" # Download graph colors theme[download_start]="#62a0ea" theme[download_mid]="#1c71d8" theme[download_end]="#c01b24" # Upload graph colors theme[upload_start]="#62a0ea" theme[upload_mid]="#1c71d8" theme[upload_end]="#c01b24" aristocratos-btop-d43a485/themes/adwaita.theme000066400000000000000000000043111517514752700214670ustar00rootroot00000000000000#Bashtop Adwaita theme #by flipflop133 # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#f6f5f4" # Main text color theme[main_fg]="#2e3436" # Title color for boxes theme[title]="#2e3436" # Highlight color for keyboard shortcuts theme[hi_fg]="#1a5fb4" # Background color of selected item in processes box theme[selected_bg]="#1c71d8" # Foreground color of selected item in processes box theme[selected_fg]="#ffffff" # Color of inactive/disabled text theme[inactive_fg]="#5e5c64" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#1a5fb4" # Cpu box outline color theme[cpu_box]="#2e3436" # Memory/disks box outline color theme[mem_box]="#3d3c14" # Net up/down box outline color theme[net_box]="#2e3436" # Processes box outline color theme[proc_box]="#2e3436" # Box divider line and small boxes line color theme[div_line]="#2e3436" # Temperature graph colors theme[temp_start]="#1a5fb4" theme[temp_mid]="#1a5fb4" theme[temp_end]="#c01c28" # CPU graph colors theme[cpu_start]="#1a5fb4" theme[cpu_mid]="#1a5fb4" theme[cpu_end]="#c01c28" # Mem/Disk free meter theme[free_start]="#1a5fb4" theme[free_mid]="#1a5fb4" theme[free_end]="#c01c28" # Mem/Disk cached meter theme[cached_start]="#1a5fb4" theme[cached_mid]="#1a5fb4" theme[cached_end]="#c01c28" # Mem/Disk available meter theme[available_start]="#1a5fb4" theme[available_mid]="#1a5fb4" theme[available_end]="#c01c28" # Mem/Disk used meter theme[used_start]="#1a5fb4" theme[used_mid]="#1a5fb4" theme[used_end]="#c01c28" # Download graph colors theme[download_start]="#1a5fb4" theme[download_mid]="#1a5fb4" theme[download_end]="#c01c28" # Upload graph colors theme[upload_start]="#1a5fb4" theme[upload_mid]="#1a5fb4" theme[upload_end]="#c01c28" aristocratos-btop-d43a485/themes/ayu.theme000066400000000000000000000041461517514752700206610ustar00rootroot00000000000000# Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#0B0E14" # Main text color theme[main_fg]="#BFBDB6" # Title color for boxes theme[title]="#BFBDB6" # Highlight color for keyboard shortcuts theme[hi_fg]="#E6B450" # Background color of selected item in processes box theme[selected_bg]="#E6B450" # Foreground color of selected item in processes box theme[selected_fg]="#f8f8f2" # Color of inactive/disabled text theme[inactive_fg]="#565B66" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#BFBDB6" # Background color of the percentage meters theme[meter_bg]="#565B66" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#DFBFFF" # Cpu box outline color theme[cpu_box]="#DFBFFF" # Memory/disks box outline color theme[mem_box]="#95E6CB" # Net up/down box outline color theme[net_box]="#F28779" # Processes box outline color theme[proc_box]="#E6B673" # Box divider line and small boxes line color theme[div_line]="#565B66" # Temperature graph colors theme[temp_start]="#DFBFFF" theme[temp_mid]="#D2A6FF" theme[temp_end]="#A37ACC" # CPU graph colors theme[cpu_start]="#DFBFFF" theme[cpu_mid]="#D2A6FF" theme[cpu_end]="#A37ACC" # Mem/Disk free meter theme[free_start]="#95E6CB" theme[free_mid]="#95E6CB" theme[free_end]="#4CBF99" # Mem/Disk cached meter theme[cached_start]="#95E6CB" theme[cached_mid]="#95E6CB" theme[cached_end]="#4CBF99" # Mem/Disk available meter theme[available_start]="#95E6CB" theme[available_mid]="#95E6CB" theme[available_end]="#4CBF99" # Mem/Disk used meter theme[used_start]="#95E6CB" theme[used_mid]="#95E6CB" theme[used_end]="#4CBF99" # Download graph colors theme[download_start]="#F28779" theme[download_mid]="#F07178" theme[download_end]="#F07171" # Upload graph colors theme[upload_start]="#73D0FF" theme[upload_mid]="#59C2FF" theme[upload_end]="#399EE6" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#FFCC66" theme[process_mid]="#E6B450" theme[process_end]="#FFAA33" aristocratos-btop-d43a485/themes/dracula.theme000066400000000000000000000041461517514752700214760ustar00rootroot00000000000000# Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#282a36" # Main text color theme[main_fg]="#f8f8f2" # Title color for boxes theme[title]="#f8f8f2" # Highlight color for keyboard shortcuts theme[hi_fg]="#6272a4" # Background color of selected item in processes box theme[selected_bg]="#ff79c6" # Foreground color of selected item in processes box theme[selected_fg]="#f8f8f2" # Color of inactive/disabled text theme[inactive_fg]="#44475a" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#f8f8f2" # Background color of the percentage meters theme[meter_bg]="#44475a" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#bd93f9" # Cpu box outline color theme[cpu_box]="#bd93f9" # Memory/disks box outline color theme[mem_box]="#50fa7b" # Net up/down box outline color theme[net_box]="#ff5555" # Processes box outline color theme[proc_box]="#8be9fd" # Box divider line and small boxes line color theme[div_line]="#44475a" # Temperature graph colors theme[temp_start]="#bd93f9" theme[temp_mid]="#ff79c6" theme[temp_end]="#ff33a8" # CPU graph colors theme[cpu_start]="#bd93f9" theme[cpu_mid]="#8be9fd" theme[cpu_end]="#50fa7b" # Mem/Disk free meter theme[free_start]="#ffa6d9" theme[free_mid]="#ff79c6" theme[free_end]="#ff33a8" # Mem/Disk cached meter theme[cached_start]="#b1f0fd" theme[cached_mid]="#8be9fd" theme[cached_end]="#26d7fd" # Mem/Disk available meter theme[available_start]="#ffd4a6" theme[available_mid]="#ffb86c" theme[available_end]="#ff9c33" # Mem/Disk used meter theme[used_start]="#96faaf" theme[used_mid]="#50fa7b" theme[used_end]="#0dfa49" # Download graph colors theme[download_start]="#bd93f9" theme[download_mid]="#50fa7b" theme[download_end]="#8be9fd" # Upload graph colors theme[upload_start]="#8c42ab" theme[upload_mid]="#ff79c6" theme[upload_end]="#ff33a8" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#50fa7b" theme[process_mid]="#59b690" theme[process_end]="#6272a4" aristocratos-btop-d43a485/themes/dusklight.theme000066400000000000000000000045441517514752700220630ustar00rootroot00000000000000#Bpytop theme comprised of blues, oranges, cyan, and yellow. #by Drazil100 # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#04142E" # Main text color theme[main_fg]="#99DFFF" # Title color for boxes theme[title]="#99FFFF" # Highlight color for keyboard shortcuts theme[hi_fg]="#FF7F00" # Background color of selected item in processes box theme[selected_bg]="#722B01" # Foreground color of selected item in processes box theme[selected_fg]="#99FFFF" # Color of inactive/disabled text theme[inactive_fg]="#052E51" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#79A1B4" # Background color of the percentage meters theme[meter_bg]="#052E51" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#B46718" # Cpu box outline color theme[cpu_box]="#00FFFF" # Memory/disks box outline color theme[mem_box]="#00FFFF" # Net up/down box outline color theme[net_box]="#00FFFF" # Processes box outline color theme[proc_box]="#00FFFF" # Box divider line and small boxes line color theme[div_line]="#A55800" # Temperature graph colors theme[temp_start]="#00ADFF" theme[temp_mid]="#00FFFF" theme[temp_end]="#FFF86B" # CPU graph colors theme[cpu_start]="#00D4FF" theme[cpu_mid]="#FFF86B" theme[cpu_end]="#FF7F00" # Mem/Disk free meter theme[free_start]="#0187CB" theme[free_mid]="" theme[free_end]="" # Mem/Disk cached meter theme[cached_start]="#B4BB63" theme[cached_mid]="" theme[cached_end]="" # Mem/Disk available meter theme[available_start]="#01C0CB" theme[available_mid]="" theme[available_end]="" # Mem/Disk used meter theme[used_start]="#B46718" theme[used_mid]="" theme[used_end]="" # Download graph colors theme[download_start]="#009EFF" theme[download_mid]="" theme[download_end]="#00FFFF" # Upload graph colors theme[upload_start]="#FF7F00" theme[upload_mid]="" theme[upload_end]="#FFF86B" aristocratos-btop-d43a485/themes/elementarish.theme000066400000000000000000000034011517514752700225340ustar00rootroot00000000000000# Theme: Elementarish # (inspired by Elementary OS) # By: Dennis Mayr # Main bg theme[main_bg]="#333333" # Main text color theme[main_fg]="#eee8d5" # Title color for boxes theme[title]="#eee8d5" # Highlight color for keyboard shortcuts theme[hi_fg]="#d1302c" # Background color of selected item in processes box theme[selected_bg]="#268ad0" # Foreground color of selected item in processes box theme[selected_fg]="#eee8d5" # Color of inactive/disabled text theme[inactive_fg]="#657b83" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#268ad0" # Cpu box outline color theme[cpu_box]="#657b83" # Memory/disks box outline color theme[mem_box]="#657b83" # Net up/down box outline color theme[net_box]="#657b83" # Processes box outline color theme[proc_box]="#657b83" # Box divider line and small boxes line color theme[div_line]="#657b83" # Temperature graph colors theme[temp_start]="#859900" theme[temp_mid]="#b28602" theme[temp_end]="#d1302c" # CPU graph colors theme[cpu_start]="#859900" theme[cpu_mid]="#b28602" theme[cpu_end]="#d1302c" # Mem/Disk free meter theme[free_start]="#268ad0" theme[free_mid]="#6c71c4" theme[free_end]="#2a9d95" # Mem/Disk cached meter theme[cached_start]="#268ad0" theme[cached_mid]="#6c71c4" theme[cached_end]="#d1302c" # Mem/Disk available meter theme[available_start]="#268ad0" theme[available_mid]="#6c71c4" theme[available_end]="#d1302c" # Mem/Disk used meter theme[used_start]="#859900" theme[used_mid]="#b28602" theme[used_end]="#d1302c" # Download graph colors theme[download_start]="#268ad0" theme[download_mid]="#6c71c4" theme[download_end]="#d1302c" # Upload graph colors theme[upload_start]="#268ad0" theme[upload_mid]="#6c71c4" theme[upload_end]="#d1302c" aristocratos-btop-d43a485/themes/everforest-dark-hard.theme000066400000000000000000000043341517514752700241010ustar00rootroot00000000000000# All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#272e33" # Main text color theme[main_fg]="#d3c6aa" # Title color for boxes theme[title]="#d3c6aa" # Highlight color for keyboard shortcuts theme[hi_fg]="#e67e80" # Background color of selected items theme[selected_bg]="#374145" # Foreground color of selected items theme[selected_fg]="#dbbc7f" # Color of inactive/disabled text theme[inactive_fg]="#272e33" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#d3c6aa" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#a7c080" # Cpu box outline color theme[cpu_box]="#374145" # Memory/disks box outline color theme[mem_box]="#374145" # Net up/down box outline color theme[net_box]="#374145" # Processes box outline color theme[proc_box]="#374145" # Box divider line and small boxes line color theme[div_line]="#374145" # Temperature graph colors theme[temp_start]="#a7c080" theme[temp_mid]="#dbbc7f" theme[temp_end]="#f85552" # CPU graph colors theme[cpu_start]="#a7c080" theme[cpu_mid]="#dbbc7f" theme[cpu_end]="#f85552" # Mem/Disk free meter theme[free_start]="#f85552" theme[free_mid]="#dbbc7f" theme[free_end]="#a7c080" # Mem/Disk cached meter theme[cached_start]="#7fbbb3" theme[cached_mid]="#83c092" theme[cached_end]="#a7c080" # Mem/Disk available meter theme[available_start]="#f85552" theme[available_mid]="#dbbc7f" theme[available_end]="#a7c080" # Mem/Disk used meter theme[used_start]="#a7c080" theme[used_mid]="#dbbc7f" theme[used_end]="#f85552" # Download graph colors theme[download_start]="#a7c080" theme[download_mid]="#83c092" theme[download_end]="#7fbbb3" # Upload graph colors theme[upload_start]="#dbbc7f" theme[upload_mid]="#e69875" theme[upload_end]="#e67e80" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#a7c080" theme[process_mid]="#f85552" theme[process_end]="#CC241D" aristocratos-btop-d43a485/themes/everforest-dark-medium.theme000066400000000000000000000043351517514752700244440ustar00rootroot00000000000000# All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#2d353b" # Main text color theme[main_fg]="#d3c6aa" # Title color for boxes theme[title]="#d3c6aa" # Highlight color for keyboard shortcuts theme[hi_fg]="#e67e80" # Background color of selected items theme[selected_bg]="#3d484d" # Foreground color of selected items theme[selected_fg]="#dbbc7f" # Color of inactive/disabled text theme[inactive_fg]="#2d353b" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#d3c6aa" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#a7c080" # Cpu box outline color theme[cpu_box]="#3d484d" # Memory/disks box outline color theme[mem_box]="#3d484d" # Net up/down box outline color theme[net_box]="#3d484d" # Processes box outline color theme[proc_box]="#3d484d" # Box divider line and small boxes line color theme[div_line]="#3d484d" # Temperature graph colors theme[temp_start]="#a7c080" theme[temp_mid]="#dbbc7f" theme[temp_end]="#f85552" # CPU graph colors theme[cpu_start]="#a7c080" theme[cpu_mid]="#dbbc7f" theme[cpu_end]="#f85552" # Mem/Disk free meter theme[free_start]="#f85552" theme[free_mid]="#dbbc7f" theme[free_end]="#a7c080" # Mem/Disk cached meter theme[cached_start]="#7fbbb3" theme[cached_mid]="#83c092" theme[cached_end]="#a7c080" # Mem/Disk available meter theme[available_start]="#f85552" theme[available_mid]="#dbbc7f" theme[available_end]="#a7c080" # Mem/Disk used meter theme[used_start]="#a7c080" theme[used_mid]="#dbbc7f" theme[used_end]="#f85552" # Download graph colors theme[download_start]="#a7c080" theme[download_mid]="#83c092" theme[download_end]="#7fbbb3" # Upload graph colors theme[upload_start]="#dbbc7f" theme[upload_mid]="#e69875" theme[upload_end]="#e67e80" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#a7c080" theme[process_mid]="#e67e80" theme[process_end]="#f85552" aristocratos-btop-d43a485/themes/everforest-light-medium.theme000066400000000000000000000043331517514752700246300ustar00rootroot00000000000000# All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#fdf6e3" # Main text color theme[main_fg]="#5c6a72" # Title color for boxes theme[title]="#5c6a72" # Highlight color for keyboard shortcuts theme[hi_fg]="#df69ba" # Background color of selected items theme[selected_bg]="#4F585E" # Foreground color of selected items theme[selected_fg]="#dfa000" # Color of inactive/disabled text theme[inactive_fg]="#9DA9A0" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#5c6a72" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#8da101" # Cpu box outline color theme[cpu_box]="#4F585E" # Memory/disks box outline color theme[mem_box]="#4F585E" # Net up/down box outline color theme[net_box]="#4F585E" # Processes box outline color theme[proc_box]="#4F585E" # Box divider line and small boxes line color theme[div_line]="#4F585E" # Temperature graph colors theme[temp_start]="#8da101" theme[temp_mid]="#dfa000" theme[temp_end]="#f85552" # CPU graph colors theme[cpu_start]="#8da101" theme[cpu_mid]="#dfa000" theme[cpu_end]="#f85552" # Mem/Disk free meter theme[free_start]="#f85552" theme[free_mid]="#dfa000" theme[free_end]="#8da101" # Mem/Disk cached meter theme[cached_start]="#3994c5" theme[cached_mid]="#35a77c" theme[cached_end]="#8da101" # Mem/Disk available meter theme[available_start]="#f85552" theme[available_mid]="#dfa000" theme[available_end]="#8da101" # Mem/Disk used meter theme[used_start]="#8da101" theme[used_mid]="#dfa000" theme[used_end]="#f85552" # Download graph colors theme[download_start]="#8da101" theme[download_mid]="#35a77c" theme[download_end]="#3994c5" # Upload graph colors theme[upload_start]="#dfa000" theme[upload_mid]="#e66868" theme[upload_end]="#df69ba" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#8da101" theme[process_mid]="#df69ba" theme[process_end]="#f85552" aristocratos-btop-d43a485/themes/flat-remix-light.theme000066400000000000000000000043501517514752700232350ustar00rootroot00000000000000#Bashtop theme with flat-remix colors #by Daniel Ruiz de Alegrรญa # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#e4e4e7" # Main text color theme[main_fg]="#737680" # Title color for boxes theme[title]="#272a34" # Highlight color for keyboard shortcuts theme[hi_fg]="#90" # Background color of selected item in processes box theme[selected_bg]="#b8174c" # Foreground color of selected item in processes box theme[selected_fg]="#ff" # Color of inactive/disabled text theme[inactive_fg]="#40" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#367bf0" # Cpu box outline color theme[cpu_box]="#367bf0" # Memory/disks box outline color theme[mem_box]="#19a187" # Net up/down box outline color theme[net_box]="#fd3535" # Processes box outline color theme[proc_box]="#4aaee6" # Box divider line and small boxes line color theme[div_line]="#50" # Temperature graph colors theme[temp_start]="#367bf0" theme[temp_mid]="#b8174c" theme[temp_end]="#d41919" # CPU graph colors theme[cpu_start]="#367bf0" theme[cpu_mid]="#4aaee6" theme[cpu_end]="#54bd8e" # Mem/Disk free meter theme[free_start]="#811035" theme[free_mid]="#b8174c" theme[free_end]="#d41919" # Mem/Disk cached meter theme[cached_start]="#2656a8" theme[cached_mid]="#4aaee6" theme[cached_end]="#23bac2" # Mem/Disk available meter theme[available_start]="#fea44c" theme[available_mid]="#fd7d00" theme[available_end]="#fe7171" # Mem/Disk used meter theme[used_start]="#12715f" theme[used_mid]="#19a187" theme[used_end]="#23bac2" # Download graph colors theme[download_start]="#367bf0" theme[download_mid]="#19a187" theme[download_end]="#4aaee6" # Upload graph colors theme[upload_start]="#8c42ab" theme[upload_mid]="#b8174c" theme[upload_end]="#d41919" aristocratos-btop-d43a485/themes/flat-remix.theme000066400000000000000000000043351517514752700221330ustar00rootroot00000000000000#Bashtop theme with flat-remix colors #by Daniel Ruiz de Alegrรญa # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="" # Main text color theme[main_fg]="#E6E6E6" # Title color for boxes theme[title]="#ff" # Highlight color for keyboard shortcuts theme[hi_fg]="#90" # Background color of selected item in processes box theme[selected_bg]="#b8174c" # Foreground color of selected item in processes box theme[selected_fg]="#ff" # Color of inactive/disabled text theme[inactive_fg]="#40" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#367bf0" # Cpu box outline color theme[cpu_box]="#367bf0" # Memory/disks box outline color theme[mem_box]="#19a187" # Net up/down box outline color theme[net_box]="#fd3535" # Processes box outline color theme[proc_box]="#4aaee6" # Box divider line and small boxes line color theme[div_line]="#50" # Temperature graph colors theme[temp_start]="#367bf0" theme[temp_mid]="#b8174c" theme[temp_end]="#d41919" # CPU graph colors theme[cpu_start]="#367bf0" theme[cpu_mid]="#4aaee6" theme[cpu_end]="#54bd8e" # Mem/Disk free meter theme[free_start]="#811035" theme[free_mid]="#b8174c" theme[free_end]="#d41919" # Mem/Disk cached meter theme[cached_start]="#2656a8" theme[cached_mid]="#4aaee6" theme[cached_end]="#23bac2" # Mem/Disk available meter theme[available_start]="#fea44c" theme[available_mid]="#fd7d00" theme[available_end]="#fe7171" # Mem/Disk used meter theme[used_start]="#12715f" theme[used_mid]="#19a187" theme[used_end]="#23bac2" # Download graph colors theme[download_start]="#367bf0" theme[download_mid]="#19a187" theme[download_end]="#4aaee6" # Upload graph colors theme[upload_start]="#8c42ab" theme[upload_mid]="#b8174c" theme[upload_end]="#d41919" aristocratos-btop-d43a485/themes/flexoki-dark.theme000066400000000000000000000054571517514752700224510ustar00rootroot00000000000000# Flexoki Dark theme (https://stephango.com/flexoki) # by Steph Ango # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#100F0F" # Main text color theme[main_fg]="#CECDC3" # Title color for boxes theme[title]="#FFFCF0" # Highlight color for keyboard shortcuts theme[hi_fg]="#DA702C" # Background color of selected item in processes box theme[selected_bg]="#403E3C" # Foreground color of selected item in processes box theme[selected_fg]="#FFFCF0" # Color of inactive/disabled text theme[inactive_fg]="#575653" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#878580" # Background color of the percentage meters theme[meter_bg]="#343331" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#879A39" # Cpu box outline color theme[cpu_box]="#4385BE" # Memory/disks box outline color theme[mem_box]="#879A39" # Net up/down box outline color theme[net_box]="#CE5D97" # Processes box outline color theme[proc_box]="#3AA99F" # Box divider line and small boxes line color theme[div_line]="#403E3C" # Temperature graph colors theme[temp_start]="#4385BE" theme[temp_mid]="#8B7EC8" theme[temp_end]="#D14D41" # CPU graph colors theme[cpu_start]="#3AA99F" theme[cpu_mid]="#D0A215" theme[cpu_end]="#D14D41" # Mem/Disk free meter theme[free_start]="#343331" theme[free_mid]="#575653" theme[free_end]="#879A39" # Mem/Disk cached meter theme[cached_start]="#205EA6" theme[cached_mid]="#4385BE" theme[cached_end]="#3AA99F" # Mem/Disk available meter theme[available_start]="#AD8301" theme[available_mid]="#D0A215" theme[available_end]="#DA702C" # Mem/Disk used meter theme[used_start]="#879A39" theme[used_mid]="#DA702C" theme[used_end]="#D14D41" # Download graph colors theme[download_start]="#205EA6" theme[download_mid]="#4385BE" theme[download_end]="#3AA99F" # Upload graph colors theme[upload_start]="#A02F6F" theme[upload_mid]="#CE5D97" theme[upload_end]="#8B7EC8" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#879A39" theme[process_mid]="#D0A215" theme[process_end]="#D14D41" # Process box banner colors theme[proc_pause_bg]="#D14D41" theme[proc_follow_bg]="#4385BE" theme[proc_banner_bg]="#8B7EC8" theme[proc_banner_fg]="#FFFCF0" # Process following attributes theme[followed_bg]="#4385BE" theme[followed_fg]="#FFFCF0" aristocratos-btop-d43a485/themes/flexoki-light.theme000066400000000000000000000054601517514752700226310ustar00rootroot00000000000000# Flexoki Light theme (https://stephango.com/flexoki) # by Steph Ango # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#FFFCF0" # Main text color theme[main_fg]="#343331" # Title color for boxes theme[title]="#100F0F" # Highlight color for keyboard shortcuts theme[hi_fg]="#BC5215" # Background color of selected item in processes box theme[selected_bg]="#E6E4D9" # Foreground color of selected item in processes box theme[selected_fg]="#100F0F" # Color of inactive/disabled text theme[inactive_fg]="#B7B5AC" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#6F6E69" # Background color of the percentage meters theme[meter_bg]="#DAD8CE" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#66800B" # Cpu box outline color theme[cpu_box]="#205EA6" # Memory/disks box outline color theme[mem_box]="#66800B" # Net up/down box outline color theme[net_box]="#A02F6F" # Processes box outline color theme[proc_box]="#24837B" # Box divider line and small boxes line color theme[div_line]="#CECDC3" # Temperature graph colors theme[temp_start]="#205EA6" theme[temp_mid]="#5E409D" theme[temp_end]="#AF3029" # CPU graph colors theme[cpu_start]="#24837B" theme[cpu_mid]="#AD8301" theme[cpu_end]="#AF3029" # Mem/Disk free meter theme[free_start]="#DAD8CE" theme[free_mid]="#B7B5AC" theme[free_end]="#66800B" # Mem/Disk cached meter theme[cached_start]="#4385BE" theme[cached_mid]="#205EA6" theme[cached_end]="#24837B" # Mem/Disk available meter theme[available_start]="#D0A215" theme[available_mid]="#AD8301" theme[available_end]="#BC5215" # Mem/Disk used meter theme[used_start]="#66800B" theme[used_mid]="#BC5215" theme[used_end]="#AF3029" # Download graph colors theme[download_start]="#4385BE" theme[download_mid]="#205EA6" theme[download_end]="#24837B" # Upload graph colors theme[upload_start]="#CE5D97" theme[upload_mid]="#A02F6F" theme[upload_end]="#5E409D" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#66800B" theme[process_mid]="#AD8301" theme[process_end]="#AF3029" # Process box banner colors theme[proc_pause_bg]="#AF3029" theme[proc_follow_bg]="#205EA6" theme[proc_banner_bg]="#5E409D" theme[proc_banner_fg]="#FFFCF0" # Process following attributes theme[followed_bg]="#205EA6" theme[followed_fg]="#FFFCF0" aristocratos-btop-d43a485/themes/gotham.theme000066400000000000000000000045541517514752700213450ustar00rootroot00000000000000# btop theme with the Gotham colorscheme for vim/neovim # Credit to Andrea Lopardi (https://github.com/whatyouhide/vim-gotham) # Adapted by jrebs (https://github.com/jrebs) # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#2E3440" # Main text color theme[main_fg]="#99d1ce" # Title color for boxes theme[title]="#2aa889" # Highlight color for keyboard shortcuts theme[hi_fg]="#ffffff" # Background color of selected item in processes box theme[selected_bg]="#0a3749" # Foreground color of selected item in processes box theme[selected_fg]="#99d1ce" # Color of inactive/disabled text #theme[inactive_fg]="#a89984" theme[inactive_fg]="#403b34" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#a89984" # Cpu box outline color theme[cpu_box]="#99d1ce" # Memory/disks box outline color theme[mem_box]="#99d1ce" # Net up/down box outline color theme[net_box]="#99d1ce" # Processes box outline color theme[proc_box]="#99d1ce" # Box divider line and small boxes line color theme[div_line]="#4C566A" # Temperature graph colors theme[temp_start]="#2aa889" theme[temp_mid]="#99d1ce" theme[temp_end]="#ffffff" # CPU graph colors theme[cpu_start]="#2aa889" theme[cpu_mid]="#99d1ce" theme[cpu_end]="#ffffff" # Mem/Disk free meter theme[free_start]="#2aa889" theme[free_mid]="#99d1ce" theme[free_end]="#ffffff" # Mem/Disk cached meter theme[cached_start]="#2aa889" theme[cached_mid]="#99d1ce" theme[cached_end]="#ffffff" # Mem/Disk available meter theme[available_start]="#2aa889" theme[available_mid]="#99d1ce" theme[available_end]="#ffffff" # Mem/Disk used meter theme[used_start]="#2aa889" theme[used_mid]="#99d1ce" theme[used_end]="#ffffff" # Download graph colors theme[download_start]="#2aa889" theme[download_mid]="#99d1ce" theme[download_end]="#ffffff" # Upload graph colors theme[upload_start]="#2aa889" theme[upload_mid]="#99d1ce" theme[upload_end]="#ffffff" aristocratos-btop-d43a485/themes/greyscale.theme000066400000000000000000000040371517514752700220400ustar00rootroot00000000000000#Bashtop grayscale theme #by aristocratos # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#00" # Main text color theme[main_fg]="#bb" # Title color for boxes theme[title]="#cc" # Highlight color for keyboard shortcuts theme[hi_fg]="#90" # Background color of selected item in processes box theme[selected_bg]="#ff" # Foreground color of selected item in processes box theme[selected_fg]="#00" # Color of inactive/disabled text theme[inactive_fg]="#30" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#90" # Cpu box outline color theme[cpu_box]="#90" # Memory/disks box outline color theme[mem_box]="#90" # Net up/down box outline color theme[net_box]="#90" # Processes box outline color theme[proc_box]="#90" # Box divider line and small boxes line color theme[div_line]="#30" # Temperature graph colors theme[temp_start]="#50" theme[temp_mid]="" theme[temp_end]="#ff" # CPU graph colors theme[cpu_start]="#50" theme[cpu_mid]="" theme[cpu_end]="#ff" # Mem/Disk free meter theme[free_start]="#50" theme[free_mid]="" theme[free_end]="#ff" # Mem/Disk cached meter theme[cached_start]="#50" theme[cached_mid]="" theme[cached_end]="#ff" # Mem/Disk available meter theme[available_start]="#50" theme[available_mid]="" theme[available_end]="#ff" # Mem/Disk used meter theme[used_start]="#50" theme[used_mid]="" theme[used_end]="#ff" # Download graph colors theme[download_start]="#30" theme[download_mid]="" theme[download_end]="#ff" # Upload graph colors theme[upload_start]="#30" theme[upload_mid]="" theme[upload_end]="#ff"aristocratos-btop-d43a485/themes/gruvbox_dark.theme000066400000000000000000000044461517514752700225630ustar00rootroot00000000000000#Bashtop gruvbox (https://github.com/morhetz/gruvbox) theme #by BachoSeven # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#1d2021" # Main text color theme[main_fg]="#a89984" # Title color for boxes theme[title]="#ebdbb2" # Highlight color for keyboard shortcuts theme[hi_fg]="#d79921" # Background color of selected items theme[selected_bg]="#282828" # Foreground color of selected items theme[selected_fg]="#fabd2f" # Color of inactive/disabled text theme[inactive_fg]="#282828" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#585858" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#98971a" # Cpu box outline color theme[cpu_box]="#a89984" # Memory/disks box outline color theme[mem_box]="#a89984" # Net up/down box outline color theme[net_box]="#a89984" # Processes box outline color theme[proc_box]="#a89984" # Box divider line and small boxes line color theme[div_line]="#a89984" # Temperature graph colors theme[temp_start]="#458588" theme[temp_mid]="#d3869b" theme[temp_end]="#fb4394" # CPU graph colors theme[cpu_start]="#b8bb26" theme[cpu_mid]="#d79921" theme[cpu_end]="#fb4934" # Mem/Disk free meter theme[free_start]="#4e5900" theme[free_mid]="" theme[free_end]="#98971a" # Mem/Disk cached meter theme[cached_start]="#458588" theme[cached_mid]="" theme[cached_end]="#83a598" # Mem/Disk available meter theme[available_start]="#d79921" theme[available_mid]="" theme[available_end]="#fabd2f" # Mem/Disk used meter theme[used_start]="#cc241d" theme[used_mid]="" theme[used_end]="#fb4934" # Download graph colors theme[download_start]="#3d4070" theme[download_mid]="#6c71c4" theme[download_end]="#a3a8f7" # Upload graph colors theme[upload_start]="#701c45" theme[upload_mid]="#b16286" theme[upload_end]="#d3869b" aristocratos-btop-d43a485/themes/gruvbox_dark_v2.theme000066400000000000000000000050711517514752700231650ustar00rootroot00000000000000# Bashtop gruvbox (https://github.com/morhetz/gruvbox) theme # First version created By BachoSeven # Adjustments to proper colors by Pietryszak (https://github.com/pietryszak/) # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#282828" # Main text color theme[main_fg]="#EBDBB2" # Title color for boxes theme[title]="#EBDBB2" # Highlight color for keyboard shortcuts theme[hi_fg]="#CC241D" # Background color of selected items theme[selected_bg]="#32302F" # Foreground color of selected items theme[selected_fg]="#D3869B" # Color of inactive/disabled text theme[inactive_fg]="#3C3836" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#A89984" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#98971A" # Cpu box outline color theme[cpu_box]="#A89984" # Memory/disks box outline color theme[mem_box]="#A89984" # Net up/down box outline color theme[net_box]="#A89984" # Processes box outline color theme[proc_box]="#A89984" # Box divider line and small boxes line color theme[div_line]="#A89984" # Temperature graph colors theme[temp_start]="#98971A" theme[temp_mid]="" theme[temp_end]="#CC241D" # CPU graph colors theme[cpu_start]="#8EC07C" theme[cpu_mid]="#D79921" theme[cpu_end]="#CC241D" # Mem/Disk free meter theme[free_start]="#CC241D" theme[free_mid]="#D79921" theme[free_end]="#8EC07C" # Mem/Disk cached meter theme[cached_start]="#458588" theme[cached_mid]="#83A598" theme[cached_end]="#8EC07C" # Mem/Disk available meter theme[available_start]="#CC241D" theme[available_mid]="#D65D0E" theme[available_end]="#FABD2F" # Mem/Disk used meter theme[used_start]="#8EC07C" theme[used_mid]="#D65D0E" theme[used_end]="#CC241D" # Download graph colors theme[download_start]="#98971A" theme[download_mid]="#689d6A" theme[download_end]="#B8BB26" # Upload graph colors theme[upload_start]="#CC241D" theme[upload_mid]="#D65d0E" theme[upload_end]="#FABF2F" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#8EC07C" theme[process_mid]="#FE8019" theme[process_end]="#CC241D" aristocratos-btop-d43a485/themes/gruvbox_light.theme000066400000000000000000000040411517514752700227400ustar00rootroot00000000000000# Btop gruvbox_light theme # by kk9uk # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#fbf1c7" # Main text color theme[main_fg]="#3c3836" # Title color for boxes theme[title]="#3c3836" # Highlight color for keyboard shortcuts theme[hi_fg]="#cc241d" # Background color of selected items theme[selected_bg]="#f2e5bc" # Foreground color of selected items theme[selected_fg]="#8f3f71" # Color of inactive/disabled text theme[inactive_fg]="#ebdbb2" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#a89984" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#98971a" # Cpu box outline color theme[cpu_box]="#a89984" # Memory/disks box outline color theme[mem_box]="#a89984" # Net up/down box outline color theme[net_box]="#a89984" # Processes box outline color theme[proc_box]="#a89984" # Box divider line and small boxes line color theme[div_line]="#a89984" # Temperature graph colors theme[temp_start]="#98971a" theme[temp_mid]="" theme[temp_end]="#cc241d" # CPU graph colors theme[cpu_start]="#427b58" theme[cpu_mid]="#d79921" theme[cpu_end]="#cc241d" # Mem/Disk free meter theme[free_start]="#cc241d" theme[free_mid]="#d79921" theme[free_end]="#427b58" # Mem/Disk cached meter theme[cached_start]="#458588" theme[cached_mid]="#076678" theme[cached_end]="#427b58" # Mem/Disk available meter theme[available_start]="#cc241d" theme[available_mid]="#d65d0e" theme[available_end]="#b57614" # Mem/Disk used meter theme[used_start]="#427b58" theme[used_mid]="#d65d0e" theme[used_end]="#cc241d" # Download graph colors theme[download_start]="#98971a" theme[download_mid]="#689d6a" theme[download_end]="#79740e" # Upload graph colors theme[upload_start]="#cc241d" theme[upload_mid]="#d65d0e" theme[upload_end]="#b57614" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#427b58" theme[process_mid]="#af3a03" theme[process_end]="#cc241d" aristocratos-btop-d43a485/themes/gruvbox_material_dark.theme000066400000000000000000000044111517514752700244310ustar00rootroot00000000000000# Btop gruvbox material dark (https://github.com/sainnhe/gruvbox-material) theme # by Marco Radocchia # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#282828" # Main text color theme[main_fg]="#d4be98" # Title color for boxes theme[title]="#d4be98" # Highlight color for keyboard shortcuts theme[hi_fg]="#ea6962" # Background color of selected items theme[selected_bg]="#d8a657" # Foreground color of selected items theme[selected_fg]="#282828" # Color of inactive/disabled text theme[inactive_fg]="#282828" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#665c54" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#a9b665" # Cpu box outline color theme[cpu_box]="#7c6f64" # Memory/disks box outline color theme[mem_box]="#7c6f64" # Net up/down box outline color theme[net_box]="#7c6f64" # Processes box outline color theme[proc_box]="#7c6f64" # Box divider line and small boxes line color theme[div_line]="#7c6f64" # Temperature graph colors theme[temp_start]="#7daea3" theme[temp_mid]="#e78a4e" theme[temp_end]="#ea6962" # CPU graph colors theme[cpu_start]="#a9b665" theme[cpu_mid]="#d8a657" theme[cpu_end]="#ea6962" # Mem/Disk free meter theme[free_start]="#89b482" theme[free_mid]="" theme[free_end]="" # Mem/Disk cached meter theme[cached_start]="#7daea3" theme[cached_mid]="" theme[cached_end]="" # Mem/Disk available meter theme[available_start]="#d8a657" theme[available_mid]="" theme[available_end]="" # Mem/Disk used meter theme[used_start]="#ea6962" theme[used_mid]="" theme[used_end]="" # Download graph colors theme[download_start]="#e78a4e" theme[download_mid]="" theme[download_end]="" # Upload graph colors theme[upload_start]="#d3869b" theme[upload_mid]="" theme[upload_end]="" aristocratos-btop-d43a485/themes/horizon.theme000066400000000000000000000041041517514752700215450ustar00rootroot00000000000000# All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#1C1E26" # Main text color theme[main_fg]="#f8f8f2" # Title color for boxes theme[title]="#f8f8f2" # Highlight color for keyboard shortcuts theme[hi_fg]="#B877DB" # Background color of selected items theme[selected_bg]="#282b37" # Foreground color of selected items theme[selected_fg]="#f8f8f2" # Color of inactive/disabled text theme[inactive_fg]="#272e33" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#f8f8f2" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#27D796" # Cpu box outline color theme[cpu_box]="#B877DB" # Memory/disks box outline color theme[mem_box]="#27D796" # Net up/down box outline color theme[net_box]="#E95678" # Processes box outline color theme[proc_box]="#25B2BC" # Box divider line and small boxes line color theme[div_line]="#272e33" # Temperature graph colors theme[temp_start]="#27D796" theme[temp_mid]="#FAC29A" theme[temp_end]="#E95678" # CPU graph colors theme[cpu_start]="#27D796" theme[cpu_mid]="#FAC29A" theme[cpu_end]="#E95678" # Mem/Disk free meter theme[free_start]="#E95678" theme[free_mid]="#FAC29A" theme[free_end]="#27D796" # Mem/Disk cached meter theme[cached_start]="#27D796" theme[cached_mid]="#FAC29A" theme[cached_end]="#E95678" # Mem/Disk available meter theme[available_start]="#27D796" theme[available_mid]="#FAC29A" theme[available_end]="#E95678" # Mem/Disk used meter theme[used_start]="#27D796" theme[used_mid]="#FAC29A" theme[used_end]="#E95678" # Download graph colors theme[download_start]="#27D796" theme[download_mid]="#FAC29A" theme[download_end]="#E95678" # Upload graph colors theme[upload_start]="#27D796" theme[upload_mid]="#FAC29A" theme[upload_end]="#E95678" aristocratos-btop-d43a485/themes/kanagawa-dragon.theme000066400000000000000000000036541517514752700231100ustar00rootroot00000000000000# Bashtop Kanagawa-dragon (https://github.com/rebelot/kanagawa.nvim) theme # By: Marcus441 # Main bg theme[main_bg]="#181616" # Main text color theme[main_fg]="#c5c9c5" # Title color for boxes theme[title]="#c5c9c5" # Highlight color for keyboard shortcuts theme[hi_fg]="#c4746e" # Background color of selected item in processes box theme[selected_bg]="#282727" # Foreground color of selected item in processes box theme[selected_fg]="#c4b28a" # Color of inactive/disabled text theme[inactive_fg]="#7a8382" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#8ea4a2" # Cpu box outline color theme[cpu_box]="#7a8382" # Memory/disks box outline color theme[mem_box]="#7a8382" # Net up/down box outline color theme[net_box]="#7a8382" # Processes box outline color theme[proc_box]="#7a8382" # Box divider line and small boxes line color theme[div_line]="#7a8382" # Temperature graph colors theme[temp_start]="#8a9a7b" theme[temp_mid]="#b6927b" theme[temp_end]="#c4746e" # CPU graph colors theme[cpu_start]="#87a987" theme[cpu_mid]="#c4b28a" theme[cpu_end]="#c4746e" # Mem/Disk free meter theme[free_start]="#c4746e" theme[free_mid]="#a292a3" theme[free_end]="#c4746e" # Mem/Disk cached meter theme[cached_start]="#8a9a7b" theme[cached_mid]="#b6927b" theme[cached_end]="#b6927b" # Mem/Disk available meter theme[available_start]="#8992a7" theme[available_mid]="#949fb5" theme[available_end]="#8ba4b0" # Mem/Disk used meter theme[used_start]="#8ba4b0" theme[used_mid]="#949fb5" theme[used_end]="#8ea4a2" # Download graph colors theme[download_start]="#949fb5" theme[download_mid]="#8992a7" theme[download_end]="#a292a3" # Upload graph colors theme[upload_start]="#b6927b" theme[upload_mid]="#c4b28a" theme[upload_end]="#c4746e" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#87a987" theme[process_mid]="#c4b28a" theme[process_end]="#c4746e" aristocratos-btop-d43a485/themes/kanagawa-lotus.theme000066400000000000000000000036541517514752700230040ustar00rootroot00000000000000# Bashtop Kanagawa-lotus (https://github.com/rebelot/kanagawa.nvim) theme # By: philikarus # Main bg theme[main_bg]="#F2ECBC" # Main text color theme[main_fg]="#545464" # Title color for boxes theme[title]="#545464" # Highlight color for keyboard shortcuts theme[hi_fg]="#C84053" # Background color of selected item in processes box theme[selected_bg]="#c9cbd1" # Foreground color of selected item in processes box theme[selected_fg]="#43436c" # Color of inactive/disabled text theme[inactive_fg]="#8A8980" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#597B75" # Cpu box outline color theme[cpu_box]="#8A8980" # Memory/disks box outline color theme[mem_box]="#8A8980" # Net up/down box outline color theme[net_box]="#8A8980" # Processes box outline color theme[proc_box]="#8A8980" # Box divider line and small boxes line color theme[div_line]="#8A8980" # Temperature graph colors theme[temp_start]="#6E915F" theme[temp_mid]="#CC6D00" theme[temp_end]="#D7474B" # CPU graph colors theme[cpu_start]="#6E915F" theme[cpu_mid]="#CC6D00" theme[cpu_end]="#D7474B" # Mem/Disk free meter theme[free_start]="#D7474B" theme[free_mid]="#C84053" theme[free_end]="#FF5D62" # Mem/Disk cached meter theme[cached_start]="#77713F" theme[cached_mid]="#CC6D00" theme[cached_end]="#FF9E3B" # Mem/Disk available meter theme[available_start]="#766b90" theme[available_mid]="#624c83" theme[available_end]="#9fb5c9" # Mem/Disk used meter theme[used_start]="#B5CBD2" theme[used_mid]="#4d699b" theme[used_end]="#4e8ca2" # Download graph colors theme[download_start]="#4d699b" theme[download_mid]="#624c83" theme[download_end]="#766b90" # Upload graph colors theme[upload_start]="#CC6D00" theme[upload_mid]="#E98A00" theme[upload_end]="#D7474B" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#6E915F" theme[process_mid]="#CC6D00" theme[process_end]="#C84053" aristocratos-btop-d43a485/themes/kanagawa-wave.theme000066400000000000000000000036531517514752700225770ustar00rootroot00000000000000# Bashtop Kanagawa-wave (https://github.com/rebelot/kanagawa.nvim) theme # By: philikarus # Main bg theme[main_bg]="#16161D" # Main text color theme[main_fg]="#dcd7ba" # Title color for boxes theme[title]="#dcd7ba" # Highlight color for keyboard shortcuts theme[hi_fg]="#C34043" # Background color of selected item in processes box theme[selected_bg]="#223249" # Foreground color of selected item in processes box theme[selected_fg]="#dca561" # Color of inactive/disabled text theme[inactive_fg]="#727169" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#7aa89f" # Cpu box outline color theme[cpu_box]="#727169" # Memory/disks box outline color theme[mem_box]="#727169" # Net up/down box outline color theme[net_box]="#727169" # Processes box outline color theme[proc_box]="#727169" # Box divider line and small boxes line color theme[div_line]="#727169" # Temperature graph colors theme[temp_start]="#98BB6C" theme[temp_mid]="#DCA561" theme[temp_end]="#E82424" # CPU graph colors theme[cpu_start]="#98BB6C" theme[cpu_mid]="#DCA561" theme[cpu_end]="#E82424" # Mem/Disk free meter theme[free_start]="#E82424" theme[free_mid]="#C34043" theme[free_end]="#FF5D62" # Mem/Disk cached meter theme[cached_start]="#C0A36E" theme[cached_mid]="#DCA561" theme[cached_end]="#FF9E3B" # Mem/Disk available meter theme[available_start]="#938AA9" theme[available_mid]="#957FBB" theme[available_end]="#9CABCA" # Mem/Disk used meter theme[used_start]="#658594" theme[used_mid]="#7E9CDB" theme[used_end]="#7FB4CA" # Download graph colors theme[download_start]="#7E9CDB" theme[download_mid]="#938AA9" theme[download_end]="#957FBB" # Upload graph colors theme[upload_start]="#DCA561" theme[upload_mid]="#E6C384" theme[upload_end]="#E82424" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#98BB6C" theme[process_mid]="#DCA561" theme[process_end]="#C34043" aristocratos-btop-d43a485/themes/kyli0x.theme000066400000000000000000000042371517514752700213040ustar00rootroot00000000000000#Bashtop Kyli0x Theme #by Kyli0x # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#222222" # Main text color theme[main_fg]="#e8f6f5" # Title color for boxes theme[title]="#e8f6f5" # Highlight color for keyboard shortcuts theme[hi_fg]="#21d6c9" # Background color of selected item in processes box theme[selected_bg]="#1aaba0" # Foreground color of selected item in processes box theme[selected_fg]="#e8f6f5" # Color of inactive/disabled text theme[inactive_fg]="#5ec4bc" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#ba1a84" # Background color of the percentage meters theme[meter_bg]="#5ec4bc" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#21d6c9" # Cpu box outline color theme[cpu_box]="#d486d4" # Memory/disks box outline color theme[mem_box]="#d486d4" # Net up/down box outline color theme[net_box]="#d486d4" # Processes box outline color theme[proc_box]="#d486d4" # Box divider line and small boxes line color theme[div_line]="#80638e" # Temperature graph colors theme[temp_start]="#21d6c9" theme[temp_mid]="#1aaba0" theme[temp_end]="#5ec4bc" # CPU graph colors theme[cpu_start]="#21d6c9" theme[cpu_mid]="#1aaba0" theme[cpu_end]="#5ec4bc" # Mem/Disk free meter theme[free_start]="#21d6c9" theme[free_mid]="#1aaba0" theme[free_end]="#5ec4bc" # Mem/Disk cached meter theme[cached_start]="#21d6c9" theme[cached_mid]="#1aaba0" theme[cached_end]="#5ec4bc" # Mem/Disk available meter theme[available_start]="#21d6c9" theme[available_mid]="#1aaba0" theme[available_end]="#5ec4bc" # Mem/Disk used meter theme[used_start]="#21d6c9" theme[used_mid]="#1aaba0" theme[used_end]="#5ec4bc" # Download graph colors theme[download_start]="#21d6c9" theme[download_mid]="#1aaba0" theme[download_end]="#5ec4bc" # Upload graph colors theme[upload_start]="#ec95ec" theme[upload_mid]="#1aaba0" theme[upload_end]="#5ec4bc" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#21d6c9" theme[process_mid]="#1aaba0" theme[process_end]="#ba1a84" aristocratos-btop-d43a485/themes/matcha-dark-sea.theme000066400000000000000000000045131517514752700230030ustar00rootroot00000000000000#Bashtop matcha-dark-sea theme #by TheCynicalTeam # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="" # Main text color theme[main_fg]="#F8F8F2" # Title color for boxes theme[title]="#F8F8F2" # Highlight color for keyboard shortcuts theme[hi_fg]="#2eb398" # Background color of selected item in processes box theme[selected_bg]="#0d493d" # Foreground color of selected item in processes box theme[selected_fg]="#F8F8F2" # Color of inactive/disabled text theme[inactive_fg]="#595647" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#797667" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#33b165" # Cpu box outline color theme[cpu_box]="#75715E" # Memory/disks box outline color theme[mem_box]="#75715E" # Net up/down box outline color theme[net_box]="#75715E" # Processes box outline color theme[proc_box]="#75715E" # Box divider line and small boxes line color theme[div_line]="#595647" # Temperature graph colors theme[temp_start]="#7976B7" theme[temp_mid]="#D8B8B2" theme[temp_end]="#33b165" # CPU graph colors theme[cpu_start]="#33b165" theme[cpu_mid]="#F8F8F2" #2eb398" theme[cpu_end]="#2eb398" # Mem/Disk free meter theme[free_start]="#75715E" theme[free_mid]="#a9c474" theme[free_end]="#e2f5bc" # Mem/Disk cached meter theme[cached_start]="#75715E" theme[cached_mid]="#66D9EF" theme[cached_end]="#aae7f2" # Mem/Disk available meter theme[available_start]="#75715E" theme[available_mid]="#E6DB74" theme[available_end]="#f2ecb6" # Mem/Disk used meter theme[used_start]="#75715E" theme[used_mid]="#2eb398" theme[used_end]="#33b165" # Download graph colors theme[download_start]="#2d2042" theme[download_mid]="#2eb398" theme[download_end]="#33b165" # Upload graph colors theme[upload_start]="#0d493d" theme[upload_mid]="#2eb398" theme[upload_end]="#33b165" aristocratos-btop-d43a485/themes/monokai.theme000066400000000000000000000045101517514752700215130ustar00rootroot00000000000000#Bashtop monokai theme #by aristocratos # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#060604" # Main text color theme[main_fg]="#F8F8F2" # Title color for boxes theme[title]="#F8F8F2" # Highlight color for keyboard shortcuts theme[hi_fg]="#F92672" # Background color of selected item in processes box theme[selected_bg]="#7a1137" # Foreground color of selected item in processes box theme[selected_fg]="#F8F8F2" # Color of inactive/disabled text theme[inactive_fg]="#595647" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#797667" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#A6E22E" # Cpu box outline color theme[cpu_box]="#75715E" # Memory/disks box outline color theme[mem_box]="#75715E" # Net up/down box outline color theme[net_box]="#75715E" # Processes box outline color theme[proc_box]="#75715E" # Box divider line and small boxes line color theme[div_line]="#595647" # Temperature graph colors theme[temp_start]="#7976B7" theme[temp_mid]="#D8B8B2" theme[temp_end]="#F92672" # CPU graph colors theme[cpu_start]="#A6E22E" theme[cpu_mid]="#F8F8F2" #b05475" theme[cpu_end]="#F92672" # Mem/Disk free meter theme[free_start]="#75715E" theme[free_mid]="#a9c474" theme[free_end]="#e2f5bc" # Mem/Disk cached meter theme[cached_start]="#75715E" theme[cached_mid]="#66D9EF" theme[cached_end]="#aae7f2" # Mem/Disk available meter theme[available_start]="#75715E" theme[available_mid]="#E6DB74" theme[available_end]="#f2ecb6" # Mem/Disk used meter theme[used_start]="#75715E" theme[used_mid]="#F92672" theme[used_end]="#ff87b2" # Download graph colors theme[download_start]="#2d2042" theme[download_mid]="#7352a8" theme[download_end]="#ccaefc" # Upload graph colors theme[upload_start]="#570d33" theme[upload_mid]="#cf277d" theme[upload_end]="#fa91c7" aristocratos-btop-d43a485/themes/night-owl.theme000066400000000000000000000044161517514752700217730ustar00rootroot00000000000000#Bashtop theme with night-owl colors #by zkourouma # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#011627" # Main text color theme[main_fg]="#d6deeb" # Title color for boxes theme[title]="#ffffff" # Highlight color for keyboard shortcuts theme[hi_fg]="#addb67" # Background color of selected items theme[selected_bg]="#000000" # Foreground color of selected items theme[selected_fg]="#ffeb95" # Color of inactive/disabled text theme[inactive_fg]="#575656" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#585858" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#22da6e" # Cpu box outline color theme[cpu_box]="#ffffff" # Memory/disks box outline color theme[mem_box]="#ffffff" # Net up/down box outline color theme[net_box]="#ffffff" # Processes box outline color theme[proc_box]="#ffffff" # Box divider line and small boxes line color theme[div_line]="#ffffff" # Temperature graph colors theme[temp_start]="#82aaff" theme[temp_mid]="#c792ea" theme[temp_end]="#fb4394" # CPU graph colors theme[cpu_start]="#22da6e" theme[cpu_mid]="#addb67" theme[cpu_end]="#ef5350" # Mem/Disk free meter theme[free_start]="#4e5900" theme[free_mid]="" theme[free_end]="#22da6e" # Mem/Disk cached meter theme[cached_start]="#82aaff" theme[cached_mid]="" theme[cached_end]="#82aaff" # Mem/Disk available meter theme[available_start]="#addb67" theme[available_mid]="" theme[available_end]="#ffeb95" # Mem/Disk used meter theme[used_start]="#ef5350" theme[used_mid]="" theme[used_end]="#ef5350" # Download graph colors theme[download_start]="#3d4070" theme[download_mid]="#6c71c4" theme[download_end]="#a3a8f7" # Upload graph colors theme[upload_start]="#701c45" theme[upload_mid]="#c792ea" theme[upload_end]="#c792ea" aristocratos-btop-d43a485/themes/nord.theme000066400000000000000000000044101517514752700210170ustar00rootroot00000000000000#Bashtop theme with nord palette (https://www.nordtheme.com) #by Justin Zobel # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#2E3440" # Main text color theme[main_fg]="#D8DEE9" # Title color for boxes theme[title]="#8FBCBB" # Highlight color for keyboard shortcuts theme[hi_fg]="#5E81AC" # Background color of selected item in processes box theme[selected_bg]="#4C566A" # Foreground color of selected item in processes box theme[selected_fg]="#ECEFF4" # Color of inactive/disabled text theme[inactive_fg]="#4C566A" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#5E81AC" # Cpu box outline color theme[cpu_box]="#4C566A" # Memory/disks box outline color theme[mem_box]="#4C566A" # Net up/down box outline color theme[net_box]="#4C566A" # Processes box outline color theme[proc_box]="#4C566A" # Box divider line and small boxes line color theme[div_line]="#4C566A" # Temperature graph colors theme[temp_start]="#81A1C1" theme[temp_mid]="#88C0D0" theme[temp_end]="#ECEFF4" # CPU graph colors theme[cpu_start]="#81A1C1" theme[cpu_mid]="#88C0D0" theme[cpu_end]="#ECEFF4" # Mem/Disk free meter theme[free_start]="#81A1C1" theme[free_mid]="#88C0D0" theme[free_end]="#ECEFF4" # Mem/Disk cached meter theme[cached_start]="#81A1C1" theme[cached_mid]="#88C0D0" theme[cached_end]="#ECEFF4" # Mem/Disk available meter theme[available_start]="#81A1C1" theme[available_mid]="#88C0D0" theme[available_end]="#ECEFF4" # Mem/Disk used meter theme[used_start]="#81A1C1" theme[used_mid]="#88C0D0" theme[used_end]="#ECEFF4" # Download graph colors theme[download_start]="#81A1C1" theme[download_mid]="#88C0D0" theme[download_end]="#ECEFF4" # Upload graph colors theme[upload_start]="#81A1C1" theme[upload_mid]="#88C0D0" theme[upload_end]="#ECEFF4" aristocratos-btop-d43a485/themes/onedark.theme000066400000000000000000000033351517514752700215050ustar00rootroot00000000000000# Theme: OneDark # By: Vitor Melo # Main bg theme[main_bg]="#282c34" # Main text color theme[main_fg]="#abb2bf" # Title color for boxes theme[title]="#abb2bf" # Highlight color for keyboard shortcuts theme[hi_fg]="#61afef" # Background color of selected item in processes box theme[selected_bg]="#2c313c" # Foreground color of selected item in processes box theme[selected_fg]="#abb2bf" # Color of inactive/disabled text theme[inactive_fg]="#5c6370" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#61afef" # Cpu box outline color theme[cpu_box]="#5c6370" # Memory/disks box outline color theme[mem_box]="#5c6370" # Net up/down box outline color theme[net_box]="#5c6370" # Processes box outline color theme[proc_box]="#5c6370" # Box divider line and small boxes line color theme[div_line]="#5c6370" # Temperature graph colors theme[temp_start]="#98c379" theme[temp_mid]="#e5c07b" theme[temp_end]="#e06c75" # CPU graph colors theme[cpu_start]="#98c379" theme[cpu_mid]="#e5c07b" theme[cpu_end]="#e06c75" # Mem/Disk free meter theme[free_start]="#98c379" theme[free_mid]="#e5c07b" theme[free_end]="#e06c75" # Mem/Disk cached meter theme[cached_start]="#98c379" theme[cached_mid]="#e5c07b" theme[cached_end]="#e06c75" # Mem/Disk available meter theme[available_start]="#98c379" theme[available_mid]="#e5c07b" theme[available_end]="#e06c75" # Mem/Disk used meter theme[used_start]="#98c379" theme[used_mid]="#e5c07b" theme[used_end]="#e06c75" # Download graph colors theme[download_start]="#98c379" theme[download_mid]="#e5c07b" theme[download_end]="#e06c75" # Upload graph colors theme[upload_start]="#98c379" theme[upload_mid]="#e5c07b" theme[upload_end]="#e06c75" aristocratos-btop-d43a485/themes/orange.theme000066400000000000000000000037711517514752700213410ustar00rootroot00000000000000# Btop orange theme # by neocerambyx # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#00" # Main text color theme[main_fg]="#ffa500" # Title color for boxes theme[title]="#ffa500" # Highlight color for keyboard shortcuts theme[hi_fg]="#ffcc66" # Background color of selected item in processes box theme[selected_bg]="#ffa500" # Foreground color of selected item in processes box theme[selected_fg]="#000000" # Color of inactive/disabled text theme[inactive_fg]="#4d3200" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#ffa500" # Cpu box outline color theme[cpu_box]="#ffa500" # Memory/disks box outline color theme[mem_box]="#ffa500" # Net up/down box outline color theme[net_box]="#ffa500" # Processes box outline color theme[proc_box]="#ffa500" # Box divider line and small boxes line color theme[div_line]="#332100" # Temperature graph colors theme[temp_start]="#996300" theme[temp_mid]="" theme[temp_end]="#ffa500" # CPU graph colors theme[cpu_start]="#996300" theme[cpu_mid]="" theme[cpu_end]="#ffa500" # Mem/Disk free meter theme[free_start]="#996300" theme[free_mid]="" theme[free_end]="#ffa500" # Mem/Disk cached meter theme[cached_start]="#996300" theme[cached_mid]="" theme[cached_end]="#ffa500" # Mem/Disk available meter theme[available_start]="#996300" theme[available_mid]="" theme[available_end]="#ffa500" # Mem/Disk used meter theme[used_start]="#996300" theme[used_mid]="" theme[used_end]="#ffa500" # Download graph colors theme[download_start]="#996300" theme[download_mid]="" theme[download_end]="#ffa500" # Upload graph colors theme[upload_start]="#996300" theme[upload_mid]="" theme[upload_end]="#ffa500" # Process list banner attributes theme[proc_pause_bg]="#996300" theme[proc_follow_bg]="#ffa500" theme[proc_banner_bg]="#ffcc66" theme[proc_banner_fg]="#000000" # Process following attributes theme[followed_bg]="#ffa500" theme[followed_fg]="#000000" aristocratos-btop-d43a485/themes/paper.theme000066400000000000000000000034671517514752700211770ustar00rootroot00000000000000# Bashtop Paper theme # c/o @s6muel # inspired by @yorickpeterse's vim-paper theme at https://gitlab.com/yorickpeterse/vim-paper # # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#F2EEDE" # Main text color theme[main_fg]="#00" # Title color for boxes theme[title]="#00" # Highlight color for keyboard shortcuts theme[hi_fg]="#CC3E28" # Background color of selected item in processes box theme[selected_bg]="#D8D5C7" # Foreground color of selected item in processes box theme[selected_fg]="#00" # Color of inactive/disabled text theme[inactive_fg]="#d8d5c7" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#00" # Cpu box outline color theme[cpu_box]="#00" # Memory/disks box outline color theme[mem_box]="#00" # Net up/down box outline color theme[net_box]="#00" # Processes box outline color theme[proc_box]="#00" # Box divider line and small boxes line color theme[div_line]="#00" # Temperature graph colors theme[temp_start]="#55" theme[temp_mid]="#00" theme[temp_end]="#CC3E28" # CPU graph colors theme[cpu_start]="#55" theme[cpu_mid]="#00" theme[cpu_end]="#CC3E28" # Mem/Disk free meter theme[free_start]="#216609" theme[free_mid]="" theme[free_end]="#216609" # Mem/Disk cached meter theme[cached_start]="#1e6fcc" theme[cached_mid]="" theme[cached_end]="#1e6fcc" # Mem/Disk available meter theme[available_start]="#216609" theme[available_mid]="" theme[available_end]="#216609" # Mem/Disk used meter theme[used_start]="#CC3E28" theme[used_mid]="" theme[used_end]="#CC3E28" # Download graph colors theme[download_start]="#55" theme[download_mid]="#00" theme[download_end]="#CC3E28" # Upload graph colors theme[upload_start]="#55" theme[upload_mid]="#00" theme[upload_end]="#CC3E28" aristocratos-btop-d43a485/themes/phoenix-night.theme000066400000000000000000000041461517514752700226440ustar00rootroot00000000000000# Theme: Phoenix Night # By: Firehawke # A combination of: # Base theme colors from Pascal Jaeger's tokyo-night # Graph theme colors from Pete Allebone's HotPurpleTrafficLight # ...basically, I wanted most of Tokyo Night with a significantly more visible graph bar coloration. # Main bg theme[main_bg]="#1a1b26" # Main text color theme[main_fg]="#cfc9c2" # Title color for boxes theme[title]="#cfc9c2" # Highlight color for keyboard shortcuts theme[hi_fg]="#7dcfff" # Background color of selected item in processes box theme[selected_bg]="#414868" # Foreground color of selected item in processes box theme[selected_fg]="#cfc9c2" # Color of inactive/disabled text theme[inactive_fg]="#565f89" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#7dcfff" # Cpu box outline color theme[cpu_box]="#565f89" # Memory/disks box outline color theme[mem_box]="#565f89" # Net up/down box outline color theme[net_box]="#565f89" # Processes box outline color theme[proc_box]="#565f89" # Box divider line and small boxes line color theme[div_line]="#565f89" # Temperature graph colors theme[temp_start]="#00ff00" theme[temp_mid]="#ff9933" theme[temp_end]="#ff0000" # CPU graph colors theme[cpu_start]="#00ff00" theme[cpu_mid]="#ccff66" theme[cpu_end]="#ff0000" # Mem/Disk free meter theme[free_end]="#00ff00" theme[free_mid]="#ccff66" theme[free_start]="#ff0000" # Mem/Disk cached meter theme[cached_start]="#00ff00" theme[cached_mid]="#ccff66" theme[cached_end]="#ff0000" # Mem/Disk available meter theme[available_start]="#ff0000" theme[available_mid]="#ccff66" theme[available_end]="#00ff00" # Mem/Disk used meter theme[used_start]="#00ff00" theme[used_mid]="#ccff66" theme[used_end]="#ff0000" # Download graph colors theme[download_start]="#00ff00" theme[download_mid]="#ff9933" theme[download_end]="#ff0000" # Upload graph colors theme[upload_start]="#00ff00" theme[upload_mid]="#ff9933" theme[upload_end]="#ff0000" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#9999ff" theme[process_mid]="#4d4dff" theme[process_end]="#a64dff" aristocratos-btop-d43a485/themes/solarized_dark.theme000066400000000000000000000042171517514752700230570ustar00rootroot00000000000000#Bashtop solarized theme #by aristocratos # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#002b36" # Main text color theme[main_fg]="#eee8d5" # Title color for boxes theme[title]="#fdf6e3" # Highlight color for keyboard shortcuts theme[hi_fg]="#b58900" # Background color of selected items theme[selected_bg]="#073642" # Foreground color of selected items theme[selected_fg]="#d6a200" # Color of inactive/disabled text theme[inactive_fg]="#073642" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#bad600" # Cpu box outline color theme[cpu_box]="#586e75" # Memory/disks box outline color theme[mem_box]="#586e75" # Net up/down box outline color theme[net_box]="#586e75" # Processes box outline color theme[proc_box]="#586e75" # Box divider line and small boxes line color theme[div_line]="#586e75" # Temperature graph colors theme[temp_start]="#268bd2" theme[temp_mid]="#ccb5f7" theme[temp_end]="#fc5378" # CPU graph colors theme[cpu_start]="#adc700" theme[cpu_mid]="#d6a200" theme[cpu_end]="#e65317" # Mem/Disk free meter theme[free_start]="#4e5900" theme[free_mid]="" theme[free_end]="#bad600" # Mem/Disk cached meter theme[cached_start]="#114061" theme[cached_mid]="" theme[cached_end]="#268bd2" # Mem/Disk available meter theme[available_start]="#705500" theme[available_mid]="" theme[available_end]="#edb400" # Mem/Disk used meter theme[used_start]="#6e1718" theme[used_mid]="" theme[used_end]="#e02f30" # Download graph colors theme[download_start]="#3d4070" theme[download_mid]="#6c71c4" theme[download_end]="#a3a8f7" # Upload graph colors theme[upload_start]="#701c45" theme[upload_mid]="#d33682" theme[upload_end]="#f56caf"aristocratos-btop-d43a485/themes/solarized_light.theme000066400000000000000000000042411517514752700232420ustar00rootroot00000000000000#solarized_light theme #modified from solarized_dark theme # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#fdf6e3" # Main text color theme[main_fg]="#586e75" # Title color for boxes theme[title]="#002b36" # Highlight color for keyboard shortcuts theme[hi_fg]="#b58900" # Background color of selected items theme[selected_bg]="#eee8d5" # Foreground color of selected items theme[selected_fg]="#b58900" # Color of inactive/disabled text theme[inactive_fg]="#eee8d5" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#d33682" # Cpu box outline color theme[cpu_box]="#93a1a1" # Memory/disks box outline color theme[mem_box]="#93a1a1" # Net up/down box outline color theme[net_box]="#93a1a1" # Processes box outline color theme[proc_box]="#93a1a1" # Box divider line and small boxes line color theme[div_line]="#93a1a1" # Temperature graph colors theme[temp_start]="#268bd2" theme[temp_mid]="#ccb5f7" theme[temp_end]="#fc5378" # CPU graph colors theme[cpu_start]="#adc700" theme[cpu_mid]="#d6a200" theme[cpu_end]="#e65317" # Mem/Disk free meter theme[free_start]="#4e5900" theme[free_mid]="" theme[free_end]="#bad600" # Mem/Disk cached meter theme[cached_start]="#114061" theme[cached_mid]="" theme[cached_end]="#268bd2" # Mem/Disk available meter theme[available_start]="#705500" theme[available_mid]="" theme[available_end]="#edb400" # Mem/Disk used meter theme[used_start]="#6e1718" theme[used_mid]="" theme[used_end]="#e02f30" # Download graph colors theme[download_start]="#3d4070" theme[download_mid]="#6c71c4" theme[download_end]="#a3a8f7" # Upload graph colors theme[upload_start]="#701c45" theme[upload_mid]="#d33682" theme[upload_end]="#f56caf" aristocratos-btop-d43a485/themes/tokyo-night.theme000066400000000000000000000033441517514752700223360ustar00rootroot00000000000000# Theme: tokyo-night # By: Pascal Jaeger # Main bg theme[main_bg]="#1a1b26" # Main text color theme[main_fg]="#cfc9c2" # Title color for boxes theme[title]="#cfc9c2" # Highlight color for keyboard shortcuts theme[hi_fg]="#7dcfff" # Background color of selected item in processes box theme[selected_bg]="#414868" # Foreground color of selected item in processes box theme[selected_fg]="#cfc9c2" # Color of inactive/disabled text theme[inactive_fg]="#565f89" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#7dcfff" # Cpu box outline color theme[cpu_box]="#565f89" # Memory/disks box outline color theme[mem_box]="#565f89" # Net up/down box outline color theme[net_box]="#565f89" # Processes box outline color theme[proc_box]="#565f89" # Box divider line and small boxes line color theme[div_line]="#565f89" # Temperature graph colors theme[temp_start]="#9ece6a" theme[temp_mid]="#e0af68" theme[temp_end]="#f7768e" # CPU graph colors theme[cpu_start]="#9ece6a" theme[cpu_mid]="#e0af68" theme[cpu_end]="#f7768e" # Mem/Disk free meter theme[free_start]="#9ece6a" theme[free_mid]="#e0af68" theme[free_end]="#f7768e" # Mem/Disk cached meter theme[cached_start]="#9ece6a" theme[cached_mid]="#e0af68" theme[cached_end]="#f7768e" # Mem/Disk available meter theme[available_start]="#9ece6a" theme[available_mid]="#e0af68" theme[available_end]="#f7768e" # Mem/Disk used meter theme[used_start]="#9ece6a" theme[used_mid]="#e0af68" theme[used_end]="#f7768e" # Download graph colors theme[download_start]="#9ece6a" theme[download_mid]="#e0af68" theme[download_end]="#f7768e" # Upload graph colors theme[upload_start]="#9ece6a" theme[upload_mid]="#e0af68" theme[upload_end]="#f7768e" aristocratos-btop-d43a485/themes/tokyo-storm.theme000066400000000000000000000033441517514752700223710ustar00rootroot00000000000000# Theme: tokyo-storm # By: Pascal Jaeger # Main bg theme[main_bg]="#24283b" # Main text color theme[main_fg]="#cfc9c2" # Title color for boxes theme[title]="#cfc9c2" # Highlight color for keyboard shortcuts theme[hi_fg]="#7dcfff" # Background color of selected item in processes box theme[selected_bg]="#414868" # Foreground color of selected item in processes box theme[selected_fg]="#cfc9c2" # Color of inactive/disabled text theme[inactive_fg]="#565f89" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#7dcfff" # Cpu box outline color theme[cpu_box]="#565f89" # Memory/disks box outline color theme[mem_box]="#565f89" # Net up/down box outline color theme[net_box]="#565f89" # Processes box outline color theme[proc_box]="#565f89" # Box divider line and small boxes line color theme[div_line]="#565f89" # Temperature graph colors theme[temp_start]="#9ece6a" theme[temp_mid]="#e0af68" theme[temp_end]="#f7768e" # CPU graph colors theme[cpu_start]="#9ece6a" theme[cpu_mid]="#e0af68" theme[cpu_end]="#f7768e" # Mem/Disk free meter theme[free_start]="#9ece6a" theme[free_mid]="#e0af68" theme[free_end]="#f7768e" # Mem/Disk cached meter theme[cached_start]="#9ece6a" theme[cached_mid]="#e0af68" theme[cached_end]="#f7768e" # Mem/Disk available meter theme[available_start]="#9ece6a" theme[available_mid]="#e0af68" theme[available_end]="#f7768e" # Mem/Disk used meter theme[used_start]="#9ece6a" theme[used_mid]="#e0af68" theme[used_end]="#f7768e" # Download graph colors theme[download_start]="#9ece6a" theme[download_mid]="#e0af68" theme[download_end]="#f7768e" # Upload graph colors theme[upload_start]="#9ece6a" theme[upload_mid]="#e0af68" theme[upload_end]="#f7768e" aristocratos-btop-d43a485/themes/tomorrow-night.theme000066400000000000000000000043621517514752700230620ustar00rootroot00000000000000#Nord theme but using the Tomorrow Night palette #by Appuchia # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#ffffff", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#1d1f21" # Main text color theme[main_fg]="#c5c8c6" # Title color for boxes theme[title]="#c5c8c6" # Highlight color for keyboard shortcuts theme[hi_fg]="#81beb7" # Background color of selected item in processes box theme[selected_bg]="#282a2e" # Foreground color of selected item in processes box theme[selected_fg]="#c5c8c6" # Color of inactive/disabled text theme[inactive_fg]="#373b41" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#969896" # Cpu box outline color theme[cpu_box]="#81a2be" # Memory/disks box outline color theme[mem_box]="#81a2be" # Net up/down box outline color theme[net_box]="#81a2be" # Processes box outline color theme[proc_box]="#81a2be" # Box divider line and small boxes line color theme[div_line]="#81a2be" # Temperature graph colors theme[temp_start]="#b5bd68" theme[temp_mid]="#f0c674" theme[temp_end]="#cc6666" # CPU graph colors theme[cpu_start]="#b5bd68" theme[cpu_mid]="#f0c674" theme[cpu_end]="#cc6666" # Mem/Disk free meter theme[free_start]="#b5bd68" theme[free_mid]="#f0c674" theme[free_end]="#cc6666" # Mem/Disk cached meter theme[cached_start]="#b5bd68" theme[cached_mid]="#f0c674" theme[cached_end]="#cc6666" # Mem/Disk available meter theme[available_start]="#b5bd68" theme[available_mid]="#f0c674" theme[available_end]="#cc6666" # Mem/Disk used meter theme[used_start]="#b5bd68" theme[used_mid]="#f0c674" theme[used_end]="#cc6666" # Download graph colors theme[download_start]="#b5bd68" theme[download_mid]="#f0c674" theme[download_end]="#cc6666" # Upload graph colors theme[upload_start]="#b5bd68" theme[upload_mid]="#f0c674" theme[upload_end]="#cc6666" aristocratos-btop-d43a485/themes/twilight.theme000066400000000000000000000047241517514752700217200ustar00rootroot00000000000000# Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#141414" # Main text color theme[main_fg]="#A7A7A7" # Title color for boxes theme[title]="#DAD085" # Highlight color for keyboard shortcuts theme[hi_fg]="#CF6A4C" # Background color of selected items theme[selected_bg]="#3E3E3E" # Foreground color of selected items theme[selected_fg]="#8B98AB" # Color of inactive/disabled text theme[inactive_fg]="#828282" # Color of text appearing on top of graphs, i.e uptime and current network graph scaling theme[graph_text]="#C5AF75" # Background color of the percentage meters theme[meter_bg]="#3E3E3E" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#8F9D6A" # Cpu box outline color theme[cpu_box]="#8F9D6A" # Memory/disks box outline color theme[mem_box]="#9B703F" # Net up/down box outline color theme[net_box]="#CDA869" # Processes box outline color theme[proc_box]="#CF6A4C" # Box divider line and small boxes line color theme[div_line]="#494949" # Temperature graph colors theme[temp_start]="#8F9D6A" theme[temp_mid]="#F9EE98" theme[temp_end]="#CF6A4C" # CPU graph colors theme[cpu_start]="#8F9D6A" theme[cpu_mid]="#F9EE98" theme[cpu_end]="#CF6A4C" # Mem/Disk free meter theme[free_start]="#CF6A4C" theme[free_mid]="#F9EE98" theme[free_end]="#8F9D6A" # Mem/Disk cached meter theme[cached_start]="#8F9D6A" theme[cached_mid]="#F9EE98" theme[cached_end]="#CF6A4C" # Mem/Disk available meter theme[available_start]="#8F9D6A" theme[available_mid]="#F9EE98" theme[available_end]="#CF6A4C" # Mem/Disk used meter theme[used_start]="#8F9D6A" theme[used_mid]="#F9EE98" theme[used_end]="#CF6A4C" # Download graph colors theme[download_start]="#8F9D6A" theme[download_mid]="#F9EE98" theme[download_end]="#CF6A4C" # Upload graph colors theme[upload_start]="#8F9D6A" theme[upload_mid]="#F9EE98" theme[upload_end]="#CF6A4C" # Process box color gradient for threads, mem and cpu usage theme[process_start]="#8F9D6A" theme[process_mid]="#F9EE98" theme[process_end]="#CF6A4C" # Process pause background color theme[proc_pause_bg]="#CF6A4C" # Process follow background color theme[proc_follow_bg]="#7587A6" # Process banner background color theme[proc_banner_bg]="#3E3E3E" # Process banner foreground color theme[proc_banner_fg]="#A7A7A7" # Followed process background color theme[followed_bg]="#7587A6" # Followed process foreground color theme[followed_fg]="#A7A7A7" aristocratos-btop-d43a485/themes/whiteout.theme000066400000000000000000000042641517514752700217340ustar00rootroot00000000000000#Bashtop "whiteout" theme #by aristocratos # Colors should be in 6 or 2 character hexadecimal or single spaced rgb decimal: "#RRGGBB", "#BW" or "0-255 0-255 0-255" # example for white: "#FFFFFF", "#ff" or "255 255 255". # All graphs and meters can be gradients # For single color graphs leave "mid" and "end" variable empty. # Use "start" and "end" variables for two color gradient # Use "start", "mid" and "end" for three color gradient # Main background, empty for terminal default, need to be empty if you want transparent background theme[main_bg]="#ff" # Main text color theme[main_fg]="#30" # Title color for boxes theme[title]="#10" # Highlight color for keyboard shortcuts theme[hi_fg]="#284d75" # Background color of selected item in processes box theme[selected_bg]="#15283d" # Foreground color of selected item in processes box theme[selected_fg]="#ff" # Color of inactive/disabled text theme[inactive_fg]="#dd" # Misc colors for processes box including mini cpu graphs, details memory graph and details status text theme[proc_misc]="#03521d" # Cpu box outline color theme[cpu_box]="#1a361e" # Memory/disks box outline color theme[mem_box]="#3d3c14" # Net up/down box outline color theme[net_box]="#1a1742" # Processes box outline color theme[proc_box]="#3b1515" # Box divider line and small boxes line color theme[div_line]="#80" # Temperature graph colors theme[temp_start]="#184567" theme[temp_mid]="#122c87" theme[temp_end]="#9e0061" # CPU graph colors theme[cpu_start]="#0b8e44" theme[cpu_mid]="#a49104" theme[cpu_end]="#8d0202" # Mem/Disk free meter theme[free_start]="#b0d090" theme[free_mid]="#70ba26" theme[free_end]="#496600" # Mem/Disk cached meter theme[cached_start]="#26c5ff" theme[cached_mid]="#74e6fc" theme[cached_end]="#0b1a29" # Mem/Disk available meter theme[available_start]="#ffb814" theme[available_mid]="#ffd77a" theme[available_end]="#292107" # Mem/Disk used meter theme[used_start]="#ff4769" theme[used_mid]="#d9626d" theme[used_end]="#3b1f1c" # Download graph colors theme[download_start]="#8d82de" theme[download_mid]="#413786" theme[download_end]="#130f29" # Upload graph colors theme[upload_start]="#f590f9" theme[upload_mid]="#722e76" theme[upload_end]="#2b062d"