init

Telegram/ThirdParty/GSL/.clang-format

@@ -0,0 +1,34 @@
+ColumnLimit: 100
+
+UseTab: Never
+IndentWidth: 4
+AccessModifierOffset: -4
+NamespaceIndentation: Inner
+
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterNamespace: true
+  AfterEnum: true
+  AfterStruct: true
+  AfterClass: true
+  SplitEmptyFunction: false
+  AfterControlStatement: true
+  AfterFunction: true
+  AfterUnion: true
+  BeforeElse: true
+
+
+AlwaysBreakTemplateDeclarations: true
+BreakConstructorInitializersBeforeComma: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+
+PointerAlignment: Left
+AlignConsecutiveAssignments: false
+AlignTrailingComments: true
+
+SpaceAfterCStyleCast: true
+CommentPragmas: '^ NO-FORMAT:'

Telegram/ThirdParty/GSL/.gitattributes

@@ -0,0 +1 @@
+include/gsl/* linguist-language=C++

Telegram/ThirdParty/GSL/.github/workflows/android.yml

@@ -0,0 +1,59 @@
+name: CI_Android
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  Android:
+    runs-on: macos-latest-large
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - uses: actions/setup-java@v4
+        with:
+          java-version: 8
+          distribution: zulu
+
+      - name: Start Emulator
+        run: |
+          echo "y" | $ANDROID_HOME/tools/bin/sdkmanager --install 'system-images;android-24;default;x86_64'
+          echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-24;default;x86_64' --force
+          $ANDROID_HOME/emulator/emulator -list-avds
+          echo "Starting emulator..."
+          nohup $ANDROID_HOME/emulator/emulator -no-audio -no-snapshot -avd xamarin_android_emulator &> /dev/null &
+          echo "Emulator starting in background"
+
+      - name: Configure
+        run: cmake -Werror=dev -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_LATEST_HOME/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=16 -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Debug ..
+
+      - name: Build
+        run: cmake --build . --parallel
+
+      - name: Wait for emulator ready
+        timeout-minutes: 2
+        run: |
+          $ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed | tr -d '\r') ]]; do sleep 10; done; input keyevent 82'
+          $ANDROID_HOME/platform-tools/adb devices
+          $ANDROID_HOME/platform-tools/adb shell getprop ro.product.cpu.abi
+
+      - name: Deploy tests
+        run: |
+          adb push tests /data/local/tmp
+          adb shell find /data/local/tmp/tests -maxdepth 1 -exec chmod +x {} \\\;
+
+      - name: Test
+        run: adb shell find /data/local/tmp/tests -name "*_tests" -maxdepth 1 -exec {} \\\;

Telegram/ThirdParty/GSL/.github/workflows/cmake/action.yml

@@ -0,0 +1,56 @@
+name: Composite CMake
+inputs:
+  cmake_generator:
+    required: false
+    type: string
+    default: 'Unix Makefiles'
+  cmake_build_type:
+    required: true
+    type: string
+    default: ''
+  cmake_cxx_compiler:
+    required: false 
+    type: string 
+  gsl_cxx_standard:
+    required: true
+    type: number
+  extra_cmake_args:
+    required: false
+    type: string
+    default: ''
+  build_cmd:
+    required: true 
+    type: string 
+    default: 'make'
+  test_cmd:
+    required: false
+    type: string 
+    default: 'make test'
+  shell:
+    required: false 
+    type: string
+    default: 'bash'
+
+
+runs:
+  using: composite
+  steps:
+    - name: Create build directory
+      run: mkdir build
+      shell: ${{ inputs.shell }}
+
+    - name: Configure CMake
+      working-directory: build
+      run: cmake -G "${{ inputs.cmake_generator }}" -DCMAKE_BUILD_TYPE=${{ inputs.cmake_build_type }} -DCMAKE_CXX_COMPILER=${{ inputs.cmake_cxx_compiler }} -DGSL_CXX_STANDARD=${{ inputs.gsl_cxx_standard }} -DCI_TESTING:BOOL=ON -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -Werror=dev ${{ inputs.extra_cmake_args }} ..
+      shell: ${{ inputs.shell }}
+
+    - name: Build
+      working-directory: build
+      run: ${{ inputs.build_cmd }}
+      shell: ${{ inputs.shell }}
+
+    - name: Test
+      working-directory: build
+      run: ${{ inputs.test_cmd }}
+      shell: ${{ inputs.shell }} 
+

Telegram/ThirdParty/GSL/.github/workflows/cmake_find_package.yml

@@ -0,0 +1,25 @@
+name: cmake_find_package
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  cmake-find-package:
+    name: Build ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, macos-latest ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.14.0
+      - name: Configure GSL
+        run: cmake -S . -B build -G "Ninja" -D GSL_TEST=OFF -D CMAKE_INSTALL_PREFIX=${GITHUB_WORKSPACE}/build/install
+      - name: Install GSL
+        run: cmake --build build --target install
+      - name: Test GSL find_package support
+        run: cmake -S tests/ -B build/tests_find_package -G "Ninja" -D CMAKE_PREFIX_PATH=${GITHUB_WORKSPACE}/build/install -D CMAKE_BUILD_TYPE=Release

Telegram/ThirdParty/GSL/.github/workflows/compilers.yml

@@ -0,0 +1,104 @@
+name: Compiler Integration Tests
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+# These jobs are correlated with the officially supported compilers
+# and toolsets. If you change any versions, please update README.md.
+
+jobs:
+  gcc:
+    strategy:
+      matrix:
+        gcc_version: [ 10, 11, 12 ]
+        build_type: [ Debug, Release ]
+        cxx_version: [ 14, 17, 20, 23 ]
+        exclude:
+          - gcc_version: 10
+            cxx_version: 23
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run CMake (configure, build, test)
+        uses: ./.github/workflows/cmake
+        with:
+          cmake_build_type: ${{ matrix.build_type }}
+          cmake_cxx_compiler: g++-${{ matrix.gcc_version }}
+          gsl_cxx_standard: ${{ matrix.cxx_version }}
+          
+  clang:
+    strategy:
+      matrix:
+        clang_version: [ 13, 14, 15 ]
+        build_type: [ Debug, Release ]
+        cxx_version: [ 14, 17, 20, 23 ]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+     
+      - name: Run CMake (configure, build, test)
+        uses: ./.github/workflows/cmake
+        with:
+          cmake_build_type: ${{ matrix.build_type }}
+          cmake_cxx_compiler: clang++-${{ matrix.clang_version }}
+          gsl_cxx_standard: ${{ matrix.cxx_version }}
+
+  xcode:
+    strategy:
+      matrix:
+        xcode_version: [ '14.3.1', '15.4' ]
+        build_type: [ Debug, Release ]
+        cxx_version: [ 14, 17, 20, 23 ]
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: select xcode version
+        run: sudo xcode-select -s /Applications/Xcode_${{ matrix.xcode_version }}.app
+
+      - name: Run CMake (configure, build, test)
+        uses: ./.github/workflows/cmake
+        with:
+          cmake_build_type: ${{ matrix.build_type }}
+          cmake_cxx_compiler: clang++
+          gsl_cxx_standard: ${{ matrix.cxx_version }}
+
+  VisualStudio:
+    strategy:
+      matrix:
+        generator: [ 'Visual Studio 16 2019', 'Visual Studio 17 2022' ]
+        image: [ windows-2019, windows-2022 ]
+        build_type: [ Debug, Release ]
+        extra_args: [ '', '-T ClangCL' ]
+        cxx_version: [ 14, 17, 20, 23 ]
+        exclude:
+          - generator: 'Visual Studio 17 2022'
+            image: windows-2019
+          - generator: 'Visual Studio 16 2019'
+            image: windows-2022
+          - generator: 'Visual Studio 16 2019'
+            cxx_version: 23
+    runs-on: ${{ matrix.image }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: microsoft/setup-msbuild@v2
+
+      - name: Run CMake (configure, build, test)
+        uses: ./.github/workflows/cmake
+        with:
+          cmake_generator: ${{ matrix.generator }}
+          cmake_build_type: ${{ matrix.build_type }}
+          gsl_cxx_standard: ${{ matrix.cxx_version }}
+          extra_cmake_args: ${{ matrix.extra_args }}
+          build_cmd: msbuild GSL.sln
+          test_cmd: ctest . --output-on-failure --no-compress-output
+          shell: pwsh
+

Telegram/ThirdParty/GSL/.github/workflows/ios.yml

@@ -0,0 +1,52 @@
+name: CI_iOS
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  iOS:
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - name: Configure
+        run: |
+          cmake \
+            -Werror=dev \
+            -GXcode \
+            -DCMAKE_SYSTEM_NAME=iOS \
+            "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
+            -DCMAKE_OSX_DEPLOYMENT_TARGET=9 \
+            -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
+            "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
+            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.1.0 \
+            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.1.0 \
+            ..
+
+      - name: Build
+        run: cmake --build . --parallel `sysctl -n hw.ncpu` --config Release -- -sdk iphonesimulator
+
+      - name: Start simulator
+        run: |
+          RUNTIME=`xcrun simctl list runtimes iOS -j|jq '.runtimes|last.identifier'`
+          UDID=`xcrun simctl list devices iPhone available -j|jq -r ".devices[$RUNTIME]|last.udid"`
+          xcrun simctl bootstatus $UDID -b
+
+      - name: Test
+        run: |
+          for TEST in `find tests/Release-iphonesimulator -depth 1 -name "*.app"`
+          do
+            xcrun simctl install booted $TEST
+            TEST_ID=`plutil -convert json -o - $TEST/Info.plist|jq -r ".CFBundleIdentifier"`
+            xcrun simctl launch --console booted $TEST_ID
+            xcrun simctl uninstall booted $TEST_ID
+          done

Telegram/ThirdParty/GSL/.gitignore

@@ -0,0 +1,16 @@
+CMakeFiles
+build
+tests/CMakeFiles
+tests/Debug
+*.opensdf
+*.sdf
+tests/*tests.dir
+*.vcxproj
+*.vcxproj.filters
+*.sln
+*.tlog
+Testing/Temporary/*.*
+CMakeCache.txt
+*.suo
+.vs/
+.vscode/

Telegram/ThirdParty/GSL/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.14...3.16)
+
+project(GSL VERSION 4.1.0 LANGUAGES CXX)
+
+add_library(GSL INTERFACE)
+add_library(Microsoft.GSL::GSL ALIAS GSL)
+
+# https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
+string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} PROJECT_IS_TOP_LEVEL)
+
+option(GSL_INSTALL "Generate and install GSL target" ${PROJECT_IS_TOP_LEVEL})
+option(GSL_TEST "Build and perform GSL tests" ${PROJECT_IS_TOP_LEVEL})
+
+# The implementation generally assumes a platform that implements C++14 support
+target_compile_features(GSL INTERFACE "cxx_std_14")
+
+# Setup include directory
+add_subdirectory(include)
+
+target_sources(GSL INTERFACE $<BUILD_INTERFACE:${GSL_SOURCE_DIR}/GSL.natvis>)
+
+if (GSL_TEST)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+if (GSL_INSTALL)
+    include(GNUInstallDirs)
+    include(CMakePackageConfigHelpers)
+
+    install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/gsl" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+    set(export_name "Microsoft.GSLConfig")
+    set(namespace "Microsoft.GSL::")
+    set(cmake_files_install_dir ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
+
+    install(TARGETS GSL EXPORT ${export_name} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+    install(EXPORT ${export_name} NAMESPACE ${namespace} DESTINATION ${cmake_files_install_dir})
+    export(TARGETS GSL NAMESPACE ${namespace} FILE ${export_name}.cmake)
+
+    set(gls_config_version "${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake")
+
+    write_basic_package_version_file(${gls_config_version} COMPATIBILITY SameMajorVersion ARCH_INDEPENDENT)
+
+    install(FILES ${gls_config_version} DESTINATION ${cmake_files_install_dir})
+
+    install(FILES GSL.natvis DESTINATION ${cmake_files_install_dir})
+endif()

Telegram/ThirdParty/GSL/CMakeSettings.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "x64-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "inheritEnvironments": [
+        "msvc_x64_x64"
+      ],
+      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
+      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
+      "cmakeCommandArgs": "-DGSL_CXX_STANDARD=17",
+      "buildCommandArgs": "-v",
+      "ctestCommandArgs": "",
+      "codeAnalysisRuleset": "CppCoreCheckRules.ruleset"
+    }
+  ]
+}

Telegram/ThirdParty/GSL/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+## Contributing to the Guidelines Support Library
+
+The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
+[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines). GSL design changes are made only as a result of modifications to the Guidelines. 
+
+GSL is accepting contributions that improve or refine any of the types in this library as well as ports to other platforms. Changes should have an issue 
+tracking the suggestion that has been approved by the maintainers. Your pull request should include a link to the bug that you are fixing. If you've submitted 
+a PR, please post a comment in the associated issue to avoid duplication of effort.
+
+## Legal
+You will need to complete a Contributor License Agreement (CLA). Briefly, this agreement testifies that you are granting us and the community permission to 
+use the submitted change according to the terms of the project's license, and that the work being submitted is under appropriate copyright.
+
+Please submit a Contributor License Agreement (CLA) before submitting a pull request. You may visit https://cla.microsoft.com to sign digitally.
+
+## Housekeeping
+Your pull request should: 
+
+* Include a description of what your change intends to do
+* Be a child commit of a reasonably recent commit in the **main** branch 
+    * Requests need not be a single commit, but should be a linear sequence of commits (i.e. no merge commits in your PR)
+* It is desirable, but not necessary, for the tests to pass at each commit. Please see [README.md](./README.md) for instructions to build the test suite. 
+* Have clear commit messages 
+    * e.g. "Fix issue", "Add tests for type", etc.
+* Include appropriate tests 
+    * Tests should include reasonable permutations of the target fix/change
+    * Include baseline changes with your change
+    * All changed code must have 100% code coverage
+* To avoid line ending issues, set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration

Telegram/ThirdParty/GSL/GSL.natvis

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 
+    This will make GitHub and some editors recognize this code as XML: 
+    vim: syntax=xml
+-->
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+    <!-- These types are from the util header. -->
+    <Type Name="gsl::final_action&lt;*&gt;">
+        <DisplayString>{{ invoke = {invoke_}, action = {f_} }}</DisplayString>
+        <Expand>
+            <Item Name="[invoke]">invoke_</Item>
+            <Item Name="[callback]">f_</Item>
+        </Expand>
+    </Type>
+
+  <!-- These types are from the span header. -->
+  <Type Name="gsl::span&lt;*, *&gt;">
+        <DisplayString>{{ extent = {storage_.size_} }}</DisplayString>
+        <Expand>
+            <ArrayItems>
+                <Size>storage_.size_</Size>
+                <ValuePointer>storage_.data_</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+    <!-- These types are from the pointers header. -->
+    <Type Name="gsl::not_null&lt;*&gt;">
+        <!-- We can always dereference this since it's an invariant. -->
+        <DisplayString>value = {*ptr_}</DisplayString>
+    </Type>
+</AutoVisualizer>  

Telegram/ThirdParty/GSL/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2015 Microsoft Corporation. All rights reserved. 
+ 
+This code is licensed under the MIT License (MIT). 
+
+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. 

Telegram/ThirdParty/GSL/README.md

@@ -0,0 +1,215 @@
+# GSL: Guidelines Support Library
+[![Build Status](https://dev.azure.com/cppstat/GSL/_apis/build/status/microsoft.GSL?branchName=main)](https://dev.azure.com/cppstat/GSL/_build/latest?definitionId=1&branchName=main)
+
+The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
+[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) maintained by the [Standard C++ Foundation](https://isocpp.org).
+This repo contains Microsoft's implementation of GSL.
+
+The entire implementation is provided inline in the headers under the [gsl](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support.
+
+While some types have been broken out into their own headers (e.g. [gsl/span](./include/gsl/span)),
+it is simplest to just include [gsl/gsl](./include/gsl/gsl) and gain access to the entire library.
+
+> NOTE: We encourage contributions that improve or refine any of the types in this library as well as ports to
+other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about contributing.
+
+# Project Code of Conduct
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+# Usage of Third Party Libraries
+This project makes use of the [Google Test](https://github.com/google/googletest) testing library. Please see the [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) file for details regarding the licensing of Google Test.
+
+# Supported features
+## Microsoft GSL implements the following from the C++ Core Guidelines:
+
+Feature                                                                  | Supported? | Description
+-------------------------------------------------------------------------|:----------:|-------------
+[**1. Views**][cg-views]                                                 |            |
+[owner](docs/headers.md#user-content-H-pointers-owner)                   | ☑   | An alias for a raw pointer
+[not_null](docs/headers.md#user-content-H-pointers-not_null)             | ☑   | Restricts a pointer/smart pointer to hold non-null values
+[span](docs/headers.md#user-content-H-span-span)                         | ☑   | A view over a contiguous sequence of memory. Based on the standardized version of `std::span`, however `gsl::span` enforces bounds checking.
+span_p                                                                   | ☐   | Spans a range starting from a pointer to the first place for which the predicate is true
+[basic_zstring](docs/headers.md#user-content-H-zstring)                  | ☑   | A pointer to a C-string (zero-terminated array) with a templated char type
+[zstring](docs/headers.md#user-content-H-zstring)                        | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `char`
+[czstring](docs/headers.md#user-content-H-zstring)                       | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const char`
+[wzstring](docs/headers.md#user-content-H-zstring)                       | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `wchar_t`
+[cwzstring](docs/headers.md#user-content-H-zstring)                      | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const wchar_t`
+[u16zstring](docs/headers.md#user-content-H-zstring)                     | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `char16_t`
+[cu16zstring](docs/headers.md#user-content-H-zstring)                    | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const char16_t`
+[u32zstring](docs/headers.md#user-content-H-zstring)                     | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `char32_t`
+[cu32zstring](docs/headers.md#user-content-H-zstring)                    | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const char32_t`
+[**2. Owners**][cg-owners]                                               |            |
+[unique_ptr](docs/headers.md#user-content-H-pointers-unique_ptr)         | ☑   | An alias to `std::unique_ptr`
+[shared_ptr](docs/headers.md#user-content-H-pointers-shared_ptr)         | ☑   | An alias to `std::shared_ptr`
+stack_array                                                              | ☐   | A stack-allocated array
+dyn_array                                                                | ☐   | A heap-allocated array
+[**3. Assertions**][cg-assertions]                                       |            |
+[Expects](docs/headers.md#user-content-H-assert-expects)                 | ☑   | A precondition assertion; on failure it terminates
+[Ensures](docs/headers.md#user-content-H-assert-ensures)                 | ☑   | A postcondition assertion; on failure it terminates
+[**4. Utilities**][cg-utilities]                                         |            |
+move_owner                                                               | ☐   | A helper function that moves one `owner` to the other
+[byte](docs/headers.md#user-content-H-byte-byte)                         | ☑   | Either an alias to `std::byte` or a byte type
+[final_action](docs/headers.md#user-content-H-util-final_action)         | ☑   | A RAII style class that invokes a functor on its destruction
+[finally](docs/headers.md#user-content-H-util-finally)                   | ☑   | A helper function instantiating [final_action](docs/headers.md#user-content-H-util-final_action)
+[GSL_SUPPRESS](docs/headers.md#user-content-H-assert-gsl_suppress)       | ☑   | A macro that takes an argument and turns it into `[[gsl::suppress(x)]]` or `[[gsl::suppress("x")]]`
+[[implicit]]                                                             | ☐   | A "marker" to put on single-argument constructors to explicitly make them non-explicit
+[index](docs/headers.md#user-content-H-util-index)                       | ☑   | A type to use for all container and array indexing (currently an alias for `std::ptrdiff_t`)
+joining_thread                                                           | ☐   | A RAII style version of `std::thread` that joins
+[narrow](docs/headers.md#user-content-H-narrow-narrow)                   | ☑   | A checked version of `narrow_cast`; it can throw [narrowing_error](docs/headers.md#user-content-H-narrow-narrowing_error)
+[narrow_cast](docs/headers.md#user-content-H-util-narrow_cast)           | ☑   | A narrowing cast for values and a synonym for `static_cast`
+[narrowing_error](docs/headers.md#user-content-H-narrow-narrowing_error) | ☑   | A custom exception type thrown by [narrow](docs/headers.md#user-content-H-narrow-narrow)
+[**5. Concepts**][cg-concepts]                                           | ☐   |
+
+## The following features do not exist in or have been removed from the C++ Core Guidelines:
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+[strict_not_null](docs/headers.md#user-content-H-pointers-strict_not_null) | ☑   | A stricter version of [not_null](docs/headers.md#user-content-H-pointers-not_null) with explicit constructors
+multi_span                         | ☐   | Deprecated. Multi-dimensional span.
+strided_span                       | ☐   | Deprecated. Support for this type has been discontinued.
+basic_string_span                  | ☐   | Deprecated. Like `span` but for strings with a templated char type
+string_span                        | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `char`
+cstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const char`
+wstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `wchar_t`
+cwstring_span                      | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const wchar_t`
+u16string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `char16_t`
+cu16string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const char16_t`
+u32string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `char32_t`
+cu32string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const char32_t`
+
+This is based on [CppCoreGuidelines semi-specification](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gsl-guidelines-support-library).
+
+[cg-views]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslview-views
+[cg-owners]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslowner-ownership-pointers
+[cg-assertions]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslassert-assertions
+[cg-utilities]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslutil-utilities
+[cg-concepts]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslconcept-concepts
+
+# Quick Start
+## Supported Compilers / Toolsets
+The GSL officially supports recent major versions of Visual Studio with both MSVC and LLVM, GCC, Clang, and XCode with Apple-Clang.
+For each of these major versions, the GSL officially supports C++14, C++17, C++20, and C++23 (when supported by the compiler).
+Below is a table showing the versions currently being tested (also see [.github/workflows/compilers.yml](the workflow).)
+
+Compiler |Toolset Versions Currently Tested
+:------- |--:
+ GCC | 10, 11, 12
+ XCode | 14.3.1, 15.4
+ Clang | 13, 14, 15
+ Visual Studio with MSVC | VS2019, VS2022 
+ Visual Studio with LLVM | VS2019, VS2022
+
+---
+If you successfully port GSL to another platform, we would love to hear from you!
+- Submit an issue specifying the platform and target.
+- Consider contributing your changes by filing a pull request with any necessary changes.
+- If at all possible, add a CI/CD step and add the button to the table below!
+
+Target | CI/CD Status
+:------- | -----------:
+iOS | ![CI_iOS](https://github.com/microsoft/GSL/workflows/CI_iOS/badge.svg)
+Android | ![CI_Android](https://github.com/microsoft/GSL/workflows/CI_Android/badge.svg)
+
+Note: These CI/CD steps are run with each pull request, however failures in them are non-blocking.
+
+## Building the tests
+To build the tests, you will require the following:
+
+* [CMake](http://cmake.org), version 3.14 or later to be installed and in your PATH.
+
+These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.
+
+1. Create a directory to contain the build outputs for a particular architecture (we name it `c:\GSL\build-x86` in this example).
+
+        cd GSL
+        md build-x86
+        cd build-x86
+
+2. Configure CMake to use the compiler of your choice (you can see a list by running `cmake --help`).
+
+        cmake -G "Visual Studio 15 2017" c:\GSL
+
+3. Build the test suite (in this case, in the Debug configuration, Release is another good choice).
+
+        cmake --build . --config Debug
+
+4. Run the test suite.
+
+        ctest -C Debug
+
+All tests should pass - indicating your platform is fully supported and you are ready to use the GSL types!
+
+## Building GSL - Using vcpkg
+
+You can download and install GSL using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install ms-gsl
+
+The GSL port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+## Using the libraries
+As the types are entirely implemented inline in headers, there are no linking requirements.
+
+You can copy the [gsl](./include/gsl) directory into your source tree so it is available
+to your compiler, then include the appropriate headers in your program.
+
+Alternatively set your compiler's *include path* flag to point to the GSL development folder (`c:\GSL\include` in the example above) or installation folder (after running the install). Eg.
+
+MSVC++
+
+    /I c:\GSL\include
+
+GCC/clang
+
+    -I$HOME/dev/GSL/include
+
+Include the library using:
+
+    #include <gsl/gsl>
+
+## Usage in CMake
+
+The library provides a Config file for CMake, once installed it can be found via `find_package`.
+
+Which, when successful, will add library target called `Microsoft.GSL::GSL` which you can use via the usual
+`target_link_libraries` mechanism.
+
+```cmake
+find_package(Microsoft.GSL CONFIG REQUIRED)
+
+target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
+```
+
+### FetchContent
+
+If you are using CMake version 3.11+ you can use the official [FetchContent module](https://cmake.org/cmake/help/latest/module/FetchContent.html).
+This allows you to easily incorporate GSL into your project.
+
+```cmake
+# NOTE: This example uses CMake version 3.14 (FetchContent_MakeAvailable).
+# Since it streamlines the FetchContent process
+cmake_minimum_required(VERSION 3.14)
+
+include(FetchContent)
+
+FetchContent_Declare(GSL
+    GIT_REPOSITORY "https://github.com/microsoft/GSL"
+    GIT_TAG "v4.1.0"
+    GIT_SHALLOW ON
+)
+
+FetchContent_MakeAvailable(GSL)
+
+target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
+```
+
+## Debugging visualization support
+
+For Visual Studio users, the file [GSL.natvis](./GSL.natvis) in the root directory of the repository can be added to your project if you would like more helpful visualization of GSL types in the Visual Studio debugger than would be offered by default.
+
+## See Also
+
+For information on [Microsoft Gray Systems Lab (GSL)](https://aka.ms/gsl) of applied data management and system research see <https://aka.ms/gsl>.

Telegram/ThirdParty/GSL/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

Telegram/ThirdParty/GSL/ThirdPartyNotices.txt

@@ -0,0 +1,41 @@
+
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+GSL: Guidelines Support Library incorporates third party material from the projects listed below.
+
+-------------------------------------------------------------------------------
+Software: Google Test
+Owner: Google Inc.
+Source URL: github.com/google/googletest
+License: BSD 3 - Clause
+Text:
+    Copyright 2008, Google Inc.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+        * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+        * Neither the name of Google Inc. nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-------------------------------------------------------------------------------

Telegram/ThirdParty/GSL/docs/headers.md

@@ -0,0 +1,860 @@
+The Guidelines Support Library (GSL) interface is very lightweight and exposed via a header-only library. This document attempts to document all of the headers and their exposed classes and functions.
+
+Types and functions are exported in the namespace `gsl`.
+
+See [GSL: Guidelines support library](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#S-gsl)
+
+# <a name="H" />Headers
+
+- [`<algorithms>`](#user-content-H-algorithms)
+- [`<assert>`](#user-content-H-assert)
+- [`<byte>`](#user-content-H-byte)
+- [`<gsl>`](#user-content-H-gsl)
+- [`<narrow>`](#user-content-H-narrow)
+- [`<pointers>`](#user-content-H-pointers)
+- [`<span>`](#user-content-H-span)
+- [`<span_ext>`](#user-content-H-span_ext)
+- [`<zstring>`](#user-content-H-zstring)
+- [`<util>`](#user-content-H-util)
+
+## <a name="H-algorithms" />`<algorithms>`
+
+This header contains some common algorithms that have been wrapped in GSL safety features.
+
+- [`gsl::copy`](#user-content-H-algorithms-copy)
+
+### <a name="H-algorithms-copy" />`gsl::copy`
+
+```cpp
+template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
+          std::size_t DestExtent>
+void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest);
+```
+
+This function copies the content from the `src` [`span`](#user-content-H-span-span) to the `dest` [`span`](#user-content-H-span-span). It [`Expects`](#user-content-H-assert-expects)
+that the destination `span` is at least as large as the source `span`.
+
+## <a name="H-assert" />`<assert>`
+
+This header contains some macros used for contract checking and suppressing code analysis warnings.
+
+See [GSL.assert: Assertions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-assertions)
+
+- [`GSL_SUPPRESS`](#user-content-H-assert-gsl_suppress)
+- [`Expects`](#user-content-H-assert-expects)
+- [`Ensures`](#user-content-H-assert-ensures)
+
+### <a name="H-assert-gsl_suppress" />`GSL_SUPPRESS`
+
+This macro can be used to suppress a code analysis warning.
+
+The core guidelines request tools that check for the rules to respect suppressing a rule by writing
+`[[gsl::suppress(tag)]]` or `[[gsl::suppress(tag, justification: "message")]]`.
+
+Clang does not use exactly that syntax, but requires `tag` to be put in double quotes `[[gsl::suppress("tag")]]`.
+
+For portable code you can use `GSL_SUPPRESS(tag)`.
+
+See [In.force: Enforcement](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#inforce-enforcement).
+
+### <a name="H-assert-expects" />`Expects`
+
+This macro can be used for expressing a precondition. If the precondition is not held, then `std::terminate` will be called.
+
+See [I.6: Prefer `Expects()` for expressing preconditions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i6-prefer-expects-for-expressing-preconditions)
+
+### <a name="H-assert-ensures" />`Ensures`
+
+This macro can be used for expressing a postcondition. If the postcondition is not held, then `std::terminate` will be called.
+
+See [I.8: Prefer `Ensures()` for expressing postconditions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i8-prefer-ensures-for-expressing-postconditions)
+
+## <a name="H-byte" />`<byte>`
+
+This header contains the definition of a byte type, implementing `std::byte` before it was standardized into C++17.
+
+- [`gsl::byte`](#user-content-H-byte-byte)
+
+### <a name="H-byte-byte" />`gsl::byte`
+
+If `GSL_USE_STD_BYTE` is defined to be `1`, then `gsl::byte` will be an alias to `std::byte`.  
+If `GSL_USE_STD_BYTE` is defined to be `0`, then `gsl::byte` will be a distinct type that implements the concept of byte.  
+If `GSL_USE_STD_BYTE` is not defined, then the header file will check if `std::byte` is available (C\+\+17 or higher). If yes,
+`gsl::byte` will be an alias to `std::byte`, otherwise `gsl::byte` will be a distinct type that implements the concept of byte.
+
+&#x26a0; Take care when linking projects that were compiled with different language standards (before C\+\+17 and C\+\+17 or higher).
+If you do so, you might want to `#define GSL_USE_STD_BYTE 0` to a fixed value to be sure that both projects use exactly
+the same type. Otherwise you might get linker errors.
+
+See [SL.str.5: Use `std::byte` to refer to byte values that do not necessarily represent characters](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-byte)
+
+### Non-member functions
+
+```cpp
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept;
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator<<(byte b, IntegerType shift) noexcept;
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept;
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept;
+```
+
+Left or right shift a `byte` by a given number of bits.
+
+```cpp
+constexpr byte& operator|=(byte& l, byte r) noexcept;
+constexpr byte operator|(byte l, byte r) noexcept;
+```
+
+Bitwise "or" of two `byte`s.
+
+```cpp
+constexpr byte& operator&=(byte& l, byte r) noexcept;
+constexpr byte operator&(byte l, byte r) noexcept;
+```
+
+Bitwise "and" of two `byte`s.
+
+```cpp
+constexpr byte& operator^=(byte& l, byte r) noexcept;
+constexpr byte operator^(byte l, byte r) noexcept;
+```
+
+Bitwise xor of two `byte`s.
+
+```cpp
+constexpr byte operator~(byte b) noexcept;
+```
+
+Bitwise negation of a `byte`. Flips all bits. Zeroes become ones, ones become zeroes.
+
+```cpp
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr IntegerType to_integer(byte b) noexcept;
+```
+
+Convert the given `byte` value to an integral type.
+
+```cpp
+template <typename T>
+constexpr byte to_byte(T t) noexcept;
+```
+
+Convert the given value to a `byte`. The template requires `T` to be an `unsigned char` so that no data loss can occur.
+If you want to convert an integer constant to a `byte` you probably want to call `to_byte<integer constant>()`.
+
+```cpp
+template <int I>
+constexpr byte to_byte() noexcept;
+```
+
+Convert the given value `I` to a `byte`. The template requires `I` to be in the valid range 0..255 for a `gsl::byte`.
+
+## <a name="H-gsl" />`<gsl>`
+
+This header is a convenience header that includes all other [GSL headers](#user-content-H).
+Since `<narrow>` requires exceptions, it will only be included if exceptions are enabled.
+
+## <a name="H-narrow" />`<narrow>`
+
+This header contains utility functions and classes, for narrowing casts, which require exceptions. The narrowing-related utilities that don't require exceptions are found inside [util](#user-content-H-util).
+
+See [GSL.util: Utilities](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-utilities)
+
+- [`gsl::narrowing_error`](#user-content-H-narrow-narrowing_error)
+- [`gsl::narrow`](#user-content-H-narrow-narrow)
+
+### <a name="H-narrow-narrowing_error" />`gsl::narrowing_error`
+
+`gsl::narrowing_error` is the exception thrown by [`gsl::narrow`](#user-content-H-narrow-narrow) when a narrowing conversion fails. It is derived from `std::exception`.
+
+### <a name="H-narrow-narrow" />`gsl::narrow`
+
+`gsl::narrow<T>(x)` is a named cast that does a `static_cast<T>(x)` for narrowing conversions with no signedness promotions.
+If the argument `x` cannot be represented in the target type `T`, then the function throws a [`gsl::narrowing_error`](#user-content-H-narrow-narrowing_error) (e.g., `narrow<unsigned>(-42)` and `narrow<char>(300)` throw).
+
+Note: compare [`gsl::narrow_cast`](#user-content-H-util-narrow_cast) in header [util](#user-content-H-util).
+
+See [ES.46: Avoid lossy (narrowing, truncating) arithmetic conversions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-narrowing) and [ES.49: If you must use a cast, use a named cast](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-casts-named)
+
+## <a name="H-pointers" />`<pointers>`
+
+This header contains some pointer types.
+
+See [GSL.view](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-views)
+
+- [`gsl::unique_ptr`](#user-content-H-pointers-unique_ptr)
+- [`gsl::shared_ptr`](#user-content-H-pointers-shared_ptr)
+- [`gsl::owner`](#user-content-H-pointers-owner)
+- [`gsl::not_null`](#user-content-H-pointers-not_null)
+- [`gsl::strict_not_null`](#user-content-H-pointers-strict_not_null)
+
+### <a name="H-pointers-unique_ptr" />`gsl::unique_ptr`
+
+`gsl::unique_ptr` is an alias to `std::unique_ptr`.
+
+See [GSL.owner: Ownership pointers](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-ownership)
+
+### <a name="H-pointers-shared_ptr" />`gsl::shared_ptr`
+
+`gsl::shared_ptr` is an alias to `std::shared_ptr`.
+
+See [GSL.owner: Ownership pointers](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-ownership)
+
+### <a name="H-pointers-owner" />`gsl::owner`
+
+`gsl::owner<T>` is designed as a safety mechanism for code that must deal directly with raw pointers that own memory. Ideally such code should be restricted to the implementation of low-level abstractions. `gsl::owner` can also be used as a stepping point in converting legacy code to use more modern RAII constructs such as smart pointers.
+`T` must be a pointer type (`std::is_pointer<T>`).
+
+A `gsl::owner<T>` is a typedef to `T`. It adds no runtime overhead whatsoever, as it is purely syntactic and does not add any runtime checks.  Instead, it serves as an annotation for static analysis tools which check for memory safety, and as a code comprehension guide for human readers.
+
+See Enforcement section of [C.31: All resources acquired by a class must be released by the class’s destructor](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-dtor-release).
+
+### <a name="H-pointers-not_null" />`gsl::not_null`
+
+`gsl::not_null<T>` restricts a pointer or smart pointer to only hold non-null values. It has no size overhead over `T`.
+
+The checks for ensuring that the pointer is not null are done in the constructor. There is no overhead when retrieving or dereferencing the checked pointer.
+When a nullptr check fails, `std::terminate` is called.
+
+See [F.23: Use a `not_null<T>` to indicate that “null” is not a valid value](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-nullptr)
+
+#### Member functions
+
+##### Construct/Copy
+
+```cpp
+template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+constexpr not_null(U&& u);
+
+template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+constexpr not_null(T u);
+```
+
+Constructs a `gsl_owner<T>` from a pointer that is convertible to `T` or that is a `T`. It [`Expects`](#user-content-H-assert-expects) that the provided pointer is not `== nullptr`.
+
+```cpp
+template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+constexpr not_null(const not_null<U>& other);
+```
+
+Constructs a `gsl_owner<T>` from another `gsl_owner` where the other pointer is convertible to `T`. It [`Expects`](#user-content-H-assert-expects) that the provided pointer is not `== nullptr`.
+
+```cpp
+not_null(const not_null& other) = default;
+not_null& operator=(const not_null& other) = default;
+```
+
+Copy construction and assignment.
+
+```cpp
+not_null(std::nullptr_t) = delete;
+not_null& operator=(std::nullptr_t) = delete;
+```
+
+Construction from `std::nullptr_t`  and assignment of `std::nullptr_t` are explicitly deleted.
+
+##### Modifiers
+
+```cpp
+not_null& operator++() = delete;
+not_null& operator--() = delete;
+not_null operator++(int) = delete;
+not_null operator--(int) = delete;
+not_null& operator+=(std::ptrdiff_t) = delete;
+not_null& operator-=(std::ptrdiff_t) = delete;
+```
+
+Explicitly deleted operators. Pointers point to single objects ([I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ri-array)), so don't allow these operators.
+
+##### Observers
+
+```cpp
+constexpr details::value_or_reference_return_t<T> get() const;
+constexpr operator T() const { return get(); }
+```
+
+Get the underlying pointer.
+
+```cpp
+constexpr decltype(auto) operator->() const { return get(); }
+constexpr decltype(auto) operator*() const { return *get(); }
+```
+
+Dereference the underlying pointer.
+
+```cpp
+void operator[](std::ptrdiff_t) const = delete;
+```
+
+Array index operator is explicitly deleted. Pointers point to single objects ([I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ri-array)), so don't allow treating them as an array.
+
+#### Non-member functions
+
+```cpp
+template <class T>
+auto make_not_null(T&& t) noexcept;
+```
+
+Creates a `gsl::not_null` object, deducing the target type from the type of the argument.
+
+```cpp
+template <class T, class U>
+auto operator==(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get()))
+    -> decltype(lhs.get() == rhs.get());
+template <class T, class U>
+auto operator!=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get()))
+    -> decltype(lhs.get() != rhs.get());
+template <class T, class U>
+auto operator<(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(lhs.get() < rhs.get()))
+    -> decltype(lhs.get() < rhs.get());
+template <class T, class U>
+auto operator<=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() <= rhs.get()))
+    -> decltype(lhs.get() <= rhs.get());
+template <class T, class U>
+auto operator>(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(lhs.get() > rhs.get()))
+    -> decltype(lhs.get() > rhs.get());
+template <class T, class U>
+auto operator>=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() >= rhs.get()))
+    -> decltype(lhs.get() >= rhs.get());
+```
+
+Comparison of pointers that are convertible to each other.
+
+##### Input/Output
+
+```cpp
+template <class T>
+std::ostream& operator<<(std::ostream& os, const not_null<T>& val);
+```
+
+Performs stream output on a `not_null` pointer, invoking `os << val.get()`. This function is only available when `GSL_NO_IOSTREAMS` is not defined.
+
+##### Modifiers
+
+```cpp
+template <class T, class U>
+std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete;
+template <class T>
+not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;
+```
+
+Addition and subtraction are explicitly deleted. Pointers point to single objects ([I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ri-array)), so don't allow these operators.
+
+##### STL integration
+
+```cpp
+template <class T>
+struct std::hash<gsl::not_null<T>> { ... };
+```
+
+Specialization of `std::hash` for `gsl::not_null`.
+
+### <a name="H-pointers-strict_not_null" />`gsl::strict_not_null`
+
+`strict_not_null` is the same as [`not_null`](#user-content-H-pointers-not_null) except that the constructors are `explicit`.
+
+The free function that deduces the target type from the type of the argument and creates a `gsl::strict_not_null` object is `gsl::make_strict_not_null`.
+
+## <a name="H-span" />`<span>`
+
+This header file exports the class `gsl::span`, a bounds-checked implementation of `std::span`.
+
+- [`gsl::span`](#user-content-H-span-span)
+
+### <a name="H-span-span" />`gsl::span`
+
+```cpp
+template <class ElementType, std::size_t Extent>
+class span;
+```
+
+`gsl::span` is a view over memory. It does not own the memory and is only a way to access contiguous sequences of objects.
+The extent can be either a fixed size or [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent).
+
+The `gsl::span` is based on the standardized version of `std::span` which was added to C++20. Originally, the plan was to
+deprecate `gsl::span` when `std::span` finished standardization, however that plan changed when the runtime bounds checking
+was removed from `std::span`'s design.
+
+The only difference between `gsl::span` and `std::span` is that `gsl::span` strictly enforces runtime bounds checking.
+Any violations of the bounds check results in termination of the program.
+Like `gsl::span`, `gsl::span`'s iterators also differ from `std::span`'s iterator in that all access operations are bounds checked.
+
+#### Which version of span should I use?
+
+##### Use `gsl::span` if
+
+- you want to guarantee bounds safety in your project.
+  - All data accessing operations use bounds checking to ensure you are only accessing valid memory.
+- your project uses C++14 or C++17.
+  - `std::span` is not available as it was not introduced into the STL until C++20.
+
+##### Use `std::span` if
+
+- your project is C++20 and you need the performance offered by `std::span`.
+
+#### Types
+
+```cpp
+using element_type = ElementType;
+using value_type = std::remove_cv_t<ElementType>;
+using size_type = std::size_t;
+using pointer = element_type*;
+using const_pointer = const element_type*;
+using reference = element_type&;
+using const_reference = const element_type&;
+using difference_type = std::ptrdiff_t;
+
+using iterator = details::span_iterator<ElementType>;
+using reverse_iterator = std::reverse_iterator<iterator>;
+```
+
+#### Member functions
+
+```cpp
+constexpr span() noexcept;
+```
+
+Constructs an empty `span`. This constructor is only available if `Extent` is 0 or [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent).
+`span::data()` will return `nullptr`.
+
+```cpp
+constexpr explicit(Extent != gsl::dynamic_extent) span(pointer ptr, size_type count) noexcept;
+```
+
+Constructs a `span` from a pointer and a size. If `Extent` is not [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent),
+then the constructor [`Expects`](#user-content-H-assert-expects) that `count == Extent`.
+
+```cpp
+constexpr explicit(Extent != gsl::dynamic_extent) span(pointer firstElem, pointer lastElem) noexcept;
+```
+
+Constructs a `span` from a pointer to the begin and the end of the data. If `Extent` is not [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent),
+then the constructor [`Expects`](#user-content-H-assert-expects) that `lastElem - firstElem == Extent`.
+
+```cpp
+template <std::size_t N>
+constexpr span(element_type (&arr)[N]) noexcept;
+```
+
+Constructs a `span` from a C style array. This overload is available if `Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+or `N == Extent`.
+
+```cpp
+template <class T, std::size_t N>
+constexpr span(std::array<T, N>& arr) noexcept;
+
+template <class T, std::size_t N>
+constexpr span(const std::array<T, N>& arr) noexcept;
+```
+
+Constructs a `span` from a `std::array`. These overloads are available if `Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+or `N == Extent`, and if the array can be interpreted as a `ElementType` array.
+
+```cpp
+template <class Container>
+constexpr explicit(Extent != gsl::dynamic_extent) span(Container& cont) noexcept;
+
+template <class Container>
+constexpr explicit(Extent != gsl::dynamic_extent) span(const Container& cont) noexcept;
+```
+
+Constructs a `span` from a container. These overloads are available if `Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+or `N == Extent`, and if the container can be interpreted as a contiguous `ElementType` array.
+
+```cpp
+constexpr span(const span& other) noexcept = default;
+```
+
+Copy constructor.
+
+```cpp
+template <class OtherElementType, std::size_t OtherExtent>
+explicit(Extent != gsl::dynamic_extent && OtherExtent == dynamic_extent)
+constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept;
+```
+
+Constructs a `span` from another `span`. This constructor is available if `OtherExtent == Extent || Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)` || OtherExtent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+and if `ElementType` and `OtherElementType` are compatible.
+
+If `Extent !=`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent) and `OtherExtent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent),
+then the constructor [`Expects`](#user-content-H-assert-expects) that `other.size() == Extent`.
+
+```cpp
+constexpr span& operator=(const span& other) noexcept = default;
+```
+
+Copy assignment
+
+```cpp
+template <std::size_t Count>
+constexpr span<element_type, Count> first() const noexcept;
+
+constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept;
+
+template <std::size_t Count>
+constexpr span<element_type, Count> last() const noexcept;
+
+constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept;
+```
+
+Return a subspan of the first/last `Count` elements. [`Expects`](#user-content-H-assert-expects) that `Count` does not exceed the `span`'s size.
+
+```cpp
+template <std::size_t offset, std::size_t count = dynamic_extent>
+constexpr auto subspan() const noexcept;
+
+constexpr span<element_type, dynamic_extent>
+subspan(size_type offset, size_type count = dynamic_extent) const noexcept;
+```
+
+Return a subspan starting at `offset` and having size `count`. [`Expects`](#user-content-H-assert-expects) that `offset` does not exceed the `span`'s size,
+and that `offset == `[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent) or `offset + count` does not exceed the `span`'s size.
+If `count` is `gsl::dynamic_extent`, the number of elements in the subspan is `size() - offset`.
+
+```cpp
+constexpr size_type size() const noexcept;
+
+constexpr size_type size_bytes() const noexcept;
+```
+
+Returns the size respective the size in bytes of the `span`.
+
+```cpp
+constexpr bool empty() const noexcept;
+```
+
+Is the `span` empty?
+
+```cpp
+constexpr reference operator[](size_type idx) const noexcept;
+```
+
+Returns a reference to the element at the given index. [`Expects`](#user-content-H-assert-expects) that `idx` is less than the `span`'s size.
+
+```cpp
+constexpr reference front() const noexcept;
+constexpr reference back() const noexcept;
+```
+
+Returns a reference to the first/last element in the `span`. [`Expects`](#user-content-H-assert-expects) that the `span` is not empty.
+
+```cpp
+constexpr pointer data() const noexcept;
+```
+
+Returns a pointer to the beginning of the contained data.
+
+```cpp
+constexpr iterator begin() const noexcept;
+constexpr iterator end() const noexcept;
+constexpr reverse_iterator rbegin() const noexcept;
+constexpr reverse_iterator rend() const noexcept;
+```
+
+Returns an iterator to the first/last normal/reverse iterator.
+
+```cpp
+template <class Type, std::size_t Extent>
+span(Type (&)[Extent]) -> span<Type, Extent>;
+
+template <class Type, std::size_t Size>
+span(std::array<Type, Size>&) -> span<Type, Size>;
+
+template <class Type, std::size_t Size>
+span(const std::array<Type, Size>&) -> span<const Type, Size>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
+span(Container&) -> span<Element>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
+span(const Container&) -> span<Element>;
+```
+
+Deduction guides.
+
+```cpp
+template <class ElementType, std::size_t Extent>
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_bytes(span<ElementType, Extent> s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_writable_bytes(span<ElementType, Extent> s) noexcept;
+```
+
+Converts a `span` into a `span` of `byte`s.
+
+`as_writable_bytes` will only be available for non-const `ElementType`s.
+
+## <a name="H-span_ext" />`<span_ext>`
+
+This file is a companion for and included by [`<gsl/span>`](#user-content-H-span), and should not be used on its own. It contains useful features that aren't part of the `std::span` API as found inside the STL `<span>` header (with the exception of [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent), which is included here due to implementation constraints).
+
+- [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+- [`gsl::span`](#user-content-H-span_ext-span)
+- [`gsl::span` comparison operators](#user-content-H-span_ext-span_comparison_operators)
+- [`gsl::make_span`](#user-content-H-span_ext-make_span)
+- [`gsl::at`](#user-content-H-span_ext-at)
+- [`gsl::ssize`](#user-content-H-span_ext-ssize)
+- [`gsl::span` iterator functions](#user-content-H-span_ext-span_iterator_functions)
+
+### <a name="H-span_ext-dynamic_extent" />`gsl::dynamic_extent`
+
+Defines the extent value to be used by all `gsl::span` with dynamic extent. 
+
+Note: `std::dynamic_extent` is exposed by the STL `<span>` header and so ideally `gsl::dynamic_extent` would be under [`<gsl/span>`](#user-content-H-span), but to avoid cyclic dependency issues it is under `<span_ext>` instead.
+
+### <a name="H-span_ext-span" />`gsl::span`
+
+```cpp
+template <class ElementType, std::size_t Extent = dynamic_extent>
+class span;
+```
+
+Forward declaration of `gsl::span`.
+
+### <a name="H-span_ext-span_comparison_operators" />`gsl::span` comparison operators
+
+```cpp
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r);
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator!=(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r);
+```
+
+The comparison operators for two `span`s lexicographically compare the elements in the `span`s.
+
+### <a name="H-span_ext-make_span" />`gsl::make_span`
+
+```cpp
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count);
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem);
+template <class ElementType, std::size_t N>
+constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept;
+template <class Container>
+constexpr span<typename Container::value_type> make_span(Container& cont);
+template <class Container>
+constexpr span<const typename Container::value_type> make_span(const Container& cont);
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count);
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont);
+```
+
+Utility function for creating a `span` with [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent) from
+- pointer and length,
+- pointer to start and pointer to end,
+- a C style array, or
+- a container.
+
+### <a name="H-span_ext-at" />`gsl::at`
+
+```cpp
+template <class ElementType, std::size_t Extent>
+constexpr ElementType& at(span<ElementType, Extent> s, index i);
+```
+
+The function `gsl::at` offers a safe way to access data with index bounds checking.
+
+This is the specialization of [`gsl::at`](#user-content-H-util-at) for [`span`](#user-content-H-span-span). It returns a reference to the `i`th element and
+[`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the `span`.
+
+Note: `gsl::at` supports indexes up to `PTRDIFF_MAX`.
+
+### <a name="H-span_ext-ssize" />`gsl::ssize`
+
+```cpp
+template <class ElementType, std::size_t Extent>
+constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept;
+```
+
+Return the size of a [`span`](#user-content-H-span-span) as a `ptrdiff_t`.
+
+### <a name="H-span_ext-span_iterator_functions" />`gsl::span` iterator functions
+
+```cpp
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+begin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+end(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rbegin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rend(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+cbegin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+cend(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crbegin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crend(const span<ElementType, Extent>& s) noexcept;
+```
+
+Free functions for getting a non-const/const begin/end normal/reverse iterator for a [`span`](#user-content-H-span-span).
+
+## <a name="H-zstring" />`<zstring>`
+
+This header exports a family of `*zstring` types.
+
+A `gsl::XXzstring<T>` is a typedef to `T`. It adds no checks whatsoever, it is just for having a syntax to describe
+that a pointer points to a zero terminated C style string. This helps static code analysis, and it helps human readers.
+
+`basic_zstring` is a pointer to a C-string (zero-terminated array) with a templated char type. Used to implement the rest of the `*zstring` family.  
+`zstring` is a zero terminated `char` string.  
+`czstring` is a const zero terminated `char` string.  
+`wzstring` is a zero terminated `wchar_t` string.  
+`cwzstring` is a const zero terminated `wchar_t` string.  
+`u16zstring` is a zero terminated `char16_t` string.  
+`cu16zstring` is a const zero terminated `char16_t` string.  
+`u32zstring` is a zero terminated `char32_t` string.  
+`cu32zstring` is a const zero terminated `char32_t` string.  
+
+See [GSL.view](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-views) and [SL.str.3: Use zstring or czstring to refer to a C-style, zero-terminated, sequence of characters](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-zstring).
+
+## <a name="H-util" />`<util>`
+
+This header contains utility functions and classes. This header works without exceptions being available. The parts that require
+exceptions being available are in their own header file [narrow](#user-content-H-narrow).
+
+See [GSL.util: Utilities](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-utilities)
+
+- [`gsl::narrow_cast`](#user-content-H-util-narrow_cast)
+- [`gsl::final_action`](#user-content-H-util-final_action)
+- [`gsl::at`](#user-content-H-util-at)
+
+### <a name="H-util-index" />`gsl::index`
+
+An alias to `std::ptrdiff_t`. It serves as the index type for all container indexes/subscripts/sizes.
+
+### <a name="H-util-narrow_cast" />`gsl::narrow_cast`
+
+`gsl::narrow_cast<T>(x)` is a named cast that is identical to a `static_cast<T>(x)`. It exists to make clear to static code analysis tools and to human readers that a lossy conversion is acceptable.
+
+Note: compare the throwing version [`gsl::narrow`](#user-content-H-narrow-narrow) in header [narrow](#user-content-H-narrow).
+
+See [ES.46: Avoid lossy (narrowing, truncating) arithmetic conversions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-narrowing) and [ES.49: If you must use a cast, use a named cast](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-casts-named)
+
+### <a name="H-util-final_action" />`gsl::final_action`
+
+```cpp
+template <class F>
+class final_action { ... };
+```
+
+`final_action` allows you to ensure something gets run at the end of a scope.
+
+See [E.19: Use a final_action object to express cleanup if no suitable resource handle is available](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Re-finally)
+
+#### Member functions
+
+```cpp
+explicit final_action(const F& ff) noexcept;
+explicit final_action(F&& ff) noexcept;
+```
+
+Construct an object with the action to invoke in the destructor.
+
+```cpp
+~final_action() noexcept;
+```
+
+The destructor will call the action that was passed in the constructor.
+
+```cpp
+final_action(final_action&& other) noexcept;
+final_action(const final_action&)   = delete;
+void operator=(const final_action&) = delete;
+void operator=(final_action&&)      = delete;
+```
+
+Move construction is allowed. Copy construction is deleted. Copy and move assignment are also explicitly deleted.
+
+#### <a name="H-util-finally" />Non-member functions
+```cpp
+template <class F>
+auto finally(F&& f) noexcept;
+```
+
+Creates a `gsl::final_action` object, deducing the template argument type from the type of the argument.
+
+### <a name="H-util-at" />`gsl::at`
+
+The function `gsl::at` offers a safe way to access data with index bounds checking.
+
+Note: `gsl::at` supports indexes up to `PTRDIFF_MAX`.
+
+See [ES.42: Keep use of pointers simple and straightforward](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-ptr)
+
+```cpp
+template <class T, std::size_t N>
+constexpr T& at(T (&arr)[N], const index i);
+```
+
+This overload returns a reference to the `i`s element of a C style array `arr`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+```cpp
+template <class Cont>
+constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()]);
+```
+
+This overload returns a reference to the `i`s element of the container `cont`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+```cpp
+template <class T>
+constexpr T at(const std::initializer_list<T> cont, const index i);
+```
+
+This overload returns a reference to the `i`s element of the initializer list `cont`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+```cpp
+template <class T, std::size_t extent = std::dynamic_extent>
+constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size()]);
+```
+
+This overload returns a reference to the `i`s element of the `std::span` `sp`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+For [`gsl::at`](#user-content-H-span_ext-at) for [`gsl::span`](#user-content-H-span-span) see header [`span_ext`](#user-content-H-span_ext).

Telegram/ThirdParty/GSL/include/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Add include folders to the library and targets that consume it
+# the SYSTEM keyword suppresses warnings for users of the library
+#
+# By adding this directory as an include directory the user gets a
+# namespace effect.
+#
+# IE:
+#   #include <gsl/gsl>
+if(PROJECT_IS_TOP_LEVEL)
+    target_include_directories(GSL INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+else()
+    target_include_directories(GSL SYSTEM INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+endif()

Telegram/ThirdParty/GSL/include/gsl/algorithm

@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_ALGORITHM_H
+#define GSL_ALGORITHM_H
+
+#include "assert" // for Expects
+#include "span"   // for dynamic_extent, span
+
+#include <algorithm>   // for copy_n
+#include <cstddef>     // for ptrdiff_t
+#include <type_traits> // for is_assignable
+
+#ifdef _MSC_VER
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4996) // unsafe use of std::copy_n
+
+#endif // _MSC_VER
+
+namespace gsl
+{
+// Note: this will generate faster code than std::copy using span iterator in older msvc+stl
+// not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)
+template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
+          std::size_t DestExtent>
+void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
+{
+    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,
+                  "Elements of source span can not be assigned to elements of destination span");
+    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
+                      (SrcExtent <= DestExtent),
+                  "Source range is longer than target range");
+
+    Expects(dest.size() >= src.size());
+    // clang-format off
+    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
+    // clang-format on
+    std::copy_n(src.data(), src.size(), dest.data());
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_ALGORITHM_H

Telegram/ThirdParty/GSL/include/gsl/assert

@@ -0,0 +1,133 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_ASSERT_H
+#define GSL_ASSERT_H
+
+//
+// Temporary until MSVC STL supports no-exceptions mode.
+// Currently terminate is a no-op in this mode, so we add termination behavior back
+//
+#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+#define GSL_KERNEL_MODE
+
+#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
+#include <intrin.h>
+#define RANGE_CHECKS_FAILURE 0
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-noreturn"
+#endif // defined(__clang__)
+
+#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) &&
+      // !_HAS_EXCEPTIONS))
+
+#include <exception>
+
+#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) &&
+       // !_HAS_EXCEPTIONS))
+
+//
+// make suppress attributes parse for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress(#x)]]
+#else
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__NVCC__)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#endif // _MSC_VER
+#endif // __clang__
+
+#if defined(__clang__) || defined(__GNUC__)
+#define GSL_LIKELY(x) __builtin_expect(!!(x), 1)
+#define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)
+
+#else
+
+#define GSL_LIKELY(x) (!!(x))
+#define GSL_UNLIKELY(x) (!!(x))
+#endif // defined(__clang__) || defined(__GNUC__)
+
+//
+// GSL_ASSUME(cond)
+//
+// Tell the optimizer that the predicate cond must hold. It is unspecified
+// whether or not cond is actually evaluated.
+//
+#ifdef _MSC_VER
+#define GSL_ASSUME(cond) __assume(cond)
+#elif defined(__GNUC__)
+#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
+#else
+#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
+#endif
+
+//
+// GSL.assert: assertions
+//
+
+namespace gsl
+{
+
+namespace details
+{
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    typedef void(__cdecl* terminate_handler)();
+
+    // clang-format off
+    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
+    // clang-format on
+    [[noreturn]] inline void __cdecl default_terminate_handler()
+    {
+        __fastfail(RANGE_CHECKS_FAILURE);
+    }
+
+    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
+    {
+        static terminate_handler handler = &default_terminate_handler;
+        return handler;
+    }
+
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    [[noreturn]] inline void terminate() noexcept
+    {
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+        (*gsl::details::get_terminate_handler())();
+#else
+        std::terminate();
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+    }
+
+} // namespace details
+} // namespace gsl
+
+#define GSL_CONTRACT_CHECK(type, cond)                                                             \
+    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
+
+#define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)
+#define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)
+
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif // GSL_ASSERT_H

Telegram/ThirdParty/GSL/include/gsl/byte

@@ -0,0 +1,183 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_BYTE_H
+#define GSL_BYTE_H
+
+#include <type_traits>
+
+#ifdef _MSC_VER
+
+#pragma warning(push)
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates
+                                 // does not always work
+
+#ifndef GSL_USE_STD_BYTE
+// this tests if we are under MSVC and the standard lib has std::byte and it is enabled
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603
+
+#define GSL_USE_STD_BYTE 1
+
+#else // defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603
+
+#define GSL_USE_STD_BYTE 0
+
+#endif // defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603
+#endif // GSL_USE_STD_BYTE
+
+#else // _MSC_VER
+
+#ifndef GSL_USE_STD_BYTE
+#include <cstddef> /* __cpp_lib_byte */
+// this tests if we are under GCC or Clang with enough -std=c++1z power to get us std::byte
+// also check if libc++ version is sufficient (> 5.0) or libstdc++ actually contains std::byte
+#if defined(__cplusplus) && (__cplusplus >= 201703L) &&                                            \
+    (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603) ||                                      \
+     defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 1
+
+#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 0
+
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+#endif // GSL_USE_STD_BYTE
+
+#endif // _MSC_VER
+
+// Use __may_alias__ attribute on gcc and clang
+#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)
+#define byte_may_alias __attribute__((__may_alias__))
+#else // defined __clang__ || defined __GNUC__
+#define byte_may_alias
+#endif // defined __clang__ || defined __GNUC__
+
+#if GSL_USE_STD_BYTE
+#include <cstddef>
+#endif
+
+namespace gsl
+{
+#if GSL_USE_STD_BYTE
+
+using std::byte;
+using std::to_integer;
+
+#else // GSL_USE_STD_BYTE
+
+// This is a simple definition for now that allows
+// use of byte within span<> to be standards-compliant
+enum class byte_may_alias byte : unsigned char
+{
+};
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator<<(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) >> shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) >> shift);
+}
+
+constexpr byte& operator|=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte operator|(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator&=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte operator&(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator^=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator^(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr IntegerType to_integer(byte b) noexcept
+{
+    return static_cast<IntegerType>(b);
+}
+
+#endif // GSL_USE_STD_BYTE
+
+template <typename T>
+// NOTE: need suppression since c++14 does not allow "return {t}"
+// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
+constexpr byte to_byte(T t) noexcept
+{
+    static_assert(std::is_same<T, unsigned char>::value,
+                  "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
+                  "If you are calling to_byte with an integer constant use: gsl::to_byte<t>() version.");
+    return byte(t);
+}
+
+template <int I>
+constexpr byte to_byte() noexcept
+{
+    static_assert(I >= 0 && I <= 255,
+                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
+    return static_cast<byte>(I);
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_BYTE_H

Telegram/ThirdParty/GSL/include/gsl/gsl

@@ -0,0 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_GSL_H
+#define GSL_GSL_H
+
+// IWYU pragma: begin_exports
+#include "algorithm"   // copy
+#include "assert"      // Ensures/Expects
+#include "byte"        // byte
+#include "pointers"    // owner, not_null
+#include "span"        // span
+#include "zstring"     // zstring
+#include "util"        // finally()/narrow_cast()...
+
+#ifdef __cpp_exceptions
+#include "narrow" // narrow()
+#endif
+// IWYU pragma: end_exports
+
+#endif // GSL_GSL_H

Telegram/ThirdParty/GSL/include/gsl/narrow

@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_NARROW_H
+#define GSL_NARROW_H
+#include "assert"    // for GSL_SUPPRESS
+#include "util"      // for narrow_cast
+#include <exception> // for std::exception
+namespace gsl
+{
+struct narrowing_error : public std::exception
+{
+    const char* what() const noexcept override { return "narrowing_error"; }
+};
+
+// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
+template <class T, class U, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(es.46) // NO-FORMAT: attribute // The warning suggests that a floating->unsigned conversion can occur
+                                            // in the static_cast below, and that gsl::narrow should be used instead.
+                                            // Suppress this warning, since gsl::narrow is defined in terms of
+                                            // static_cast
+    // clang-format on
+    constexpr T narrow(U u)
+{
+    constexpr const bool is_different_signedness =
+        (std::is_signed<T>::value != std::is_signed<U>::value);
+
+GSL_SUPPRESS(es.103) // NO-FORMAT: attribute // don't overflow
+GSL_SUPPRESS(es.104) // NO-FORMAT: attribute // don't underflow
+GSL_SUPPRESS(p.2) // NO-FORMAT: attribute // don't rely on undefined behavior
+    const T t = narrow_cast<T>(u); // While this is technically undefined behavior in some cases (i.e., if the source value is of floating-point type
+                                   // and cannot fit into the destination integral type), the resultant behavior is benign on the platforms
+                                   // that we target (i.e., no hardware trap representations are hit).
+
+#if defined(__clang__) || defined(__GNUC__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    // Note: NaN will always throw, since NaN != NaN
+    if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{}))))
+    {
+        throw narrowing_error{};
+    }
+#if defined(__clang__) || defined(__GNUC__)
+    #pragma GCC diagnostic pop
+#endif
+
+    return t;
+}
+
+template <class T, class U, typename std::enable_if<!std::is_arithmetic<T>::value>::type* = nullptr>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T narrow(U u)
+{
+    const T t = narrow_cast<T>(u);
+
+    if (static_cast<U>(t) != u)
+    {
+        throw narrowing_error{};
+    }
+
+    return t;
+}
+} // namespace gsl
+#endif // GSL_NARROW_H

Telegram/ThirdParty/GSL/include/gsl/pointers

@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_POINTERS_H
+#define GSL_POINTERS_H
+
+#include "assert" // for Ensures, Expects
+
+#include <cstddef>      // for ptrdiff_t, nullptr_t, size_t
+#include <functional>   // for less, greater
+#include <memory>       // for shared_ptr, unique_ptr, hash
+#include <type_traits>  // for enable_if_t, is_convertible, is_assignable
+#include <utility>      // for declval, forward
+
+#if !defined(GSL_NO_IOSTREAMS)
+#include <iosfwd> // for ostream
+#endif            // !defined(GSL_NO_IOSTREAMS)
+
+namespace gsl
+{
+
+namespace details
+{
+    template <typename T, typename = void>
+    struct is_comparable_to_nullptr : std::false_type
+    {
+    };
+
+    template <typename T>
+    struct is_comparable_to_nullptr<
+        T,
+        std::enable_if_t<std::is_convertible<decltype(std::declval<T>() != nullptr), bool>::value>>
+        : std::true_type
+    {
+    };
+
+    // Resolves to the more efficient of `const T` or `const T&`, in the context of returning a const-qualified value
+    // of type T.
+    //
+    // Copied from cppfront's implementation of the CppCoreGuidelines F.16 (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-in)
+    template<typename T>
+    using value_or_reference_return_t = std::conditional_t<
+                                            sizeof(T) < 2*sizeof(void*) && std::is_trivially_copy_constructible<T>::value,
+                                            const T,
+                                            const T&>;
+
+} // namespace details
+
+//
+// GSL.owner: ownership pointers
+//
+using std::shared_ptr;
+using std::unique_ptr;
+
+//
+// owner
+//
+// `gsl::owner<T>` is designed as a safety mechanism for code that must deal directly with raw pointers that own memory.
+// Ideally such code should be restricted to the implementation of low-level abstractions. `gsl::owner` can also be used
+// as a stepping point in converting legacy code to use more modern RAII constructs, such as smart pointers.
+//
+// T must be a pointer type
+// - disallow construction from any type other than pointer type
+//
+template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
+using owner = T;
+
+//
+// not_null
+//
+// Restricts a pointer or smart pointer to only hold non-null values.
+//
+// Has zero size overhead over T.
+//
+// If T is a pointer (i.e. T == U*) then
+// - allow construction from U*
+// - disallow construction from nullptr_t
+// - disallow default construction
+// - ensure construction from null U* fails
+// - allow implicit conversion to U*
+//
+template <class T>
+class not_null
+{
+public:
+    static_assert(details::is_comparable_to_nullptr<T>::value, "T cannot be compared to nullptr.");
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr not_null(U&& u) noexcept(std::is_nothrow_move_constructible<T>::value) : ptr_(std::forward<U>(u))
+    {
+        Expects(ptr_ != nullptr);
+    }
+
+    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+    constexpr not_null(T u) noexcept(std::is_nothrow_move_constructible<T>::value) : ptr_(std::move(u))
+    {
+        Expects(ptr_ != nullptr);
+    }
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr not_null(const not_null<U>& other) noexcept(std::is_nothrow_move_constructible<T>::value) : not_null(other.get())
+    {}
+
+    not_null(const not_null& other) = default;
+    not_null& operator=(const not_null& other) = default;
+    constexpr details::value_or_reference_return_t<T> get() const
+        noexcept(noexcept(details::value_or_reference_return_t<T>{std::declval<T&>()}))
+    {
+        return ptr_;
+    }
+
+    constexpr operator T() const { return get(); }
+    constexpr decltype(auto) operator->() const { return get(); }
+    constexpr decltype(auto) operator*() const { return *get(); }
+
+    // prevents compilation when someone attempts to assign a null pointer constant
+    not_null(std::nullptr_t) = delete;
+    not_null& operator=(std::nullptr_t) = delete;
+
+    // unwanted operators...pointers only point to single objects!
+    not_null& operator++() = delete;
+    not_null& operator--() = delete;
+    not_null operator++(int) = delete;
+    not_null operator--(int) = delete;
+    not_null& operator+=(std::ptrdiff_t) = delete;
+    not_null& operator-=(std::ptrdiff_t) = delete;
+    void operator[](std::ptrdiff_t) const = delete;
+
+private:
+    T ptr_;
+};
+
+template <class T>
+auto make_not_null(T&& t) noexcept
+{
+    return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
+}
+
+#if !defined(GSL_NO_IOSTREAMS)
+template <class T>
+std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
+{
+    os << val.get();
+    return os;
+}
+#endif // !defined(GSL_NO_IOSTREAMS)
+
+template <class T, class U>
+auto operator==(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get()))
+    -> decltype(lhs.get() == rhs.get())
+{
+    return lhs.get() == rhs.get();
+}
+
+template <class T, class U>
+auto operator!=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get()))
+    -> decltype(lhs.get() != rhs.get())
+{
+    return lhs.get() != rhs.get();
+}
+
+template <class T, class U>
+auto operator<(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(std::less<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::less<>{}(lhs.get(), rhs.get()))
+{
+    return std::less<>{}(lhs.get(), rhs.get());
+}
+
+template <class T, class U>
+auto operator<=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(std::less_equal<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::less_equal<>{}(lhs.get(), rhs.get()))
+{
+    return std::less_equal<>{}(lhs.get(), rhs.get());
+}
+
+template <class T, class U>
+auto operator>(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(std::greater<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::greater<>{}(lhs.get(), rhs.get()))
+{
+    return std::greater<>{}(lhs.get(), rhs.get());
+}
+
+template <class T, class U>
+auto operator>=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(std::greater_equal<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::greater_equal<>{}(lhs.get(), rhs.get()))
+{
+    return std::greater_equal<>{}(lhs.get(), rhs.get());
+}
+
+// more unwanted operators
+template <class T, class U>
+std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete;
+template <class T>
+not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;
+
+
+template <class T, class U = decltype(std::declval<const T&>().get()), bool = std::is_default_constructible<std::hash<U>>::value>
+struct not_null_hash
+{
+    std::size_t operator()(const T& value) const { return std::hash<U>{}(value.get()); }
+};
+
+template <class T, class U>
+struct not_null_hash<T, U, false>
+{
+    not_null_hash() = delete;
+    not_null_hash(const not_null_hash&) = delete;
+    not_null_hash& operator=(const not_null_hash&) = delete;
+};
+
+} // namespace gsl
+
+namespace std
+{
+template <class T>
+struct hash<gsl::not_null<T>> : gsl::not_null_hash<gsl::not_null<T>>
+{
+};
+
+} // namespace std
+
+namespace gsl
+{
+
+//
+// strict_not_null
+//
+// Restricts a pointer or smart pointer to only hold non-null values,
+//
+// - provides a strict (i.e. explicit constructor from T) wrapper of not_null
+// - to be used for new code that wishes the design to be cleaner and make not_null
+//   checks intentional, or in old code that would like to make the transition.
+//
+//   To make the transition from not_null, incrementally replace not_null
+//   by strict_not_null and fix compilation errors
+//
+//   Expect to
+//   - remove all unneeded conversions from raw pointer to not_null and back
+//   - make API clear by specifying not_null in parameters where needed
+//   - remove unnecessary asserts
+//
+template <class T>
+class strict_not_null : public not_null<T>
+{
+public:
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr explicit strict_not_null(U&& u) : not_null<T>(std::forward<U>(u))
+    {}
+
+    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+    constexpr explicit strict_not_null(T u) : not_null<T>(u)
+    {}
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr strict_not_null(const not_null<U>& other) : not_null<T>(other)
+    {}
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr strict_not_null(const strict_not_null<U>& other) : not_null<T>(other)
+    {}
+
+    // To avoid invalidating the "not null" invariant, the contained pointer is actually copied
+    // instead of moved. If it is a custom pointer, its constructor could in theory throw exceptions.
+    strict_not_null(strict_not_null&& other) noexcept(std::is_nothrow_copy_constructible<T>::value) = default;
+    strict_not_null(const strict_not_null& other) = default;
+    strict_not_null& operator=(const strict_not_null& other) = default;
+    strict_not_null& operator=(const not_null<T>& other)
+    {
+        not_null<T>::operator=(other);
+        return *this;
+    }
+
+    // prevents compilation when someone attempts to assign a null pointer constant
+    strict_not_null(std::nullptr_t) = delete;
+    strict_not_null& operator=(std::nullptr_t) = delete;
+
+    // unwanted operators...pointers only point to single objects!
+    strict_not_null& operator++() = delete;
+    strict_not_null& operator--() = delete;
+    strict_not_null operator++(int) = delete;
+    strict_not_null operator--(int) = delete;
+    strict_not_null& operator+=(std::ptrdiff_t) = delete;
+    strict_not_null& operator-=(std::ptrdiff_t) = delete;
+    void operator[](std::ptrdiff_t) const = delete;
+};
+
+// more unwanted operators
+template <class T, class U>
+std::ptrdiff_t operator-(const strict_not_null<T>&, const strict_not_null<U>&) = delete;
+template <class T>
+strict_not_null<T> operator-(const strict_not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+strict_not_null<T> operator+(const strict_not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete;
+
+template <class T>
+auto make_strict_not_null(T&& t) noexcept
+{
+    return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
+}
+
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
+
+// deduction guides to prevent the ctad-maybe-unsupported warning
+template <class T>
+not_null(T) -> not_null<T>;
+template <class T>
+strict_not_null(T) -> strict_not_null<T>;
+
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
+
+} // namespace gsl
+
+namespace std
+{
+template <class T>
+struct hash<gsl::strict_not_null<T>> : gsl::not_null_hash<gsl::strict_not_null<T>>
+{
+};
+
+} // namespace std
+
+#endif // GSL_POINTERS_H

Telegram/ThirdParty/GSL/include/gsl/span

@@ -0,0 +1,863 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_SPAN_H
+#define GSL_SPAN_H
+
+#include "assert"   // for Expects
+#include "byte"     // for byte
+#include "span_ext" // for span specialization of gsl::at and other span-related extensions
+#include "util"     // for narrow_cast
+
+#include <array>       // for array
+#include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
+#include <iterator>    // for reverse_iterator, distance, random_access_...
+#include <memory>      // for pointer_traits
+#include <type_traits> // for enable_if_t, declval, is_convertible, inte...
+
+#if defined(__has_include) && __has_include(<version>)
+#include <version>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(                                                                                   \
+    disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
+#pragma warning(disable : 4702) // unreachable code
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26495) // uninitialized member when constructor calls constructor
+#pragma warning(disable : 26446) // parser bug does not allow attributes on some templates
+
+#endif // _MSC_VER
+
+// See if we have enough C++17 power to use a static constexpr data member
+// without needing an out-of-line definition
+#if !(defined(__cplusplus) && (__cplusplus >= 201703L))
+#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
+#endif // !(defined(__cplusplus) && (__cplusplus >= 201703L))
+
+// GCC 7 does not like the signed unsigned mismatch (size_t ptrdiff_t)
+// While there is a conversion from signed to unsigned, it happens at
+// compiletime, so the compiler wouldn't have to warn indiscriminately, but
+// could check if the source value actually doesn't fit into the target type
+// and only warn in those cases.
+#if defined(__GNUC__) && __GNUC__ > 6
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+// Turn off clang unsafe buffer warnings as all accessed are guarded by runtime checks
+#if defined(__clang__)
+#if __has_warning("-Wunsafe-buffer-usage")
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#endif // __has_warning("-Wunsafe-buffer-usage")
+#endif // defined(__clang__)
+
+namespace gsl
+{
+
+// implementation details
+namespace details
+{
+    template <class T>
+    struct is_span_oracle : std::false_type
+    {
+    };
+
+    template <class ElementType, std::size_t Extent>
+    struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_span : public is_span_oracle<std::remove_cv_t<T>>
+    {
+    };
+
+    template <class T>
+    struct is_std_array_oracle : std::false_type
+    {
+    };
+
+    template <class ElementType, std::size_t Extent>
+    struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_std_array : is_std_array_oracle<std::remove_cv_t<T>>
+    {
+    };
+
+    template <std::size_t From, std::size_t To>
+    struct is_allowed_extent_conversion
+        : std::integral_constant<bool, From == To || To == dynamic_extent>
+    {
+    };
+
+    template <class From, class To>
+    struct is_allowed_element_type_conversion
+        : std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value>
+    {
+    };
+
+    template <class Type>
+    class span_iterator
+    {
+    public:
+#if defined(__cpp_lib_ranges) || (defined(_MSVC_STL_VERSION) && defined(__cpp_lib_concepts))
+        using iterator_concept = std::contiguous_iterator_tag;
+#endif // __cpp_lib_ranges
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = std::remove_cv_t<Type>;
+        using difference_type = std::ptrdiff_t;
+        using pointer = Type*;
+        using reference = Type&;
+
+#ifdef _MSC_VER
+        using _Unchecked_type = pointer;
+        using _Prevent_inheriting_unwrap = span_iterator;
+#endif // _MSC_VER
+        constexpr span_iterator() = default;
+
+        constexpr span_iterator(pointer begin, pointer end, pointer current)
+            : begin_(begin), end_(end), current_(current)
+        {}
+
+        constexpr operator span_iterator<const Type>() const noexcept
+        {
+            return {begin_, end_, current_};
+        }
+
+        constexpr reference operator*() const noexcept
+        {
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
+            return *current_;
+        }
+
+        constexpr pointer operator->() const noexcept
+        {
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
+            return current_;
+        }
+        constexpr span_iterator& operator++() noexcept
+        {
+            Expects(begin_ && current_ && end_);
+            Expects(current_ < end_);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
+            ++current_;
+            return *this;
+        }
+
+        constexpr span_iterator operator++(int) noexcept
+        {
+            span_iterator ret = *this;
+            ++*this;
+            return ret;
+        }
+
+        constexpr span_iterator& operator--() noexcept
+        {
+            Expects(begin_ && end_);
+            Expects(begin_ < current_);
+            --current_;
+            return *this;
+        }
+
+        constexpr span_iterator operator--(int) noexcept
+        {
+            span_iterator ret = *this;
+            --*this;
+            return ret;
+        }
+
+        constexpr span_iterator& operator+=(const difference_type n) noexcept
+        {
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(end_ - current_ >= n);
+            if (n < 0) Expects(current_ - begin_ >= -n);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
+            current_ += n;
+            return *this;
+        }
+
+        constexpr span_iterator operator+(const difference_type n) const noexcept
+        {
+            span_iterator ret = *this;
+            ret += n;
+            return ret;
+        }
+
+        friend constexpr span_iterator operator+(const difference_type n,
+                                                 const span_iterator& rhs) noexcept
+        {
+            return rhs + n;
+        }
+
+        constexpr span_iterator& operator-=(const difference_type n) noexcept
+        {
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(current_ - begin_ >= n);
+            if (n < 0) Expects(end_ - current_ >= -n);
+            GSL_SUPPRESS(bounds .1)
+            current_ -= n;
+            return *this;
+        }
+
+        constexpr span_iterator operator-(const difference_type n) const noexcept
+        {
+            span_iterator ret = *this;
+            ret -= n;
+            return ret;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr difference_type operator-(const span_iterator<Type2>& rhs) const noexcept
+        {
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
+            return current_ - rhs.current_;
+        }
+
+        constexpr reference operator[](const difference_type n) const noexcept
+        {
+            return *(*this + n);
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator==(const span_iterator<Type2>& rhs) const noexcept
+        {
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
+            return current_ == rhs.current_;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator!=(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return !(*this == rhs);
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator<(const span_iterator<Type2>& rhs) const noexcept
+        {
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
+            return current_ < rhs.current_;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator>(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return rhs < *this;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator<=(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return !(rhs < *this);
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator>=(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return !(*this < rhs);
+        }
+
+#ifdef _MSC_VER
+        // MSVC++ iterator debugging support; allows STL algorithms in 15.8+
+        // to unwrap span_iterator to a pointer type after a range check in STL
+        // algorithm calls
+        friend constexpr void _Verify_range(span_iterator lhs, span_iterator rhs) noexcept
+        { // test that [lhs, rhs) forms a valid range inside an STL algorithm
+            Expects(lhs.begin_ == rhs.begin_ // range spans have to match
+                    && lhs.end_ == rhs.end_ &&
+                    lhs.current_ <= rhs.current_); // range must not be transposed
+        }
+
+        constexpr void _Verify_offset(const difference_type n) const noexcept
+        { // test that *this + n is within the range of this call
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(end_ - current_ >= n);
+            if (n < 0) Expects(current_ - begin_ >= -n);
+        }
+
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr pointer _Unwrapped() const noexcept
+        { // after seeking *this to a high water mark, or using one of the
+            // _Verify_xxx functions above, unwrap this span_iterator to a raw
+            // pointer
+            return current_;
+        }
+
+        // Tell the STL that span_iterator should not be unwrapped if it can't
+        // validate in advance, even in release / optimized builds:
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+        static constexpr const bool _Unwrap_when_unverified = false;
+#else
+        static constexpr bool _Unwrap_when_unverified = false;
+#endif
+        // clang-format off
+        GSL_SUPPRESS(con.3) // NO-FORMAT: attribute // TODO: false positive
+        // clang-format on
+        constexpr void _Seek_to(const pointer p) noexcept
+        { // adjust the position of *this to previously verified location p
+            // after _Unwrapped
+            current_ = p;
+        }
+#endif
+
+        pointer begin_ = nullptr;
+        pointer end_ = nullptr;
+        pointer current_ = nullptr;
+
+        template <typename Ptr>
+        friend struct std::pointer_traits;
+    };
+}} // namespace gsl::details
+
+namespace std
+{
+template <class Type>
+struct pointer_traits<::gsl::details::span_iterator<Type>>
+{
+    using pointer = ::gsl::details::span_iterator<Type>;
+    using element_type = Type;
+    using difference_type = ptrdiff_t;
+
+    static constexpr element_type* to_address(const pointer i) noexcept { return i.current_; }
+};
+} // namespace std
+
+namespace gsl { namespace details {
+    template <std::size_t Ext>
+    class extent_type
+    {
+    public:
+        using size_type = std::size_t;
+
+        constexpr extent_type() noexcept = default;
+
+        constexpr explicit extent_type(extent_type<dynamic_extent>);
+
+        constexpr explicit extent_type(size_type size) { Expects(size == Ext); }
+
+        constexpr size_type size() const noexcept { return Ext; }
+
+    private:
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+        static constexpr const size_type size_ = Ext; // static size equal to Ext
+#else
+        static constexpr size_type size_ = Ext; // static size equal to Ext
+#endif
+    };
+
+    template <>
+    class extent_type<dynamic_extent>
+    {
+    public:
+        using size_type = std::size_t;
+
+        template <size_type Other>
+        constexpr explicit extent_type(extent_type<Other> ext) : size_(ext.size())
+        {}
+
+        constexpr explicit extent_type(size_type size) : size_(size)
+        {
+            Expects(size != dynamic_extent);
+        }
+
+        constexpr size_type size() const noexcept { return size_; }
+
+    private:
+        size_type size_;
+    };
+
+    template <std::size_t Ext>
+    constexpr extent_type<Ext>::extent_type(extent_type<dynamic_extent> ext)
+    {
+        Expects(ext.size() == Ext);
+    }
+
+    template <class ElementType, std::size_t Extent, std::size_t Offset, std::size_t Count>
+    struct calculate_subspan_type
+    {
+        using type = span<ElementType, Count != dynamic_extent
+                                           ? Count
+                                           : (Extent != dynamic_extent ? Extent - Offset : Extent)>;
+    };
+} // namespace details
+
+// [span], class template span
+template <class ElementType, std::size_t Extent>
+class span
+{
+public:
+    // constants and types
+    using element_type = ElementType;
+    using value_type = std::remove_cv_t<ElementType>;
+    using size_type = std::size_t;
+    using pointer = element_type*;
+    using const_pointer = const element_type*;
+    using reference = element_type&;
+    using const_reference = const element_type&;
+    using difference_type = std::ptrdiff_t;
+
+    using iterator = details::span_iterator<ElementType>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+    static constexpr const size_type extent{Extent};
+#else
+    static constexpr size_type extent{Extent};
+#endif
+
+    // [span.cons], span constructors, copy, assignment, and destructor
+    template <bool Dependent = false,
+              // "Dependent" is needed to make "std::enable_if_t<Dependent || Extent == 0 || Extent
+              // == dynamic_extent>" SFINAE, since "std::enable_if_t<Extent == 0 || Extent ==
+              // dynamic_extent>" is ill-formed when Extent is greater than 0.
+              class = std::enable_if_t<(Dependent ||
+                                        details::is_allowed_extent_conversion<0, Extent>::value)>>
+    constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
+    {}
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
+    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    {
+        Expects(count == Extent);
+    }
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
+    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    {}
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
+    constexpr explicit span(pointer firstElem, pointer lastElem) noexcept
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
+    {
+        Expects(lastElem - firstElem == static_cast<difference_type>(Extent));
+    }
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
+    constexpr span(pointer firstElem, pointer lastElem) noexcept
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
+    {}
+
+    template <std::size_t N,
+              std::enable_if_t<details::is_allowed_extent_conversion<N, Extent>::value, int> = 0>
+    constexpr span(element_type (&arr)[N]) noexcept
+        : storage_(KnownNotNull{arr}, details::extent_type<N>())
+    {}
+
+    template <
+        class T, std::size_t N,
+        std::enable_if_t<(details::is_allowed_extent_conversion<N, Extent>::value &&
+                          details::is_allowed_element_type_conversion<T, element_type>::value),
+                         int> = 0>
+    constexpr span(std::array<T, N>& arr) noexcept
+        : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
+    {}
+
+    template <class T, std::size_t N,
+              std::enable_if_t<
+                  (details::is_allowed_extent_conversion<N, Extent>::value &&
+                   details::is_allowed_element_type_conversion<const T, element_type>::value),
+                  int> = 0>
+    constexpr span(const std::array<T, N>& arr) noexcept
+        : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
+    {}
+
+    // NB: the SFINAE on these constructors uses .data() as an incomplete/imperfect proxy for the
+    // requirement on Container to be a contiguous sequence container.
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent != dynamic_extent && !details::is_span<Container>::value &&
+                      !details::is_std_array<Container>::value &&
+                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                      std::is_convertible<
+                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                          element_type (*)[]>::value,
+                  int> = 0>
+    constexpr explicit span(Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent == dynamic_extent && !details::is_span<Container>::value &&
+                      !details::is_std_array<Container>::value &&
+                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                      std::is_convertible<
+                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                          element_type (*)[]>::value,
+                  int> = 0>
+    constexpr span(Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <
+        std::size_t MyExtent = Extent, class Container,
+        std::enable_if_t<
+            MyExtent != dynamic_extent && std::is_const<element_type>::value &&
+                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                std::is_convertible<
+                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
+                    element_type (*)[]>::value,
+            int> = 0>
+    constexpr explicit span(const Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <
+        std::size_t MyExtent = Extent, class Container,
+        std::enable_if_t<
+            MyExtent == dynamic_extent && std::is_const<element_type>::value &&
+                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                std::is_convertible<
+                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
+                    element_type (*)[]>::value,
+            int> = 0>
+    constexpr span(const Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    constexpr span(const span& other) noexcept = default;
+
+    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+              std::enable_if_t<(MyExtent == dynamic_extent || MyExtent == OtherExtent) &&
+                                   details::is_allowed_element_type_conversion<OtherElementType,
+                                                                               element_type>::value,
+                               int> = 0>
+    constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
+        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
+    {}
+
+    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+              std::enable_if_t<MyExtent != dynamic_extent && OtherExtent == dynamic_extent &&
+                                   details::is_allowed_element_type_conversion<OtherElementType,
+                                                                               element_type>::value,
+                               int> = 0>
+    constexpr explicit span(const span<OtherElementType, OtherExtent>& other) noexcept
+        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
+    {}
+
+    ~span() noexcept = default;
+    constexpr span& operator=(const span& other) noexcept = default;
+
+    // [span.sub], span subviews
+    template <std::size_t Count>
+    constexpr span<element_type, Count> first() const noexcept
+    {
+        Expects(Count <= size());
+        return span<element_type, Count>{data(), Count};
+    }
+
+    template <std::size_t Count>
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr span<element_type, Count> last() const noexcept
+    {
+        Expects(Count <= size());
+        return span<element_type, Count>{data() + (size() - Count), Count};
+    }
+
+    template <std::size_t Offset, std::size_t Count = dynamic_extent>
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr auto subspan() const noexcept ->
+        typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
+    {
+        Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)));
+        using type =
+            typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type;
+        return type{data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
+    }
+
+    constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept
+    {
+        Expects(count <= size());
+        return {data(), count};
+    }
+
+    constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept
+    {
+        Expects(count <= size());
+        return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{});
+    }
+
+    constexpr span<element_type, dynamic_extent>
+    subspan(size_type offset, size_type count = dynamic_extent) const noexcept
+    {
+        return make_subspan(offset, count, subspan_selector<Extent>{});
+    }
+
+    // [span.obs], span observers
+    constexpr size_type size() const noexcept { return storage_.size(); }
+
+    constexpr size_type size_bytes() const noexcept { return size() * sizeof(element_type); }
+
+    constexpr bool empty() const noexcept { return size() == 0; }
+
+    // [span.elem], span element access
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr reference operator[](size_type idx) const noexcept
+    {
+        Expects(idx < size());
+        return data()[idx];
+    }
+
+    constexpr reference front() const noexcept
+    {
+        Expects(size() > 0);
+        return data()[0];
+    }
+
+    constexpr reference back() const noexcept
+    {
+        Expects(size() > 0);
+        return data()[size() - 1];
+    }
+
+    constexpr pointer data() const noexcept { return storage_.data(); }
+
+    // [span.iter], span iterator support
+    constexpr iterator begin() const noexcept
+    {
+        const auto data = storage_.data();
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        return {data, data + size(), data};
+    }
+
+    constexpr iterator end() const noexcept
+    {
+        const auto data = storage_.data();
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        const auto endData = data + storage_.size();
+        return {data, endData, endData};
+    }
+
+    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
+    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
+
+#ifdef _MSC_VER
+    // Tell MSVC how to unwrap spans in range-based-for
+    constexpr pointer _Unchecked_begin() const noexcept { return data(); }
+    constexpr pointer _Unchecked_end() const noexcept
+    {
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        return data() + size();
+    }
+#endif // _MSC_VER
+
+private:
+    // Needed to remove unnecessary null check in subspans
+    struct KnownNotNull
+    {
+        pointer p;
+    };
+
+    // this implementation detail class lets us take advantage of the
+    // empty base class optimization to pay for only storage of a single
+    // pointer in the case of fixed-size spans
+    template <class ExtentType>
+    class storage_type : public ExtentType
+    {
+    public:
+        // KnownNotNull parameter is needed to remove unnecessary null check
+        // in subspans and constructors from arrays
+        template <class OtherExtentType>
+        constexpr storage_type(KnownNotNull data, OtherExtentType ext)
+            : ExtentType(ext), data_(data.p)
+        {}
+
+        template <class OtherExtentType>
+        constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
+        {
+            Expects(data || ExtentType::size() == 0);
+        }
+
+        constexpr pointer data() const noexcept { return data_; }
+
+    private:
+        pointer data_;
+    };
+
+    storage_type<details::extent_type<Extent>> storage_;
+
+    // The rest is needed to remove unnecessary null check
+    // in subspans and constructors from arrays
+    constexpr span(KnownNotNull ptr, size_type count) noexcept : storage_(ptr, count) {}
+
+    template <std::size_t CallerExtent>
+    class subspan_selector
+    {
+    };
+
+    template <std::size_t CallerExtent>
+    constexpr span<element_type, dynamic_extent>
+    make_subspan(size_type offset, size_type count, subspan_selector<CallerExtent>) const noexcept
+    {
+        const span<element_type, dynamic_extent> tmp(*this);
+        return tmp.subspan(offset, count);
+    }
+
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr span<element_type, dynamic_extent>
+    make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const noexcept
+    {
+        Expects(size() >= offset);
+
+        if (count == dynamic_extent) { return {KnownNotNull{data() + offset}, size() - offset}; }
+
+        Expects(size() - offset >= count);
+        return {KnownNotNull{data() + offset}, count};
+    }
+};
+
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
+
+// Deduction Guides
+template <class Type, std::size_t Extent>
+span(Type (&)[Extent]) -> span<Type, Extent>;
+
+template <class Type, std::size_t Size>
+span(std::array<Type, Size>&) -> span<Type, Size>;
+
+template <class Type, std::size_t Size>
+span(const std::array<Type, Size>&) -> span<const Type, Size>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
+span(Container&) -> span<Element>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
+span(const Container&) -> span<Element>;
+
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
+
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+#if defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated" // Bug in clang-cl.exe which raises a C++17 -Wdeprecated warning about this static constexpr workaround in C++14 mode.
+#endif // defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
+template <class ElementType, std::size_t Extent>
+constexpr const typename span<ElementType, Extent>::size_type span<ElementType, Extent>::extent;
+#if defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
+#pragma clang diagnostic pop
+#endif // defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
+#endif
+
+namespace details
+{
+    // if we only supported compilers with good constexpr support then
+    // this pair of classes could collapse down to a constexpr function
+
+    // we should use a narrow_cast<> to go to std::size_t, but older compilers may not see it as
+    // constexpr
+    // and so will fail compilation of the template
+    template <class ElementType, std::size_t Extent>
+    struct calculate_byte_size : std::integral_constant<std::size_t, sizeof(ElementType) * Extent>
+    {
+        static_assert(Extent < dynamic_extent / sizeof(ElementType), "Size is too big.");
+    };
+
+    template <class ElementType>
+    struct calculate_byte_size<ElementType, dynamic_extent>
+        : std::integral_constant<std::size_t, dynamic_extent>
+    {
+    };
+} // namespace details
+
+// [span.objectrep], views of object representation
+template <class ElementType, std::size_t Extent>
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_bytes(span<ElementType, Extent> s) noexcept
+{
+    using type = span<const byte, details::calculate_byte_size<ElementType, Extent>::value>;
+
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return type{reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
+}
+
+template <class ElementType, std::size_t Extent,
+          std::enable_if_t<!std::is_const<ElementType>::value, int> = 0>
+span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_writable_bytes(span<ElementType, Extent> s) noexcept
+{
+    using type = span<byte, details::calculate_byte_size<ElementType, Extent>::value>;
+
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return type{reinterpret_cast<byte*>(s.data()), s.size_bytes()};
+}
+
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#if defined(__GNUC__) && __GNUC__ > 6
+#pragma GCC diagnostic pop
+#endif // __GNUC__ > 6
+
+#if defined(__clang__)
+#if __has_warning("-Wunsafe-buffer-usage")
+#pragma clang diagnostic pop
+#endif // __has_warning("-Wunsafe-buffer-usage")
+#endif // defined(__clang__)
+
+#endif // GSL_SPAN_H

Telegram/ThirdParty/GSL/include/gsl/span_ext

@@ -0,0 +1,214 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_SPAN_EXT_H
+#define GSL_SPAN_EXT_H
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// File: span_ext
+// Purpose: continue offering features that have been cut from the official
+//   implementation of span.
+//   While modernizing gsl::span a number of features needed to be removed to
+//   be compliant with the design of std::span
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "assert" // GSL_KERNEL_MODE
+#include "util"   // for narrow_cast, narrow
+
+#include <cstddef> // for ptrdiff_t, size_t
+#include <utility>
+
+#ifndef GSL_KERNEL_MODE
+#include <algorithm> // for lexicographical_compare
+#endif               // GSL_KERNEL_MODE
+
+namespace gsl
+{
+
+// [span.views.constants], constants
+GSL_INLINE constexpr const std::size_t dynamic_extent = narrow_cast<std::size_t>(-1);
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+class span;
+
+// std::equal and std::lexicographical_compare are not /kernel compatible
+// so all comparison operators must be removed for kernel mode.
+#ifndef GSL_KERNEL_MODE
+
+// [span.comparison], span comparison operators
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r)
+{
+    return std::equal(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator!=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l == r);
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l > r);
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return r < l;
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l < r);
+}
+
+#endif // GSL_KERNEL_MODE
+
+//
+// make_span() - Utility functions for creating spans
+//
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count)
+{
+    return span<ElementType>(ptr, count);
+}
+
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
+{
+    return span<ElementType>(firstElem, lastElem);
+}
+
+template <class ElementType, std::size_t N>
+constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept
+{
+    return span<ElementType, N>(arr);
+}
+
+template <class Container>
+constexpr span<typename Container::value_type> make_span(Container& cont)
+{
+    return span<typename Container::value_type>(cont);
+}
+
+template <class Container>
+constexpr span<const typename Container::value_type> make_span(const Container& cont)
+{
+    return span<const typename Container::value_type>(cont);
+}
+
+template <class Ptr>
+[[deprecated("This function is deprecated. See GSL issue #1092.")]]
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count)
+{
+    return span<typename Ptr::element_type>(cont, count);
+}
+
+template <class Ptr>
+[[deprecated("This function is deprecated. See GSL issue #1092.")]]
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
+{
+    return span<typename Ptr::element_type>(cont);
+}
+
+// Specialization of gsl::at for span
+template <class ElementType, std::size_t Extent>
+constexpr ElementType& at(span<ElementType, Extent> s, index i)
+{
+    // No bounds checking here because it is done in span::operator[] called below
+    Ensures(i >= 0);
+    return s[narrow_cast<std::size_t>(i)];
+}
+
+// [span.obs] Free observer functions
+template <class ElementType, std::size_t Extent>
+constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept
+{
+    return static_cast<std::ptrdiff_t>(s.size());
+}
+
+// [span.iter] Free functions for begin/end functions
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+begin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.begin();
+}
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+end(const span<ElementType, Extent>& s) noexcept
+{
+    return s.end();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rbegin();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rend();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+cbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.begin();
+}
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+cend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.end();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rbegin();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rend();
+}
+
+} // namespace gsl
+
+#endif // GSL_SPAN_EXT_H

Telegram/ThirdParty/GSL/include/gsl/string_span

@@ -0,0 +1,4 @@
+#pragma once
+#pragma message(                                                                                   \
+    "This header will soon be removed. Use <gsl/zstring> instead of <gsl/string_span>")
+#include "zstring"

Telegram/ThirdParty/GSL/include/gsl/util

@@ -0,0 +1,171 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_UTIL_H
+#define GSL_UTIL_H
+
+#include "assert" // for Expects
+
+#include <array>
+#include <cstddef>          // for ptrdiff_t, size_t
+#include <limits>           // for numeric_limits
+#include <initializer_list> // for initializer_list
+#include <type_traits>      // for is_signed, integral_constant
+#include <utility>          // for exchange, forward
+
+#if defined(__has_include) && __has_include(<version>)
+#include <version>
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+#include <span>
+#endif // __cpp_lib_span >= 202002L
+#endif //__has_include(<version>)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+
+#endif // _MSC_VER
+
+// Turn off clang unsafe buffer warnings as all accessed are guarded by runtime checks
+#if defined(__clang__)
+#if __has_warning("-Wunsafe-buffer-usage")
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#endif // __has_warning("-Wunsafe-buffer-usage")
+#endif // defined(__clang__)
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+#define GSL_NODISCARD [[nodiscard]]
+#else
+#define GSL_NODISCARD
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L)
+
+#if defined(__cpp_inline_variables)
+#define GSL_INLINE inline
+#else
+#define GSL_INLINE
+#endif
+
+namespace gsl
+{
+//
+// GSL.util: utilities
+//
+
+// index type for all container indexes/subscripts/sizes
+using index = std::ptrdiff_t;
+
+// final_action allows you to ensure something gets run at the end of a scope
+template <class F>
+class final_action
+{
+public:
+    explicit final_action(const F& ff) noexcept : f{ff} { }
+    explicit final_action(F&& ff) noexcept : f{std::move(ff)} { }
+
+    ~final_action() noexcept { if (invoke) f(); }
+
+    final_action(final_action&& other) noexcept
+        : f(std::move(other.f)), invoke(std::exchange(other.invoke, false))
+    { }
+
+    final_action(const final_action&)   = delete;
+    void operator=(const final_action&) = delete;
+    void operator=(final_action&&)      = delete;
+
+private:
+    F f;
+    bool invoke = true;
+};
+
+// finally() - convenience function to generate a final_action
+template <class F>
+GSL_NODISCARD auto finally(F&& f) noexcept
+{
+    return final_action<std::decay_t<F>>{std::forward<F>(f)};
+}
+
+// narrow_cast(): a searchable way to do narrowing casts of values
+template <class T, class U>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T narrow_cast(U&& u) noexcept
+{
+    return static_cast<T>(std::forward<U>(u));
+}
+
+//
+// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
+//
+template <class T, std::size_t N>
+// clang-format off
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T& at(T (&arr)[N], const index i)
+{
+    static_assert(N <= static_cast<std::size_t>((std::numeric_limits<std::ptrdiff_t>::max)()), "We only support arrays up to PTRDIFF_MAX bytes.");
+    Expects(i >= 0 && i < narrow_cast<index>(N));
+    return arr[narrow_cast<std::size_t>(i)];
+}
+
+template <class Cont>
+// clang-format off
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    using size_type = decltype(cont.size());
+    return cont[narrow_cast<size_type>(i)];
+}
+
+template <class T>
+// clang-format off
+GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T at(const std::initializer_list<T> cont, const index i)
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    return *(cont.begin() + i);
+}
+
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+template <class T, std::size_t extent = std::dynamic_extent>
+constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(sp.size()));
+    return sp[gsl::narrow_cast<std::size_t>(i)];
+}
+#endif // __cpp_lib_span >= 202002L
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(pop)
+
+#endif // _MSC_VER
+
+#if defined(__clang__)
+#if __has_warning("-Wunsafe-buffer-usage")
+#pragma clang diagnostic pop
+#endif // __has_warning("-Wunsafe-buffer-usage")
+#endif // defined(__clang__)
+
+#endif // GSL_UTIL_H

Telegram/ThirdParty/GSL/include/gsl/zstring

@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_ZSTRING_H
+#define GSL_ZSTRING_H
+
+#include "span_ext" // for dynamic_extent
+
+#include <cstddef>   // for size_t, nullptr_t
+
+namespace gsl
+{
+//
+// czstring and wzstring
+//
+// These are "tag" typedefs for C-style strings (i.e. null-terminated character arrays)
+// that allow static analysis to help find bugs.
+//
+// There are no additional features/semantics that we can find a way to add inside the
+// type system for these types that will not either incur significant runtime costs or
+// (sometimes needlessly) break existing programs when introduced.
+//
+
+template <typename CharT, std::size_t Extent = dynamic_extent>
+using basic_zstring = CharT*;
+
+using czstring = basic_zstring<const char, dynamic_extent>;
+
+using cwzstring = basic_zstring<const wchar_t, dynamic_extent>;
+
+using cu16zstring = basic_zstring<const char16_t, dynamic_extent>;
+
+using cu32zstring = basic_zstring<const char32_t, dynamic_extent>;
+
+using zstring = basic_zstring<char, dynamic_extent>;
+
+using wzstring = basic_zstring<wchar_t, dynamic_extent>;
+
+using u16zstring = basic_zstring<char16_t, dynamic_extent>;
+
+using u32zstring = basic_zstring<char32_t, dynamic_extent>;
+
+} // namespace gsl
+
+#endif // GSL_ZSTRING_H

Telegram/ThirdParty/GSL/tests/CMakeLists.txt

@@ -0,0 +1,317 @@
+cmake_minimum_required(VERSION 3.14...3.16)
+
+project(GSLTests LANGUAGES CXX)
+
+set(GSL_CXX_STANDARD "14" CACHE STRING "Use c++ standard")
+
+set(CMAKE_CXX_STANDARD ${GSL_CXX_STANDARD})
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FindPkgConfig)
+include(ExternalProject)
+
+# will make visual studio generated project group files
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+if(CI_TESTING AND GSL_CXX_STANDARD EQUAL 20)
+    add_compile_definitions(FORCE_STD_SPAN_TESTS=1)
+endif()
+
+if(IOS)
+    add_compile_definitions(GTEST_HAS_DEATH_TEST=1 IOS_PROCESS_DELAY_WORKAROUND=1)
+endif()
+
+pkg_search_module(GTestMain gtest_main)
+if (NOT GTestMain_FOUND)
+    # No pre-installed GTest is available, try to download it using Git.
+    find_package(Git REQUIRED QUIET)
+
+    configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+        RESULT_VARIABLE result
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+    )
+    if(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
+
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} --build .
+        RESULT_VARIABLE result
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+    )
+    if(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
+
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+    set(GTestMain_LIBRARIES gtest_main)
+
+    add_subdirectory(
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
+        EXCLUDE_FROM_ALL
+    )
+endif()
+
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    find_package(Microsoft.GSL CONFIG REQUIRED)
+    enable_testing()
+
+    if (NOT DEFINED Microsoft.GSL_VERSION)
+        message(FATAL_ERROR "Microsoft.GSL_VERSION not defined!")
+    endif()
+
+    message(STATUS "Microsoft.GSL_VERSION = ${Microsoft.GSL_VERSION}")
+endif()
+
+if (MSVC AND (GSL_CXX_STANDARD GREATER_EQUAL 17))
+    set(GSL_CPLUSPLUS_OPT -Zc:__cplusplus -permissive-)
+endif()
+
+include(CheckCXXCompilerFlag)
+# this interface adds compile options to how the tests are run
+# please try to keep entries ordered =)
+add_library(gsl_tests_config INTERFACE)
+if(MSVC) # MSVC or simulating MSVC
+    target_compile_options(gsl_tests_config INTERFACE
+        ${GSL_CPLUSPLUS_OPT}
+        /EHsc
+        /W4
+        /WX
+        $<$<CXX_COMPILER_ID:MSVC>:
+          /wd4996  # Use of function or classes marked [[deprecated]]
+          /wd26409 # CppCoreCheck - GTest
+          /wd26426 # CppCoreCheck - GTest
+          /wd26440 # CppCoreCheck - GTest
+          /wd26446 # CppCoreCheck - prefer gsl::at()
+          /wd26472 # CppCoreCheck - use gsl::narrow(_cast)
+          /wd26481 # CppCoreCheck - use span instead of pointer arithmetic
+          $<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,1920>: # VS2015
+            /wd4189 # variable is initialized but not referenced
+            $<$<NOT:$<CONFIG:Debug>>: # Release, RelWithDebInfo
+              /wd4702 # Unreachable code
+            >
+          >
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          -Weverything
+          -Wfloat-equal
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-covered-switch-default # GTest
+          -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
+          -Wno-global-constructors # GTest
+          -Wno-language-extension-token # GTest gtest-port.h
+          -Wno-missing-braces
+          -Wno-missing-prototypes
+          -Wno-shift-sign-overflow # GTest gtest-port.h
+          -Wno-undef # GTest
+          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+            -Wno-unused-member-function
+            -Wno-unused-variable
+            $<$<VERSION_EQUAL:$<CXX_COMPILER_VERSION>,15.0.1>:
+              -Wno-deprecated # False positive in MSVC Clang 15.0.1 raises a C++17 warning
+            >
+          >
+        >
+    )
+    check_cxx_compiler_flag("-Wno-reserved-identifier" WARN_RESERVED_ID)
+    if (WARN_RESERVED_ID)
+      target_compile_options(gsl_tests_config INTERFACE "-Wno-reserved-identifier")
+    endif()
+else()
+    target_compile_options(gsl_tests_config INTERFACE
+        -fno-strict-aliasing
+        -Wall
+        -Wcast-align
+        -Wconversion
+        -Wctor-dtor-privacy
+        -Werror
+        -Wextra
+        -Wpedantic
+        -Wshadow
+        -Wsign-conversion
+        -Wfloat-equal
+        -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-braces
+          -Wno-covered-switch-default # GTest
+          -Wno-global-constructors # GTest
+          -Wno-missing-prototypes
+          -Wno-padded
+          -Wno-switch-default
+          -Wno-unknown-attributes
+          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
+          -Wno-weak-vtables
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+            -Wno-unused-member-function
+            -Wno-unused-variable
+          >
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.99>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
+          >
+          $<$<AND:$<EQUAL:${GSL_CXX_STANDARD},20>,$<OR:$<CXX_COMPILER_VERSION:11.0.0>,$<CXX_COMPILER_VERSION:10.0.0>>>:
+              -Wno-zero-as-null-pointer-constant  # failing Clang Ubuntu 20.04 tests, seems to be a bug with clang 10.0.0
+                                                  # and clang 11.0.0. (operator< is being re-written by the compiler
+                                                  # as operator<=> and raising the warning)
+          >
+        >
+        $<$<CXX_COMPILER_ID:AppleClang>:
+          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,9.1>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,10>>:
+            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
+          >
+        >
+        $<$<CXX_COMPILER_ID:GNU>:
+          -Wdouble-promotion # float implicit to double
+          -Wlogical-op # suspicious uses of logical operators
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            -Wduplicated-cond # duplicated if-else conditions
+            -Wmisleading-indentation
+            -Wnull-dereference
+            $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+              -Wno-unused-variable
+            >
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
+            -Wduplicated-branches # identical if-else branches
+          >
+        >
+    )
+endif(MSVC)
+check_cxx_compiler_flag("-Wno-unsafe-buffer-usage" WARN_UNSAFE_BUFFER)
+if (WARN_UNSAFE_BUFFER)
+  # This test uses very greedy heuristics such as "no pointer arithmetic on raw buffer"
+  target_compile_options(gsl_tests_config INTERFACE "-Wno-unsafe-buffer-usage")
+endif()
+
+# for tests to find the gtest header
+target_include_directories(gsl_tests_config SYSTEM INTERFACE
+    googletest/googletest/include
+)
+
+add_executable(gsl_tests
+    algorithm_tests.cpp
+    assertion_tests.cpp
+    at_tests.cpp
+    byte_tests.cpp
+    notnull_tests.cpp
+    owner_tests.cpp
+    span_compatibility_tests.cpp
+    span_ext_tests.cpp
+    span_tests.cpp
+    strict_notnull_tests.cpp
+    
+    utils_tests.cpp
+)
+
+target_link_libraries(gsl_tests
+    Microsoft.GSL::GSL
+    gsl_tests_config
+    ${GTestMain_LIBRARIES}
+)
+add_test(gsl_tests gsl_tests)
+
+# No exception tests
+
+foreach(flag_var
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    STRING (REGEX REPLACE "/EHsc" "" ${flag_var} "${${flag_var}}")
+endforeach(flag_var)
+
+# this interface adds compile options to how the tests are run
+# please try to keep entries ordered =)
+add_library(gsl_tests_config_noexcept INTERFACE)
+if(MSVC) # MSVC or simulating MSVC
+    target_compile_definitions(gsl_tests_config_noexcept INTERFACE
+        _HAS_EXCEPTIONS=0 # disable exceptions in the Microsoft STL
+    )
+    target_compile_options(gsl_tests_config_noexcept INTERFACE
+        ${GSL_CPLUSPLUS_OPT}
+        /W4
+        /WX
+        $<$<CXX_COMPILER_ID:MSVC>:
+          /wd4577
+          /wd4702
+          /wd26440 # CppCoreCheck - GTest
+          /wd26446 # CppCoreCheck - prefer gsl::at()
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          -Weverything
+          -Wfloat-equal
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-prototypes
+          -Wno-unknown-attributes
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>:
+            $<$<VERSION_EQUAL:$<CXX_COMPILER_VERSION>,15.0.1>: 
+              -Wno-deprecated # False positive in MSVC Clang 15.0.1 raises a C++17 warning
+            >
+          >
+        >
+    )
+    check_cxx_compiler_flag("-Wno-reserved-identifier" WARN_RESERVED_ID)
+    if (WARN_RESERVED_ID)
+      target_compile_options(gsl_tests_config_noexcept INTERFACE "-Wno-reserved-identifier")
+    endif()
+else()
+    target_compile_options(gsl_tests_config_noexcept INTERFACE
+        -fno-exceptions
+        -fno-strict-aliasing
+        -Wall
+        -Wcast-align
+        -Wconversion
+        -Wctor-dtor-privacy
+        -Werror
+        -Wextra
+        -Wpedantic
+        -Wshadow
+        -Wsign-conversion
+        -Wfloat-equal
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-prototypes
+          -Wno-unknown-attributes
+          -Wno-weak-vtables
+        >
+        $<$<CXX_COMPILER_ID:GNU>:
+          -Wdouble-promotion # float implicit to double
+          -Wlogical-op # suspicious uses of logical operators
+          -Wuseless-cast # casting to its own type
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            -Wduplicated-cond # duplicated if-else conditions
+            -Wmisleading-indentation
+            -Wnull-dereference
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
+            -Wduplicated-branches # identical if-else branches
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,8>>:
+            -Wcast-align=strict # increase alignment (i.e. char* to int*)
+          >
+        >
+    )
+endif(MSVC)
+check_cxx_compiler_flag("-Wno-unsafe-buffer-usage" WARN_UNSAFE_BUFFER)
+if (WARN_UNSAFE_BUFFER)
+  # This test uses very greedy heuristics such as "no pointer arithmetic on raw buffer"
+  target_compile_options(gsl_tests_config_noexcept INTERFACE "-Wno-unsafe-buffer-usage")
+endif()
+
+add_executable(gsl_noexcept_tests no_exception_ensure_tests.cpp)
+target_link_libraries(gsl_noexcept_tests
+    Microsoft.GSL::GSL
+    gsl_tests_config_noexcept
+)
+add_test(gsl_noexcept_tests gsl_noexcept_tests)

Telegram/ThirdParty/GSL/tests/CMakeLists.txt.in

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(googletest-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(googletest
+  GIT_REPOSITORY    https://github.com/google/googletest.git
+  GIT_TAG           1b18723e874b256c1e39378c6774a90701d70f7a
+  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
+  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND     ""
+  INSTALL_COMMAND   ""
+  TEST_COMMAND      ""
+)

Telegram/ThirdParty/GSL/tests/algorithm_tests.cpp

@@ -0,0 +1,224 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <array>         // for array
+#include <cstddef>       // for size_t
+#include <gsl/algorithm> // for copy
+#include <gsl/span>      // for span
+#include <gtest/gtest.h>
+
+#include "deathTestCommon.h"
+
+namespace gsl
+{
+struct fail_fast;
+} // namespace gsl
+
+using namespace gsl;
+
+TEST(algorithm_tests, same_type)
+{
+    // dynamic source and destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<int> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and dynamic destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<int, 5> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // dynamic source and static destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const gsl::span<int> src_span(src);
+        const gsl::span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<int, 5> src_span(src);
+        const span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+}
+
+TEST(algorithm_tests, compatible_type)
+{
+    // dynamic source and destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and dynamic destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short, 5> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // dynamic source and static destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short> src_span(src);
+        const span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short, 5> src_span(src);
+        const span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+}
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+TEST(algorithm_tests, incompatible_type)
+{
+    std::array<int, 4> src{1, 2, 3, 4};
+    std::array<int*, 12> dst{};
+
+    span<int> src_span_dyn(src);
+    span<int, 4> src_span_static(src);
+    span<int*> dst_span_dyn(dst);
+    span<int*, 4> dst_span_static(dst);
+
+    // every line should produce a compilation error
+    copy(src_span_dyn, dst_span_dyn);
+    copy(src_span_dyn, dst_span_static);
+    copy(src_span_static, dst_span_dyn);
+    copy(src_span_static, dst_span_static);
+}
+#endif
+
+TEST(algorithm_tests, small_destination_span)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. small_destination_span";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    std::array<int, 12> src{1, 2, 3, 4};
+    std::array<int, 4> dst{};
+
+    const span<int> src_span_dyn(src);
+    const span<int, 12> src_span_static(src);
+    const span<int> dst_span_dyn(dst);
+    const span<int, 4> dst_span_static(dst);
+
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_dyn), expected);
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_static), expected);
+    EXPECT_DEATH(copy(src_span_static, dst_span_dyn), expected);
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    copy(src_span_static, dst_span_static);
+#endif
+}

Telegram/ThirdParty/GSL/tests/assertion_tests.cpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 "deathTestCommon.h"
+#include <gsl/assert> // for Ensures, Expects
+#include <gtest/gtest.h>
+
+using namespace gsl;
+
+namespace
+{
+
+int f(int i)
+{
+    Expects(i > 0 && i < 10);
+    return i;
+}
+
+int g(int i)
+{
+    i++;
+    Ensures(i > 0 && i < 10);
+    return i;
+}
+} // namespace
+
+TEST(assertion_tests, expects)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. expects";
+        std::abort();
+    });
+
+    EXPECT_TRUE(f(2) == 2);
+    EXPECT_DEATH(f(10), GetExpectedDeathString(terminateHandler));
+}
+
+TEST(assertion_tests, ensures)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. ensures";
+        std::abort();
+    });
+
+    EXPECT_TRUE(g(2) == 3);
+    EXPECT_DEATH(g(9), GetExpectedDeathString(terminateHandler));
+}

Telegram/ThirdParty/GSL/tests/at_tests.cpp

@@ -0,0 +1,173 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gtest/gtest.h>
+
+#include <gsl/util> // for at
+
+#include <array>            // for array
+#include <cstddef>          // for size_t
+#include <exception>        // for terminate
+#include <initializer_list> // for initializer_list
+#include <vector>           // for vector
+#if defined(__cplusplus) && __cplusplus >= 202002L
+#include <span>
+#endif // __cplusplus >= 202002L
+
+#include "deathTestCommon.h"
+
+TEST(at_tests, static_array)
+{
+    int a[4] = {1, 2, 3, 4};
+    const int(&c_a)[4] = a;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(&gsl::at(a, i) == &a[i]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[i]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. static_array";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
+}
+
+TEST(at_tests, std_array)
+{
+    std::array<int, 4> a = {1, 2, 3, 4};
+    const std::array<int, 4>& c_a = a;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_array";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
+}
+
+TEST(at_tests, std_vector)
+{
+    std::vector<int> a = {1, 2, 3, 4};
+    const std::vector<int>& c_a = a;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_vector";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
+}
+
+TEST(at_tests, InitializerList)
+{
+    const std::initializer_list<int> a = {1, 2, 3, 4};
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(gsl::at(a, i) == i + 1);
+        EXPECT_TRUE(gsl::at({1, 2, 3, 4}, i) == i + 1);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. InitializerList";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, -1), expected);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, 4), expected);
+}
+
+#if defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+TEST(at_tests, std_span)
+{
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    std::span sp{vec};
+
+    std::vector<int> cvec{1, 2, 3, 4, 5};
+    std::span csp{cvec};
+
+    for (gsl::index i = 0; i < gsl::narrow_cast<gsl::index>(vec.size()); ++i)
+    {
+        EXPECT_TRUE(&gsl::at(sp, i) == &vec[gsl::narrow_cast<size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(csp, i) == &cvec[gsl::narrow_cast<size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_span";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(sp, -1), expected);
+    EXPECT_DEATH(gsl::at(sp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+    EXPECT_DEATH(gsl::at(csp, -1), expected);
+    EXPECT_DEATH(gsl::at(csp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+}
+#endif // defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+
+#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1910
+static constexpr bool test_constexpr()
+{
+    int a1[4] = {1, 2, 3, 4};
+    const int(&c_a1)[4] = a1;
+    std::array<int, 4> a2 = {1, 2, 3, 4};
+    const std::array<int, 4>& c_a2 = a2;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        if (&gsl::at(a1, i) != &a1[i]) return false;
+        if (&gsl::at(c_a1, i) != &a1[i]) return false;
+        // requires C++17:
+        // if (&gsl::at(a2, i) != &a2[static_cast<std::size_t>(i)]) return false;
+        if (&gsl::at(c_a2, i) != &c_a2[static_cast<std::size_t>(i)]) return false;
+        if (gsl::at({1, 2, 3, 4}, i) != i + 1) return false;
+    }
+
+    return true;
+}
+
+static_assert(test_constexpr(), "FAIL");
+#endif

Telegram/ThirdParty/GSL/tests/byte_tests.cpp

@@ -0,0 +1,134 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gtest/gtest.h>
+
+#include <gsl/byte> // for to_byte, to_integer, byte, operator&, ope...
+
+using namespace std;
+using namespace gsl;
+
+namespace
+{
+int modify_both(gsl::byte& b, int& i)
+{
+    i = 10;
+    b = to_byte<5>();
+    return i;
+}
+
+TEST(byte_tests, construction)
+{
+    {
+        const byte b = static_cast<byte>(4);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
+    }
+
+    {
+        const byte b = byte(12);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+
+    {
+        const byte b = to_byte<12>();
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+    {
+        const unsigned char uc = 12;
+        const byte b = to_byte(uc);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+    {
+        const byte b{14};
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
+    }
+#endif
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    to_byte(char{});
+    to_byte(3);
+    to_byte(3u);
+#endif
+}
+
+TEST(byte_tests, bitwise_operations)
+{
+    const byte b = to_byte<0xFF>();
+
+    byte a = to_byte<0x00>();
+    EXPECT_TRUE((b | a) == to_byte<0xFF>());
+    EXPECT_TRUE(a == to_byte<0x00>());
+
+    a |= b;
+    EXPECT_TRUE(a == to_byte<0xFF>());
+
+    a = to_byte<0x01>();
+    EXPECT_TRUE((b & a) == to_byte<0x01>());
+
+    a &= b;
+    EXPECT_TRUE(a == to_byte<0x01>());
+
+    EXPECT_TRUE((b ^ a) == to_byte<0xFE>());
+
+    EXPECT_TRUE(a == to_byte<0x01>());
+    a ^= b;
+    EXPECT_TRUE(a == to_byte<0xFE>());
+
+    a = to_byte<0x01>();
+    EXPECT_TRUE(~a == to_byte<0xFE>());
+
+    a = to_byte<0xFF>();
+    EXPECT_TRUE((a << 4) == to_byte<0xF0>());
+    EXPECT_TRUE((a >> 4) == to_byte<0x0F>());
+
+    a <<= 4;
+    EXPECT_TRUE(a == to_byte<0xF0>());
+    a >>= 4;
+    EXPECT_TRUE(a == to_byte<0x0F>());
+}
+
+TEST(byte_tests, to_integer)
+{
+    const byte b = to_byte<0x12>();
+
+    EXPECT_TRUE(0x12 == gsl::to_integer<char>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<short>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<long>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<long long>(b));
+
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned char>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned short>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long long>(b));
+
+    //      EXPECT_TRUE(0x12 == gsl::to_integer<float>(b));   // expect compile-time error
+    //      EXPECT_TRUE(0x12 == gsl::to_integer<double>(b));  // expect compile-time error
+}
+
+TEST(byte_tests, aliasing)
+{
+    int i{0};
+    const int res = modify_both(reinterpret_cast<byte&>(i), i);
+    EXPECT_TRUE(res == i);
+}
+
+} // namespace
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+copy(src_span_static, dst_span_static);
+#endif

Telegram/ThirdParty/GSL/tests/deathTestCommon.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <gsl/assert>
+
+constexpr char deathstring[] = "Expected Death";
+constexpr char failed_set_terminate_deathstring[] = ".*";
+
+// This prevents a failed call to set_terminate from failing the test suite.
+constexpr const char* GetExpectedDeathString(std::terminate_handler handle)
+{
+    return handle ? deathstring : failed_set_terminate_deathstring;
+}

Telegram/ThirdParty/GSL/tests/no_exception_ensure_tests.cpp

@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <chrono>
+#include <cstdlib>  // for std::exit
+#include <gsl/span> // for span
+#include <iostream>
+#include <thread>
+
+int operator_subscript_no_throw() noexcept
+{
+    int arr[10];
+    const gsl::span<int> sp{arr};
+    return sp[11];
+}
+
+[[noreturn]] void test_terminate() { std::exit(0); }
+
+void setup_termination_handler() noexcept
+{
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    auto& handler = gsl::details::get_terminate_handler();
+    handler = &test_terminate;
+
+#else
+
+    std::set_terminate(test_terminate);
+
+#endif
+}
+
+int main() noexcept
+{
+    std::cout << "Running main() from " __FILE__ "\n";
+#if defined(IOS_PROCESS_DELAY_WORKAROUND)
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+#endif
+    setup_termination_handler();
+    operator_subscript_no_throw();
+    return -1;
+}

Telegram/ThirdParty/GSL/tests/notnull_tests.cpp

@@ -0,0 +1,648 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gtest/gtest.h>
+
+#include <gsl/pointers> // for not_null, operator<, operator<=, operator>
+
+#include <algorithm> // for addressof
+#include <cstdint>   // for uint16_t
+#include <memory>    // for shared_ptr, make_shared, operator<, opera...
+#include <sstream>   // for operator<<, ostringstream, basic_ostream:...
+#include <string>    // for basic_string, operator==, string, operator<<
+#include <typeinfo>  // for type_info
+#include <variant>   // for variant, monostate, get
+
+#include "deathTestCommon.h"
+using namespace gsl;
+
+struct MyBase
+{
+};
+struct MyDerived : public MyBase
+{
+};
+struct Unrelated
+{
+};
+
+// stand-in for a user-defined ref-counted class
+template <typename T>
+struct RefCounted
+{
+    RefCounted(T* p) : p_(p) {}
+    operator T*() { return p_; }
+    T* p_;
+};
+
+// user defined smart pointer with comparison operators returning non bool value
+template <typename T>
+struct CustomPtr
+{
+    CustomPtr(T* p) : p_(p) {}
+    operator T*() const { return p_; }
+    bool operator!=(std::nullptr_t) const { return p_ != nullptr; }
+    T* p_ = nullptr;
+};
+
+template <typename T, typename U>
+std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) == reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+template <typename T, typename U>
+std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) != reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+template <typename T, typename U>
+std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) < reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                         : "false";
+}
+
+template <typename T, typename U>
+std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) > reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                         : "false";
+}
+
+template <typename T, typename U>
+std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) <= reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+template <typename T, typename U>
+std::string operator>=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) >= reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+struct NonCopyableNonMovable
+{
+    NonCopyableNonMovable() = default;
+    NonCopyableNonMovable(const NonCopyableNonMovable&) = delete;
+    NonCopyableNonMovable& operator=(const NonCopyableNonMovable&) = delete;
+    NonCopyableNonMovable(NonCopyableNonMovable&&) = delete;
+    NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
+};
+
+namespace
+{
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
+bool helper(not_null<int*> p) { return *p == 12; }
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
+bool helper_const(not_null<const int*> p) { return *p == 12; }
+
+int* return_pointer() { return nullptr; }
+} // namespace
+
+TEST(notnull_tests, TestNotNullConstructors)
+{
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        not_null<int*> p = nullptr;          // yay...does not compile!
+        not_null<std::vector<char>*> p1 = 0; // yay...does not compile!
+        not_null<int*> p2;                   // yay...does not compile!
+        std::unique_ptr<int> up = std::make_unique<int>(120);
+        not_null<int*> p3 = up;
+
+        // Forbid non-nullptr assignable types
+        not_null<std::vector<int>> f(std::vector<int>{1});
+        not_null<int> z(10);
+        not_null<std::vector<int>> y({1, 2});
+#endif
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullConstructors";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        // from shared pointer
+        int i = 12;
+        auto rp = RefCounted<int>(&i);
+        not_null<int*> p(rp);
+        EXPECT_TRUE(p.get() == &i);
+
+        not_null<std::shared_ptr<int>> x(
+            std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
+
+        int* pi = nullptr;
+        EXPECT_DEATH((not_null<decltype(pi)>(pi)), expected);
+    }
+
+    {
+        // from pointer to local
+        int t = 42;
+
+        not_null<int*> x = &t;
+        helper(&t);
+        helper_const(&t);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from raw pointer
+        // from not_null pointer
+
+        int t = 42;
+        int* p = &t;
+
+        not_null<int*> x = p;
+        helper(p);
+        helper_const(p);
+        helper(x);
+        helper_const(x);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from raw const pointer
+        // from not_null const pointer
+
+        int t = 42;
+        const int* cp = &t;
+
+        not_null<const int*> x = cp;
+        helper_const(cp);
+        helper_const(x);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from not_null const pointer, using auto
+        int t = 42;
+        const int* cp = &t;
+
+        auto x = not_null<const int*>{cp};
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from returned pointer
+
+        EXPECT_DEATH(helper(return_pointer()), expected);
+        EXPECT_DEATH(helper_const(return_pointer()), expected);
+    }
+}
+
+template <typename T>
+void ostream_helper(T v)
+{
+    not_null<T*> p(&v);
+    {
+        std::ostringstream os;
+        std::ostringstream ref;
+        os << static_cast<void*>(p);
+        ref << static_cast<void*>(&v);
+        EXPECT_TRUE(os.str() == ref.str());
+    }
+    {
+        std::ostringstream os;
+        std::ostringstream ref;
+        os << *p;
+        ref << v;
+        EXPECT_TRUE(os.str() == ref.str());
+    }
+}
+
+TEST(notnull_tests, TestNotNullostream)
+{
+    ostream_helper<int>(17);
+    ostream_helper<float>(21.5f);
+    ostream_helper<double>(3.4566e-7);
+    ostream_helper<char>('c');
+    ostream_helper<uint16_t>(0x0123u);
+    ostream_helper<const char*>("cstring");
+    ostream_helper<std::string>("string");
+}
+
+TEST(notnull_tests, TestNotNullCasting)
+{
+    MyBase base;
+    MyDerived derived;
+    Unrelated unrelated;
+    not_null<Unrelated*> u{&unrelated};
+    (void) u;
+    not_null<MyDerived*> p{&derived};
+    not_null<MyBase*> q(&base);
+    q = p; // allowed with heterogeneous copy ctor
+    EXPECT_TRUE(q == p);
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    q = u; // no viable conversion possible between MyBase* and Unrelated*
+    p = q; // not possible to implicitly convert MyBase* to MyDerived*
+
+    not_null<Unrelated*> r = p;
+    not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
+#endif
+    not_null<Unrelated*> t(reinterpret_cast<Unrelated*>(p.get()));
+    EXPECT_TRUE(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
+}
+
+TEST(notnull_tests, TestNotNullAssignment)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullAssignmentd";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    int i = 12;
+    not_null<int*> p(&i);
+    EXPECT_TRUE(helper(p));
+
+    int* q = nullptr;
+    EXPECT_DEATH(p = not_null<int*>(q), expected);
+}
+
+TEST(notnull_tests, TestNotNullRawPointerComparison)
+{
+    int ints[2] = {42, 43};
+    int* p1 = &ints[0];
+    const int* p2 = &ints[1];
+
+    using NotNull1 = not_null<decltype(p1)>;
+    using NotNull2 = not_null<decltype(p2)>;
+
+    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == true);
+    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == false);
+
+    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == true);
+
+    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
+    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
+
+    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
+    EXPECT_TRUE((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
+
+    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == true);
+    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
+    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
+}
+
+TEST(notnull_tests, TestNotNullDereferenceOperator)
+{
+    {
+        auto sp1 = std::make_shared<NonCopyableNonMovable>();
+
+        using NotNullSp1 = not_null<decltype(sp1)>;
+        EXPECT_TRUE(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
+        EXPECT_TRUE(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
+    }
+
+    {
+        int ints[1] = {42};
+        CustomPtr<int> p1(&ints[0]);
+
+        using NotNull1 = not_null<decltype(p1)>;
+        EXPECT_TRUE(typeid(*NotNull1(p1)) == typeid(*p1));
+        EXPECT_TRUE(*NotNull1(p1) == 42);
+        *NotNull1(p1) = 43;
+        EXPECT_TRUE(ints[0] == 43);
+    }
+
+    {
+        int v = 42;
+        gsl::not_null<int*> p(&v);
+        EXPECT_TRUE(typeid(*p) == typeid(*(&v)));
+        *p = 43;
+        EXPECT_TRUE(v == 43);
+    }
+}
+
+TEST(notnull_tests, TestNotNullSharedPtrComparison)
+{
+    auto sp1 = std::make_shared<int>(42);
+    auto sp2 = std::make_shared<const int>(43);
+
+    using NotNullSp1 = not_null<decltype(sp1)>;
+    using NotNullSp2 = not_null<decltype(sp2)>;
+
+    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);
+
+    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);
+
+    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));
+
+    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));
+
+    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));
+
+    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
+}
+
+TEST(notnull_tests, TestNotNullCustomPtrComparison)
+{
+    int ints[2] = {42, 43};
+    CustomPtr<int> p1(&ints[0]);
+    CustomPtr<const int> p2(&ints[1]);
+
+    using NotNull1 = not_null<decltype(p1)>;
+    using NotNull2 = not_null<decltype(p2)>;
+
+    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == "false");
+
+    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == "true");
+
+    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
+    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
+
+    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
+    EXPECT_TRUE((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
+
+    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
+    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
+
+    EXPECT_TRUE((NotNull1(p1) >= NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
+    EXPECT_TRUE((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
+}
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+
+TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
+{
+    {
+        int i = 42;
+
+        not_null x{&i};
+        helper(not_null{&i});
+        helper_const(not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+
+        not_null x{&i};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(not_null{&i});
+#endif
+        helper_const(not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        not_null x{p};
+        helper(not_null{p});
+        helper_const(not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+        const int* p = &i;
+
+        not_null x{p};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(not_null{p});
+#endif
+        helper_const(not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullConstructorTypeDeduction";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(not_null{p}), expected);
+        EXPECT_DEATH(helper_const(not_null{p}), expected);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        not_null x{nullptr};
+        helper(not_null{nullptr});
+        helper_const(not_null{nullptr});
+    }
+#endif
+}
+
+TEST(notnull_tests, TestVariantEmplace)
+{
+    int i = 0;
+    std::variant<std::monostate, not_null<int*>> v;
+    v.emplace<not_null<int*>>(&i);
+
+    EXPECT_FALSE(v.valueless_by_exception());
+    EXPECT_TRUE(v.index() == 1);
+    EXPECT_TRUE(std::get<not_null<int*>>(v) == &i);
+}
+#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)
+
+TEST(notnull_tests, TestMakeNotNull)
+{
+    {
+        int i = 42;
+
+        const auto x = make_not_null(&i);
+        helper(make_not_null(&i));
+        helper_const(make_not_null(&i));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+
+        const auto x = make_not_null(&i);
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(make_not_null(&i));
+#endif
+        helper_const(make_not_null(&i));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        const auto x = make_not_null(p);
+        helper(make_not_null(p));
+        helper_const(make_not_null(p));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+        const int* p = &i;
+
+        const auto x = make_not_null(p);
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(make_not_null(p));
+#endif
+        helper_const(make_not_null(p));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestMakeNotNull";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        const auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const auto x = make_not_null(p1);
+            EXPECT_TRUE(*x == 42);
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        const auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const auto x = make_not_null(p1);
+            EXPECT_TRUE(*x == 42);
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(make_not_null(p)), expected);
+        EXPECT_DEATH(helper_const(make_not_null(p)), expected);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        EXPECT_DEATH(make_not_null(nullptr), expected);
+        EXPECT_DEATH(helper(make_not_null(nullptr)), expected);
+        EXPECT_DEATH(helper_const(make_not_null(nullptr)), expected);
+    }
+#endif
+}
+
+TEST(notnull_tests, TestStdHash)
+{
+    {
+        int x = 42;
+        int y = 99;
+        not_null<int*> nn{&x};
+        const not_null<int*> cnn{&x};
+
+        std::hash<not_null<int*>> hash_nn;
+        std::hash<int*> hash_intptr;
+
+        EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
+    }
+
+    {
+        const int x = 42;
+        const int y = 99;
+        not_null<const int*> nn{&x};
+        const not_null<const int*> cnn{&x};
+
+        std::hash<not_null<const int*>> hash_nn;
+        std::hash<const int*> hash_intptr;
+
+        EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
+    }
+}

Telegram/ThirdParty/GSL/tests/owner_tests.cpp

@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gtest/gtest.h>
+
+#include <gsl/pointers> // for owner
+
+using namespace gsl;
+
+GSL_SUPPRESS(f .23) // NO-FORMAT: attribute
+void f(int* i) { *i += 1; }
+
+TEST(owner_tests, basic_test)
+{
+    owner<int*> p = new int(120);
+    EXPECT_TRUE(*p == 120);
+    f(p);
+    EXPECT_TRUE(*p == 121);
+    delete p;
+}
+
+TEST(owner_tests, check_pointer_constraint)
+{
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        owner<int> integerTest = 10;
+        owner<std::shared_ptr<int>> sharedPtrTest(new int(10));
+    }
+#endif
+}

Telegram/ThirdParty/GSL/tests/span_ext_tests.cpp

@@ -0,0 +1,380 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gtest/gtest.h>
+
+#include <gsl/span> // for span and span_ext
+#include <gsl/util> // for narrow_cast, at
+
+#include <array>     // for array
+#include <exception> // for terminate
+#include <iostream>  // for cerr
+#include <vector>    // for vector
+
+using namespace std;
+using namespace gsl;
+
+#include "deathTestCommon.h"
+
+TEST(span_ext_test, make_span_from_pointer_length_constructor)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. from_pointer_length_constructor";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    int arr[4] = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(&arr[0], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
+    }
+
+    {
+        int* p = nullptr;
+        auto s = make_span(p, narrow_cast<gsl::span<int>::size_type>(0));
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
+    }
+
+    {
+        int* p = nullptr;
+        auto workaround_macro = [=]() { make_span(p, 2); };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+}
+
+TEST(span_ext_test, make_span_from_pointer_pointer_construction)
+{
+    int arr[4] = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(&arr[0], &arr[2]);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
+    }
+
+    {
+        auto s = make_span(&arr[0], &arr[0]);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
+    }
+
+    {
+        int* p = nullptr;
+        auto s = make_span(p, p);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
+    }
+}
+
+TEST(span_ext_test, make_span_from_array_constructor)
+{
+    int arr[5] = {1, 2, 3, 4, 5};
+    int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
+    int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+    {
+        const auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == 5);
+        EXPECT_TRUE(s.data() == std::addressof(arr[0]));
+    }
+
+    {
+        const auto s = make_span(std::addressof(arr2d[0]), 1);
+        EXPECT_TRUE(s.size() == 1);
+        EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
+    }
+
+    {
+        const auto s = make_span(std::addressof(arr3d[0]), 1);
+        EXPECT_TRUE(s.size() == 1);
+        EXPECT_TRUE(s.data() == std::addressof(arr3d[0]));
+    }
+}
+
+TEST(span_ext_test, make_span_from_dynamic_array_constructor)
+{
+    double(*arr)[3][4] = new double[100][3][4];
+
+    {
+        auto s = make_span(&arr[0][0][0], 10);
+        EXPECT_TRUE(s.size() == 10);
+        EXPECT_TRUE(s.data() == &arr[0][0][0]);
+    }
+
+    delete[] arr;
+}
+
+TEST(span_ext_test, make_span_from_std_array_constructor)
+{
+    std::array<int, 4> arr = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == arr.size());
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+
+    // This test checks for the bug found in gcc 6.1, 6.2, 6.3, 6.4, 6.5 7.1, 7.2, 7.3 - issue #590
+    {
+        gsl::span<int> s1 = make_span(arr);
+
+        static gsl::span<int> s2;
+        s2 = s1;
+
+#if defined(__GNUC__) && __GNUC__ == 6 && (__GNUC_MINOR__ == 4 || __GNUC_MINOR__ == 5) &&          \
+    __GNUC_PATCHLEVEL__ == 0 && defined(__OPTIMIZE__)
+        // Known to be broken in gcc 6.4 and 6.5 with optimizations
+        // Issue in gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83116
+        EXPECT_TRUE(s1.size() == 4);
+        EXPECT_TRUE(s2.size() == 0);
+#else
+        EXPECT_TRUE(s1.size() == s2.size());
+#endif
+    }
+}
+
+TEST(span_ext_test, make_span_from_const_std_array_constructor)
+{
+    const std::array<int, 4> arr = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == arr.size());
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+}
+
+TEST(span_ext_test, make_span_from_std_array_const_constructor)
+{
+    std::array<const int, 4> arr = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == arr.size());
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+}
+
+TEST(span_ext_test, make_span_from_container_constructor)
+{
+    std::vector<int> v = {1, 2, 3};
+    const std::vector<int> cv = v;
+
+    {
+        auto s = make_span(v);
+        EXPECT_TRUE(s.size() == v.size());
+        EXPECT_TRUE(s.data() == v.data());
+
+        auto cs = make_span(cv);
+        EXPECT_TRUE(cs.size() == cv.size());
+        EXPECT_TRUE(cs.data() == cv.data());
+    }
+}
+
+TEST(span_test, interop_with_gsl_at)
+{
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    gsl::span<int> sp{vec};
+
+    std::vector<int> cvec{1, 2, 3, 4, 5};
+    gsl::span<int> csp{cvec};
+
+    for (gsl::index i = 0; i < gsl::narrow_cast<gsl::index>(vec.size()); ++i)
+    {
+        EXPECT_TRUE(&gsl::at(sp, i) == &vec[gsl::narrow_cast<size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(csp, i) == &cvec[gsl::narrow_cast<size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. interop_with_gsl_at";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(sp, -1), expected);
+    EXPECT_DEATH(gsl::at(sp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+    EXPECT_DEATH(gsl::at(csp, -1), expected);
+    EXPECT_DEATH(gsl::at(csp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+}
+
+TEST(span_ext_test, iterator_free_functions)
+{
+    int a[] = {1, 2, 3, 4};
+    gsl::span<int> s{a};
+
+    EXPECT_TRUE((std::is_same<decltype(s.begin()), decltype(begin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(s.end()), decltype(end(s))>::value));
+
+    EXPECT_TRUE((std::is_same<decltype(std::cbegin(s)), decltype(cbegin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(std::cend(s)), decltype(cend(s))>::value));
+
+    EXPECT_TRUE((std::is_same<decltype(s.rbegin()), decltype(rbegin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(s.rend()), decltype(rend(s))>::value));
+
+    EXPECT_TRUE((std::is_same<decltype(std::crbegin(s)), decltype(crbegin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(std::crend(s)), decltype(crend(s))>::value));
+
+    EXPECT_TRUE(s.begin() == begin(s));
+    EXPECT_TRUE(s.end() == end(s));
+
+    EXPECT_TRUE(s.rbegin() == rbegin(s));
+    EXPECT_TRUE(s.rend() == rend(s));
+
+    EXPECT_TRUE(s.begin() == cbegin(s));
+    EXPECT_TRUE(s.end() == cend(s));
+
+    EXPECT_TRUE(s.rbegin() == crbegin(s));
+    EXPECT_TRUE(s.rend() == crend(s));
+}
+
+TEST(span_ext_test, ssize_free_function)
+{
+    int a[] = {1, 2, 3, 4};
+    gsl::span<int> s{a};
+
+    EXPECT_FALSE((std::is_same<decltype(s.size()), decltype(ssize(s))>::value));
+    EXPECT_TRUE(s.size() == static_cast<std::size_t>(ssize(s)));
+}
+
+#ifndef GSL_KERNEL_MODE
+TEST(span_ext_test, comparison_operators)
+{
+    {
+        gsl::span<int> s1;
+        gsl::span<int> s2;
+        EXPECT_TRUE(s1 == s2);
+        EXPECT_FALSE(s1 != s2);
+        EXPECT_FALSE(s1 < s2);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s1 >= s2);
+        EXPECT_TRUE(s2 == s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_TRUE(s2 <= s1);
+        EXPECT_FALSE(s2 > s1);
+        EXPECT_TRUE(s2 >= s1);
+    }
+
+    {
+        int arr[] = {2, 1};
+        gsl::span<int> s1 = arr;
+        gsl::span<int> s2 = arr;
+
+        EXPECT_TRUE(s1 == s2);
+        EXPECT_FALSE(s1 != s2);
+        EXPECT_FALSE(s1 < s2);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s1 >= s2);
+        EXPECT_TRUE(s2 == s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s2 <= s1);
+        EXPECT_FALSE(s2 > s1);
+        EXPECT_TRUE(s2 >= s1);
+    }
+
+    {
+        int arr[] = {2, 1}; // bigger
+
+        gsl::span<int> s1;
+        gsl::span<int> s2 = arr;
+
+        EXPECT_TRUE(s1 != s2);
+        EXPECT_TRUE(s2 != s1);
+        EXPECT_FALSE(s1 == s2);
+        EXPECT_FALSE(s2 == s1);
+        EXPECT_TRUE(s1 < s2);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s2 <= s1);
+        EXPECT_TRUE(s2 > s1);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s2 >= s1);
+        EXPECT_FALSE(s1 >= s2);
+    }
+
+    {
+        int arr1[] = {1, 2};
+        int arr2[] = {1, 2};
+        gsl::span<int> s1 = arr1;
+        gsl::span<int> s2 = arr2;
+
+        EXPECT_TRUE(s1 == s2);
+        EXPECT_FALSE(s1 != s2);
+        EXPECT_FALSE(s1 < s2);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s1 >= s2);
+        EXPECT_TRUE(s2 == s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s2 <= s1);
+        EXPECT_FALSE(s2 > s1);
+        EXPECT_TRUE(s2 >= s1);
+    }
+
+    {
+        int arr[] = {1, 2, 3};
+
+        gsl::span<int> s1 = {&arr[0], 2}; // shorter
+        gsl::span<int> s2 = arr;          // longer
+
+        EXPECT_TRUE(s1 != s2);
+        EXPECT_TRUE(s2 != s1);
+        EXPECT_FALSE(s1 == s2);
+        EXPECT_FALSE(s2 == s1);
+        EXPECT_TRUE(s1 < s2);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s2 <= s1);
+        EXPECT_TRUE(s2 > s1);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s2 >= s1);
+        EXPECT_FALSE(s1 >= s2);
+    }
+
+    {
+        int arr1[] = {1, 2}; // smaller
+        int arr2[] = {2, 1}; // bigger
+
+        gsl::span<int> s1 = arr1;
+        gsl::span<int> s2 = arr2;
+
+        EXPECT_TRUE(s1 != s2);
+        EXPECT_TRUE(s2 != s1);
+        EXPECT_FALSE(s1 == s2);
+        EXPECT_FALSE(s2 == s1);
+        EXPECT_TRUE(s1 < s2);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s2 <= s1);
+        EXPECT_TRUE(s2 > s1);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s2 >= s1);
+        EXPECT_FALSE(s1 >= s2);
+    }
+}
+#endif // GSL_KERNEL_MODE

Telegram/ThirdParty/GSL/tests/strict_notnull_tests.cpp

@@ -0,0 +1,304 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gsl/pointers> // for not_null, operator<, operator<=, operator>
+#include <gtest/gtest.h>
+
+#include "deathTestCommon.h"
+
+using namespace gsl;
+
+namespace
+{
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool helper(not_null<int*> p) { return *p == 12; }
+
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool helper_const(not_null<const int*> p) { return *p == 12; }
+
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool strict_helper(strict_not_null<int*> p) { return *p == 12; }
+
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool strict_helper_const(strict_not_null<const int*> p) { return *p == 12; }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+int* return_pointer() { return nullptr; }
+const int* return_pointer_const() { return nullptr; }
+#endif
+} // namespace
+
+TEST(strict_notnull_tests, TestStrictNotNull)
+{
+    {
+        // raw ptr <-> strict_not_null
+        int x = 42;
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_not_null<int*> snn = &x;
+        strict_helper(&x);
+        strict_helper_const(&x);
+        strict_helper(return_pointer());
+        strict_helper_const(return_pointer_const());
+#endif
+
+        const strict_not_null<int*> snn1{&x};
+
+        helper(snn1);
+        helper_const(snn1);
+
+        EXPECT_TRUE(*snn1 == 42);
+    }
+
+    {
+        // raw ptr <-> strict_not_null
+        const int x = 42;
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_not_null<int*> snn = &x;
+        strict_helper(&x);
+        strict_helper_const(&x);
+        strict_helper(return_pointer());
+        strict_helper_const(return_pointer_const());
+#endif
+
+        const strict_not_null<const int*> snn1{&x};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(snn1);
+#endif
+        helper_const(snn1);
+
+        EXPECT_TRUE(*snn1 == 42);
+    }
+
+    {
+        // strict_not_null -> strict_not_null
+        int x = 42;
+
+        strict_not_null<int*> snn1{&x};
+        const strict_not_null<int*> snn2{&x};
+
+        strict_helper(snn1);
+        strict_helper_const(snn1);
+        strict_helper_const(snn2);
+
+        EXPECT_TRUE(snn1 == snn2);
+    }
+
+    {
+        // strict_not_null -> strict_not_null
+        const int x = 42;
+
+        strict_not_null<const int*> snn1{&x};
+        const strict_not_null<const int*> snn2{&x};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_helper(snn1);
+#endif
+        strict_helper_const(snn1);
+        strict_helper_const(snn2);
+
+        EXPECT_TRUE(snn1 == snn2);
+    }
+
+    {
+        // strict_not_null -> not_null
+        int x = 42;
+
+        strict_not_null<int*> snn{&x};
+
+        const not_null<int*> nn1 = snn;
+        const not_null<int*> nn2{snn};
+
+        helper(snn);
+        helper_const(snn);
+
+        EXPECT_TRUE(snn == nn1);
+        EXPECT_TRUE(snn == nn2);
+    }
+
+    {
+        // strict_not_null -> not_null
+        const int x = 42;
+
+        strict_not_null<const int*> snn{&x};
+
+        const not_null<const int*> nn1 = snn;
+        const not_null<const int*> nn2{snn};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(snn);
+#endif
+        helper_const(snn);
+
+        EXPECT_TRUE(snn == nn1);
+        EXPECT_TRUE(snn == nn2);
+    }
+
+    {
+        // not_null -> strict_not_null
+        int x = 42;
+
+        not_null<int*> nn{&x};
+
+        const strict_not_null<int*> snn1{nn};
+        const strict_not_null<int*> snn2{nn};
+
+        strict_helper(nn);
+        strict_helper_const(nn);
+
+        EXPECT_TRUE(snn1 == nn);
+        EXPECT_TRUE(snn2 == nn);
+
+        std::hash<strict_not_null<int*>> hash_snn;
+        std::hash<not_null<int*>> hash_nn;
+
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
+        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
+    }
+
+    {
+        // not_null -> strict_not_null
+        const int x = 42;
+
+        not_null<const int*> nn{&x};
+
+        const strict_not_null<const int*> snn1{nn};
+        const strict_not_null<const int*> snn2{nn};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_helper(nn);
+#endif
+        strict_helper_const(nn);
+
+        EXPECT_TRUE(snn1 == nn);
+        EXPECT_TRUE(snn2 == nn);
+
+        std::hash<strict_not_null<const int*>> hash_snn;
+        std::hash<not_null<const int*>> hash_nn;
+
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
+        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        strict_not_null<int*> p{nullptr};
+    }
+#endif
+}
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+
+TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestStrictNotNullConstructorTypeDeduction";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        int i = 42;
+
+        strict_not_null x{&i};
+        helper(strict_not_null{&i});
+        helper_const(strict_not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+
+        strict_not_null x{&i};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(strict_not_null{&i});
+#endif
+        helper_const(strict_not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        strict_not_null x{p};
+        helper(strict_not_null{p});
+        helper_const(strict_not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+        const int* p = &i;
+
+        strict_not_null x{p};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(strict_not_null{p});
+#endif
+        helper_const(strict_not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const strict_not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const strict_not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(strict_not_null{p}), expected);
+        EXPECT_DEATH(helper_const(strict_not_null{p}), expected);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        strict_not_null x{nullptr};
+        helper(strict_not_null{nullptr});
+        helper_const(strict_not_null{nullptr});
+    }
+#endif
+}
+#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)

Telegram/ThirdParty/GSL/tests/utils_tests.cpp

@@ -0,0 +1,165 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 <gtest/gtest.h>
+
+#include <algorithm>   // for move
+#include <complex>
+#include <cstddef>     // for std::ptrdiff_t
+#include <cstdint>     // for uint32_t, int32_t
+#include <functional>  // for reference_wrapper, _Bind_helper<>::type
+#include <gsl/narrow>  // for narrow, narrowing_error
+#include <gsl/util>    // finally, narrow_cast
+#include <limits>      // for numeric_limits
+#include <type_traits> // for is_same
+
+using namespace gsl;
+
+namespace
+{
+void f(int& i) { i += 1; }
+static int j = 0;
+void g() { j += 1; }
+} // namespace
+
+TEST(utils_tests, sanity_check_for_gsl_index_typedef)
+{
+    static_assert(std::is_same<gsl::index, std::ptrdiff_t>::value,
+                  "gsl::index represents wrong arithmetic type");
+}
+
+TEST(utils_tests, finally_lambda)
+{
+    int i = 0;
+    {
+        auto _ = finally([&]() { f(i); });
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_lambda_move)
+{
+    int i = 0;
+    {
+        auto _1 = finally([&]() { f(i); });
+        {
+            auto _2 = std::move(_1);
+            EXPECT_TRUE(i == 0);
+        }
+        EXPECT_TRUE(i == 1);
+        {
+            auto _2 = std::move(_1);
+            EXPECT_TRUE(i == 1);
+        }
+        EXPECT_TRUE(i == 1);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_const_lvalue_lambda)
+{
+    int i = 0;
+    {
+        const auto const_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(const_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_mutable_lvalue_lambda)
+{
+    int i = 0;
+    {
+        auto mutable_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(mutable_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_function_with_bind)
+{
+    int i = 0;
+    {
+        auto _ = finally([&i] { return f(i); });
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_function_ptr)
+{
+    j = 0;
+    {
+        auto _ = finally(&g);
+        EXPECT_TRUE(j == 0);
+    }
+    EXPECT_TRUE(j == 1);
+}
+
+TEST(utils_tests, finally_function)
+{
+    j = 0;
+    {
+        auto _ = finally(g);
+        EXPECT_TRUE(j == 0);
+    }
+    EXPECT_TRUE(j == 1);
+}
+
+TEST(utils_tests, narrow_cast)
+{
+    int n = 120;
+    char c = narrow_cast<char>(n);
+    EXPECT_TRUE(c == 120);
+
+    n = 300;
+    unsigned char uc = narrow_cast<unsigned char>(n);
+    EXPECT_TRUE(uc == 44);
+}
+
+#ifndef GSL_KERNEL_MODE
+TEST(utils_tests, narrow)
+{
+    int n = 120;
+    const char c = narrow<char>(n);
+    EXPECT_TRUE(c == 120);
+
+    n = 300;
+    EXPECT_THROW(narrow<char>(n), narrowing_error);
+
+    const auto int32_max = std::numeric_limits<int32_t>::max();
+    const auto int32_min = std::numeric_limits<int32_t>::min();
+
+    EXPECT_TRUE(narrow<uint32_t>(int32_t(0)) == 0);
+    EXPECT_TRUE(narrow<uint32_t>(int32_t(1)) == 1);
+    EXPECT_TRUE(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
+
+    EXPECT_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
+    EXPECT_THROW(narrow<uint32_t>(int32_min), narrowing_error);
+
+    n = -42;
+    EXPECT_THROW(narrow<unsigned>(n), narrowing_error);
+
+    EXPECT_TRUE(
+        narrow<std::complex<float>>(std::complex<double>(4, 2)) == std::complex<float>(4, 2));
+    EXPECT_THROW(narrow<std::complex<float>>(std::complex<double>(4.2)), narrowing_error);
+
+    EXPECT_TRUE(narrow<int>(float(1)) == 1);
+}
+#endif // GSL_KERNEL_MODE

Telegram/ThirdParty/QR/Readme.markdown

@@ -0,0 +1,91 @@
+QR Code generator library
+=========================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library in multiple languages. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: [https://www.nayuki.io/page/qr-code-generator-library](https://www.nayuki.io/page/qr-code-generator-library)
+
+
+Features
+--------
+
+Core features:
+
+* Available in 6 programming languages, all with nearly equal functionality: Java, TypeScript/JavaScript, Python, Rust, C++, C
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+Optional advanced features (Java only):
+
+* Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes
+* Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+The code below is in Java, but the other language ports are designed with essentially the same API naming and behavior.
+
+```java
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.List;
+import javax.imageio.ImageIO;
+import io.nayuki.qrcodegen.*;
+
+// Simple operation
+QrCode qr0 = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
+BufferedImage img = toImage(qr0, 4, 10);  // See QrCodeGeneratorDemo
+ImageIO.write(img, "png", new File("qr-code.png"));
+
+// Manual operation
+List<QrSegment> segs = QrSegment.makeSegments("3141592653589793238462643383");
+QrCode qr1 = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
+for (int y = 0; y < qr1.size; y++) {
+    for (int x = 0; x < qr1.size; x++) {
+        (... paint qr1.getModule(x, y) ...)
+    }
+}
+```
+
+
+License
+-------
+
+Copyright © 2022 Project Nayuki. (MIT License)  
+[https://www.nayuki.io/page/qr-code-generator-library](https://www.nayuki.io/page/qr-code-generator-library)
+
+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.

Telegram/ThirdParty/QR/c/Makefile

@@ -0,0 +1,88 @@
+# 
+# Makefile for QR Code generator (C)
+# 
+# Copyright (c) Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/qr-code-generator-library
+# 
+# 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.
+# 
+
+
+# ---- Configuration options ----
+
+# External/implicit variables:
+# - CC: The C compiler, such as gcc or clang.
+# - CFLAGS: Any extra user-specified compiler flags (can be blank).
+
+# Recommended compiler flags:
+CFLAGS += -std=c99 -O
+
+# Extra flags for diagnostics:
+# CFLAGS += -g -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -fsanitize=undefined,address
+
+
+# ---- Controlling make ----
+
+# Clear default suffix rules
+.SUFFIXES:
+
+# Don't delete object files
+.SECONDARY:
+
+# Stuff concerning goals
+.DEFAULT_GOAL = all
+.PHONY: all clean
+
+
+# ---- Targets to build ----
+
+LIB = qrcodegen
+LIBFILE = lib$(LIB).a
+LIBOBJ = qrcodegen.o
+MAINS = qrcodegen-demo qrcodegen-test
+
+# Build all binaries
+all: $(LIBFILE) $(MAINS)
+
+# Delete build output
+clean:
+	rm -f -- $(LIBOBJ) $(LIBFILE) $(MAINS:=.o) $(MAINS)
+	rm -rf .deps
+
+# Executable files
+%: %.o $(LIBFILE)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< -L . -l $(LIB)
+
+# Special executable
+qrcodegen-test: qrcodegen-test.c $(LIBOBJ:%.o=%.c)
+	$(CC) $(CFLAGS) $(LDFLAGS) -DQRCODEGEN_TEST -o $@ $^
+
+# The library
+$(LIBFILE): $(LIBOBJ)
+	$(AR) -crs $@ -- $^
+
+# Object files
+%.o: %.c .deps/timestamp
+	$(CC) $(CFLAGS) -c -o $@ -MMD -MF .deps/$*.d $<
+
+# Have a place to store header dependencies automatically generated by compiler
+.deps/timestamp:
+	mkdir -p .deps
+	touch .deps/timestamp
+
+# Make use of said dependencies if available
+-include .deps/*.d

Telegram/ThirdParty/QR/c/Readme.markdown

@@ -0,0 +1,70 @@
+QR Code generator library - C
+=============================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Completely avoids heap allocation (`malloc()`), instead relying on suitably sized buffers from the caller and fixed-size stack allocations
+* Coded carefully to prevent memory corruption, integer overflow, platform-dependent inconsistencies, and undefined behavior; tested rigorously to confirm safety
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```c
+#include <stdbool.h>
+#include <stdint.h>
+#include "qrcodegen.h"
+
+// Text data
+uint8_t qr0[qrcodegen_BUFFER_LEN_MAX];
+uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+bool ok = qrcodegen_encodeText("Hello, world!",
+    tempBuffer, qr0, qrcodegen_Ecc_MEDIUM,
+    qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX,
+    qrcodegen_Mask_AUTO, true);
+if (!ok)
+    return;
+
+int size = qrcodegen_getSize(qr0);
+for (int y = 0; y < size; y++) {
+    for (int x = 0; x < size; x++) {
+        (... paint qrcodegen_getModule(qr0, x, y) ...)
+    }
+}
+
+// Binary data
+uint8_t dataAndTemp[qrcodegen_BUFFER_LEN_FOR_VERSION(7)]
+    = {0xE3, 0x81, 0x82};
+uint8_t qr1[qrcodegen_BUFFER_LEN_FOR_VERSION(7)];
+ok = qrcodegen_encodeBinary(dataAndTemp, 3, qr1,
+    qrcodegen_Ecc_HIGH, 2, 7, qrcodegen_Mask_4, false);
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/c/qrcodegen-demo.c .

Telegram/ThirdParty/QR/c/qrcodegen-demo.c

@@ -0,0 +1,335 @@
+/* 
+ * QR Code generator demo (C)
+ * 
+ * Run this command-line program with no arguments. The program
+ * computes a demonstration QR Codes and print it to the console.
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "qrcodegen.h"
+
+
+// Function prototypes
+static void doBasicDemo(void);
+static void doVarietyDemo(void);
+static void doSegmentDemo(void);
+static void doMaskDemo(void);
+static void printQr(const uint8_t qrcode[]);
+
+
+// The main application program.
+int main(void) {
+	doBasicDemo();
+	doVarietyDemo();
+	doSegmentDemo();
+	doMaskDemo();
+	return EXIT_SUCCESS;
+}
+
+
+
+/*---- Demo suite ----*/
+
+// Creates a single QR Code, then prints it to the console.
+static void doBasicDemo(void) {
+	const char *text = "Hello, world!";                // User-supplied text
+	enum qrcodegen_Ecc errCorLvl = qrcodegen_Ecc_LOW;  // Error correction level
+	
+	// Make and print the QR Code symbol
+	uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+	uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+	bool ok = qrcodegen_encodeText(text, tempBuffer, qrcode, errCorLvl,
+		qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+	if (ok)
+		printQr(qrcode);
+}
+
+
+// Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console.
+static void doVarietyDemo(void) {
+	{  // Numeric mode encoding (3.33 bits per digit)
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok = qrcodegen_encodeText("314159265358979323846264338327950288419716939937510", tempBuffer, qrcode,
+			qrcodegen_Ecc_MEDIUM, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+		if (ok)
+			printQr(qrcode);
+	}
+	
+	{  // Alphanumeric mode encoding (5.5 bits per character)
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok = qrcodegen_encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", tempBuffer, qrcode,
+			qrcodegen_Ecc_HIGH, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+		if (ok)
+			printQr(qrcode);
+	}
+	
+	{  // Unicode text as UTF-8
+		const char *text = "\xE3\x81\x93\xE3\x82\x93\xE3\x81\xAB\xE3\x81\xA1wa\xE3\x80\x81"
+			"\xE4\xB8\x96\xE7\x95\x8C\xEF\xBC\x81\x20\xCE\xB1\xCE\xB2\xCE\xB3\xCE\xB4";
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok = qrcodegen_encodeText(text, tempBuffer, qrcode,
+			qrcodegen_Ecc_QUARTILE, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+		if (ok)
+			printQr(qrcode);
+	}
+	
+	{  // Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+		const char *text =
+			"Alice was beginning to get very tired of sitting by her sister on the bank, "
+			"and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
+			"but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
+			"'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
+			"for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
+			"daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
+			"a White Rabbit with pink eyes ran close by her.";
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok = qrcodegen_encodeText(text, tempBuffer, qrcode,
+			qrcodegen_Ecc_HIGH, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+		if (ok)
+			printQr(qrcode);
+	}
+}
+
+
+// Creates QR Codes with manually specified segments for better compactness.
+static void doSegmentDemo(void) {
+	{  // Illustration "silver"
+		const char *silver0 = "THE SQUARE ROOT OF 2 IS 1.";
+		const char *silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok;
+		{
+			char *concat = calloc(strlen(silver0) + strlen(silver1) + 1, sizeof(char));
+			if (concat == NULL) {
+				perror("calloc");
+				exit(EXIT_FAILURE);
+			}
+			strcat(concat, silver0);
+			strcat(concat, silver1);
+			ok = qrcodegen_encodeText(concat, tempBuffer, qrcode, qrcodegen_Ecc_LOW,
+				qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+			if (ok)
+				printQr(qrcode);
+			free(concat);
+		}
+		{
+			uint8_t *segBuf0 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_ALPHANUMERIC, strlen(silver0)) * sizeof(uint8_t));
+			uint8_t *segBuf1 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_NUMERIC, strlen(silver1)) * sizeof(uint8_t));
+			if (segBuf0 == NULL || segBuf1 == NULL) {
+				perror("malloc");
+				exit(EXIT_FAILURE);
+			}
+			struct qrcodegen_Segment segs[] = {
+				qrcodegen_makeAlphanumeric(silver0, segBuf0),
+				qrcodegen_makeNumeric(silver1, segBuf1),
+			};
+			ok = qrcodegen_encodeSegments(segs, sizeof(segs) / sizeof(segs[0]), qrcodegen_Ecc_LOW, tempBuffer, qrcode);
+			free(segBuf0);
+			free(segBuf1);
+			if (ok)
+				printQr(qrcode);
+		}
+	}
+	
+	{  // Illustration "golden"
+		const char *golden0 = "Golden ratio \xCF\x86 = 1.";
+		const char *golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+		const char *golden2 = "......";
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok;
+		{
+			char *concat = calloc(strlen(golden0) + strlen(golden1) + strlen(golden2) + 1, sizeof(char));
+			if (concat == NULL) {
+				perror("calloc");
+				exit(EXIT_FAILURE);
+			}
+			strcat(concat, golden0);
+			strcat(concat, golden1);
+			strcat(concat, golden2);
+			ok = qrcodegen_encodeText(concat, tempBuffer, qrcode, qrcodegen_Ecc_LOW,
+				qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+			if (ok)
+				printQr(qrcode);
+			free(concat);
+		}
+		{
+			uint8_t *bytes = malloc(strlen(golden0) * sizeof(uint8_t));
+			if (bytes == NULL) {
+				perror("malloc");
+				exit(EXIT_FAILURE);
+			}
+			for (size_t i = 0, len = strlen(golden0); i < len; i++)
+				bytes[i] = (uint8_t)golden0[i];
+			uint8_t *segBuf0 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_BYTE, strlen(golden0)) * sizeof(uint8_t));
+			uint8_t *segBuf1 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_NUMERIC, strlen(golden1)) * sizeof(uint8_t));
+			uint8_t *segBuf2 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_ALPHANUMERIC, strlen(golden2)) * sizeof(uint8_t));
+			if (segBuf0 == NULL || segBuf1 == NULL || segBuf2 == NULL) {
+				perror("malloc");
+				exit(EXIT_FAILURE);
+			}
+			struct qrcodegen_Segment segs[] = {
+				qrcodegen_makeBytes(bytes, strlen(golden0), segBuf0),
+				qrcodegen_makeNumeric(golden1, segBuf1),
+				qrcodegen_makeAlphanumeric(golden2, segBuf2),
+			};
+			free(bytes);
+			ok = qrcodegen_encodeSegments(segs, sizeof(segs) / sizeof(segs[0]), qrcodegen_Ecc_LOW, tempBuffer, qrcode);
+			free(segBuf0);
+			free(segBuf1);
+			free(segBuf2);
+			if (ok)
+				printQr(qrcode);
+		}
+	}
+	
+	{  // Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok;
+		{
+			const char *madoka =  // Encoded in UTF-8
+				"\xE3\x80\x8C\xE9\xAD\x94\xE6\xB3\x95\xE5"
+				"\xB0\x91\xE5\xA5\xB3\xE3\x81\xBE\xE3\x81"
+				"\xA9\xE3\x81\x8B\xE2\x98\x86\xE3\x83\x9E"
+				"\xE3\x82\xAE\xE3\x82\xAB\xE3\x80\x8D\xE3"
+				"\x81\xA3\xE3\x81\xA6\xE3\x80\x81\xE3\x80"
+				"\x80\xD0\x98\xD0\x90\xD0\x98\xE3\x80\x80"
+				"\xEF\xBD\x84\xEF\xBD\x85\xEF\xBD\x93\xEF"
+				"\xBD\x95\xE3\x80\x80\xCE\xBA\xCE\xB1\xEF"
+				"\xBC\x9F";
+			ok = qrcodegen_encodeText(madoka, tempBuffer, qrcode, qrcodegen_Ecc_LOW,
+				qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+			if (ok)
+				printQr(qrcode);
+		}
+		{
+			const int kanjiChars[] = {  // Kanji mode encoding (13 bits per character)
+				0x0035, 0x1002, 0x0FC0, 0x0AED, 0x0AD7,
+				0x015C, 0x0147, 0x0129, 0x0059, 0x01BD,
+				0x018D, 0x018A, 0x0036, 0x0141, 0x0144,
+				0x0001, 0x0000, 0x0249, 0x0240, 0x0249,
+				0x0000, 0x0104, 0x0105, 0x0113, 0x0115,
+				0x0000, 0x0208, 0x01FF, 0x0008,
+			};
+			size_t len = sizeof(kanjiChars) / sizeof(kanjiChars[0]);
+			uint8_t *segBuf = calloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_KANJI, len), sizeof(uint8_t));
+			if (segBuf == NULL) {
+				perror("calloc");
+				exit(EXIT_FAILURE);
+			}
+			struct qrcodegen_Segment seg;
+			seg.mode = qrcodegen_Mode_KANJI;
+			seg.numChars = (int)len;
+			seg.bitLength = 0;
+			for (size_t i = 0; i < len; i++) {
+				for (int j = 12; j >= 0; j--, seg.bitLength++)
+					segBuf[seg.bitLength >> 3] |= ((kanjiChars[i] >> j) & 1) << (7 - (seg.bitLength & 7));
+			}
+			seg.data = segBuf;
+			ok = qrcodegen_encodeSegments(&seg, 1, qrcodegen_Ecc_LOW, tempBuffer, qrcode);
+			free(segBuf);
+			if (ok)
+				printQr(qrcode);
+		}
+	}
+}
+
+
+// Creates QR Codes with the same size and contents but different mask patterns.
+static void doMaskDemo(void) {
+	{  // Project Nayuki URL
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok;
+		
+		ok = qrcodegen_encodeText("https://www.nayuki.io/", tempBuffer, qrcode,
+			qrcodegen_Ecc_HIGH, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+		if (ok)
+			printQr(qrcode);
+		
+		ok = qrcodegen_encodeText("https://www.nayuki.io/", tempBuffer, qrcode,
+			qrcodegen_Ecc_HIGH, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_3, true);
+		if (ok)
+			printQr(qrcode);
+	}
+	
+	{  // Chinese text as UTF-8
+		const char *text =
+			"\xE7\xB6\xAD\xE5\x9F\xBA\xE7\x99\xBE\xE7\xA7\x91\xEF\xBC\x88\x57\x69\x6B\x69\x70"
+			"\x65\x64\x69\x61\xEF\xBC\x8C\xE8\x81\x86\xE8\x81\xBD\x69\x2F\xCB\x8C\x77\xC9\xAA"
+			"\x6B\xE1\xB5\xBB\xCB\x88\x70\x69\xCB\x90\x64\x69\x2E\xC9\x99\x2F\xEF\xBC\x89\xE6"
+			"\x98\xAF\xE4\xB8\x80\xE5\x80\x8B\xE8\x87\xAA\xE7\x94\xB1\xE5\x85\xA7\xE5\xAE\xB9"
+			"\xE3\x80\x81\xE5\x85\xAC\xE9\x96\x8B\xE7\xB7\xA8\xE8\xBC\xAF\xE4\xB8\x94\xE5\xA4"
+			"\x9A\xE8\xAA\x9E\xE8\xA8\x80\xE7\x9A\x84\xE7\xB6\xB2\xE8\xB7\xAF\xE7\x99\xBE\xE7"
+			"\xA7\x91\xE5\x85\xA8\xE6\x9B\xB8\xE5\x8D\x94\xE4\xBD\x9C\xE8\xA8\x88\xE7\x95\xAB";
+		uint8_t qrcode[qrcodegen_BUFFER_LEN_MAX];
+		uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
+		bool ok;
+		
+		ok = qrcodegen_encodeText(text, tempBuffer, qrcode,
+			qrcodegen_Ecc_MEDIUM, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_0, true);
+		if (ok)
+			printQr(qrcode);
+		
+		ok = qrcodegen_encodeText(text, tempBuffer, qrcode,
+			qrcodegen_Ecc_MEDIUM, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_1, true);
+		if (ok)
+			printQr(qrcode);
+		
+		ok = qrcodegen_encodeText(text, tempBuffer, qrcode,
+			qrcodegen_Ecc_MEDIUM, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_5, true);
+		if (ok)
+			printQr(qrcode);
+		
+		ok = qrcodegen_encodeText(text, tempBuffer, qrcode,
+			qrcodegen_Ecc_MEDIUM, qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_7, true);
+		if (ok)
+			printQr(qrcode);
+	}
+}
+
+
+
+/*---- Utilities ----*/
+
+// Prints the given QR Code to the console.
+static void printQr(const uint8_t qrcode[]) {
+	int size = qrcodegen_getSize(qrcode);
+	int border = 4;
+	for (int y = -border; y < size + border; y++) {
+		for (int x = -border; x < size + border; x++) {
+			fputs((qrcodegen_getModule(qrcode, x, y) ? "##" : "  "), stdout);
+		}
+		fputs("\n", stdout);
+	}
+	fputs("\n", stdout);
+}

Telegram/ThirdParty/QR/c/qrcodegen.h

@@ -0,0 +1,385 @@
+/* 
+ * QR Code generator library (C)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* 
+ * This library creates QR Code symbols, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * A QR Code structure is an immutable square grid of dark and light cells.
+ * The library provides functions to create a QR Code from text or binary data.
+ * The library covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+ * 
+ * Ways to create a QR Code object:
+ * - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
+ * - Low level: Custom-make the list of segments and call
+ *   qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
+ * (Note that all ways require supplying the desired error correction level and various byte buffers.)
+ */
+
+
+/*---- Enum and struct types----*/
+
+/* 
+ * The error correction level in a QR Code symbol.
+ */
+enum qrcodegen_Ecc {
+	// Must be declared in ascending order of error protection
+	// so that an internal qrcodegen function works properly
+	qrcodegen_Ecc_LOW = 0 ,  // The QR Code can tolerate about  7% erroneous codewords
+	qrcodegen_Ecc_MEDIUM  ,  // The QR Code can tolerate about 15% erroneous codewords
+	qrcodegen_Ecc_QUARTILE,  // The QR Code can tolerate about 25% erroneous codewords
+	qrcodegen_Ecc_HIGH    ,  // The QR Code can tolerate about 30% erroneous codewords
+};
+
+
+/* 
+ * The mask pattern used in a QR Code symbol.
+ */
+enum qrcodegen_Mask {
+	// A special value to tell the QR Code encoder to
+	// automatically select an appropriate mask pattern
+	qrcodegen_Mask_AUTO = -1,
+	// The eight actual mask patterns
+	qrcodegen_Mask_0 = 0,
+	qrcodegen_Mask_1,
+	qrcodegen_Mask_2,
+	qrcodegen_Mask_3,
+	qrcodegen_Mask_4,
+	qrcodegen_Mask_5,
+	qrcodegen_Mask_6,
+	qrcodegen_Mask_7,
+};
+
+
+/* 
+ * Describes how a segment's data bits are interpreted.
+ */
+enum qrcodegen_Mode {
+	qrcodegen_Mode_NUMERIC      = 0x1,
+	qrcodegen_Mode_ALPHANUMERIC = 0x2,
+	qrcodegen_Mode_BYTE         = 0x4,
+	qrcodegen_Mode_KANJI        = 0x8,
+	qrcodegen_Mode_ECI          = 0x7,
+};
+
+
+/* 
+ * A segment of character/binary/control data in a QR Code symbol.
+ * The mid-level way to create a segment is to take the payload data
+ * and call a factory function such as qrcodegen_makeNumeric().
+ * The low-level way to create a segment is to custom-make the bit buffer
+ * and initialize a qrcodegen_Segment struct with appropriate values.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * Moreover, the maximum allowed bit length is 32767 because
+ * the largest QR Code (version 40) has 31329 modules.
+ */
+struct qrcodegen_Segment {
+	// The mode indicator of this segment.
+	enum qrcodegen_Mode mode;
+	
+	// The length of this segment's unencoded data. Measured in characters for
+	// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	// Always zero or positive. Not the same as the data's bit length.
+	int numChars;
+	
+	// The data bits of this segment, packed in bitwise big endian.
+	// Can be null if the bit length is zero.
+	uint8_t *data;
+	
+	// The number of valid data bits used in the buffer. Requires
+	// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
+	// The character count (numChars) must agree with the mode and the bit buffer length.
+	int bitLength;
+};
+
+
+
+/*---- Macro constants and functions ----*/
+
+#define qrcodegen_VERSION_MIN   1  // The minimum version number supported in the QR Code Model 2 standard
+#define qrcodegen_VERSION_MAX  40  // The maximum version number supported in the QR Code Model 2 standard
+
+// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
+// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
+// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
+// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
+#define qrcodegen_BUFFER_LEN_FOR_VERSION(n)  ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
+
+// The worst-case number of bytes needed to store one QR Code, up to and including
+// version 40. This value equals 3918, which is just under 4 kilobytes.
+// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
+#define qrcodegen_BUFFER_LEN_MAX  qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
+
+
+
+/*---- Functions (high level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given text string to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * The input text must be encoded in UTF-8 and contain no NULs.
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * If successful, the resulting QR Code may use numeric,
+ * alphanumeric, or byte mode to encode the text.
+ * 
+ * In the most optimistic case, a QR Code at version 40 with low ECC
+ * can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
+ * up to 4296 characters, or any digit string up to 7089 characters.
+ * These numbers represent the hard upper limit of the QR Code standard.
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/* 
+ * Encodes the given binary data to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
+ * - Before calling the function:
+ *   - The array ranges dataAndTemp[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The input array range dataAndTemp[0 : dataLen] should normally be
+ *     valid UTF-8 text, but is not required by the QR Code standard.
+ *   - The initial state of dataAndTemp[dataLen : len] and qrcode[0 : len]
+ *     can be uninitialized because the function always writes before reading.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - dataAndTemp contains no useful data and should be treated as entirely uninitialized.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * If successful, the resulting QR Code will use byte mode to encode the data.
+ * 
+ * In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
+ * sequence up to length 2953. This is the hard upper limit of the QR Code standard.
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/*---- Functions (low level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given segments to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version at the given ECC level,
+ * then false is returned.
+ * 
+ * The smallest possible QR Code version is automatically chosen for
+ * the output. The ECC level of the result may be higher than the
+ * ecl argument if it can be done without increasing the version.
+ * 
+ * About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ *   - The input array segs can contain segments whose data buffers overlap with tempBuffer.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - Any segment whose data buffer overlaps with tempBuffer[0 : len]
+ *     must be treated as having invalid values in that array.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ * 
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ */
+bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
+	enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Encodes the given segments to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ *   - The input array segs can contain segments whose data buffers overlap with tempBuffer.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - Any segment whose data buffer overlaps with tempBuffer[0 : len]
+ *     must be treated as having invalid values in that array.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ * 
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ */
+bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
+	int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in numeric mode.
+ * A string is encodable iff each character is in the range 0 to 9.
+ */
+bool qrcodegen_isNumeric(const char *text);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in alphanumeric mode.
+ * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+ * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+bool qrcodegen_isAlphanumeric(const char *text);
+
+
+/* 
+ * Returns the number of bytes (uint8_t) needed for the data buffer of a segment
+ * containing the given number of characters using the given mode. Notes:
+ * - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or the internal
+ *   calculation of the number of needed bits exceeds INT16_MAX (i.e. 32767).
+ * - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
+ * - It is okay for the user to allocate more bytes for the buffer than needed.
+ * - For byte mode, numChars measures the number of bytes, not Unicode code points.
+ * - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
+ *   An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
+ */
+size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
+
+
+/* 
+ * Returns a segment representing the given binary data encoded in
+ * byte mode. All input byte arrays are acceptable. Any text string
+ * can be converted to UTF-8 bytes and encoded as a byte mode segment.
+ */
+struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given string of decimal digits encoded in numeric mode.
+ */
+struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given text string encoded in alphanumeric mode.
+ * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+ * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing an Extended Channel Interpretation
+ * (ECI) designator with the given assignment value.
+ */
+struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
+
+
+/*---- Functions to extract raw data from QR Codes ----*/
+
+/* 
+ * Returns the side length of the given QR Code, assuming that encoding succeeded.
+ * The result is in the range [21, 177]. Note that the length of the array buffer
+ * is related to the side length - every 'uint8_t qrcode[]' must have length at least
+ * qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
+ */
+int qrcodegen_getSize(const uint8_t qrcode[]);
+
+
+/* 
+ * Returns the color of the module (pixel) at the given coordinates, which is false
+ * for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+ * If the given coordinates are out of bounds, then false (light) is returned.
+ */
+bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
+
+
+#ifdef __cplusplus
+}
+#endif

Telegram/ThirdParty/QR/cpp/Makefile

@@ -0,0 +1,84 @@
+# 
+# Makefile for QR Code generator (C++)
+# 
+# Copyright (c) Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/qr-code-generator-library
+# 
+# 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.
+# 
+
+
+# ---- Configuration options ----
+
+# External/implicit variables:
+# - CXX: The C++ compiler, such as g++ or clang++.
+# - CXXFLAGS: Any extra user-specified compiler flags (can be blank).
+
+# Recommended compiler flags:
+CXXFLAGS += -std=c++11 -O
+
+# Extra flags for diagnostics:
+# CXXFLAGS += -g -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -fsanitize=undefined,address
+
+
+# ---- Controlling make ----
+
+# Clear default suffix rules
+.SUFFIXES:
+
+# Don't delete object files
+.SECONDARY:
+
+# Stuff concerning goals
+.DEFAULT_GOAL = all
+.PHONY: all clean
+
+
+# ---- Targets to build ----
+
+LIB = qrcodegencpp
+LIBFILE = lib$(LIB).a
+LIBOBJ = qrcodegen.o
+MAINS = QrCodeGeneratorDemo
+
+# Build all binaries
+all: $(LIBFILE) $(MAINS)
+
+# Delete build output
+clean:
+	rm -f -- $(LIBOBJ) $(LIBFILE) $(MAINS:=.o) $(MAINS)
+	rm -rf .deps
+
+# Executable files
+%: %.o $(LIBFILE)
+	$(CXX) $(CXXFLAGS) $(LDFLAGS) -o $@ $< -L . -l $(LIB)
+
+# The library
+$(LIBFILE): $(LIBOBJ)
+	$(AR) -crs $@ -- $^
+
+# Object files
+%.o: %.cpp .deps/timestamp
+	$(CXX) $(CXXFLAGS) -c -o $@ -MMD -MF .deps/$*.d $<
+
+# Have a place to store header dependencies automatically generated by compiler
+.deps/timestamp:
+	mkdir -p .deps
+	touch .deps/timestamp
+
+# Make use of said dependencies if available
+-include .deps/*.d

Telegram/ThirdParty/QR/cpp/QrCodeGeneratorDemo.cpp

@@ -0,0 +1,232 @@
+/* 
+ * QR Code generator demo (C++)
+ * 
+ * Run this command-line program with no arguments. The program computes a bunch of demonstration
+ * QR Codes and prints them to the console. Also, the SVG code for one QR Code is printed as a sample.
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+#include <climits>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "qrcodegen.hpp"
+
+using std::uint8_t;
+using qrcodegen::QrCode;
+using qrcodegen::QrSegment;
+
+
+// Function prototypes
+static void doBasicDemo();
+static void doVarietyDemo();
+static void doSegmentDemo();
+static void doMaskDemo();
+static std::string toSvgString(const QrCode &qr, int border);
+static void printQr(const QrCode &qr);
+
+
+// The main application program.
+int main() {
+	doBasicDemo();
+	doVarietyDemo();
+	doSegmentDemo();
+	doMaskDemo();
+	return EXIT_SUCCESS;
+}
+
+
+
+/*---- Demo suite ----*/
+
+// Creates a single QR Code, then prints it to the console.
+static void doBasicDemo() {
+	const char *text = "Hello, world!";              // User-supplied text
+	const QrCode::Ecc errCorLvl = QrCode::Ecc::LOW;  // Error correction level
+	
+	// Make and print the QR Code symbol
+	const QrCode qr = QrCode::encodeText(text, errCorLvl);
+	printQr(qr);
+	std::cout << toSvgString(qr, 4) << std::endl;
+}
+
+
+// Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console.
+static void doVarietyDemo() {
+	// Numeric mode encoding (3.33 bits per digit)
+	const QrCode qr0 = QrCode::encodeText("314159265358979323846264338327950288419716939937510", QrCode::Ecc::MEDIUM);
+	printQr(qr0);
+	
+	// Alphanumeric mode encoding (5.5 bits per character)
+	const QrCode qr1 = QrCode::encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCode::Ecc::HIGH);
+	printQr(qr1);
+	
+	// Unicode text as UTF-8
+	const QrCode qr2 = QrCode::encodeText("\xE3\x81\x93\xE3\x82\x93\xE3\x81\xAB\xE3\x81\xA1wa\xE3\x80\x81"
+		"\xE4\xB8\x96\xE7\x95\x8C\xEF\xBC\x81\x20\xCE\xB1\xCE\xB2\xCE\xB3\xCE\xB4", QrCode::Ecc::QUARTILE);
+	printQr(qr2);
+	
+	// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+	const QrCode qr3 = QrCode::encodeText(
+		"Alice was beginning to get very tired of sitting by her sister on the bank, "
+		"and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
+		"but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
+		"'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
+		"for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
+		"daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
+		"a White Rabbit with pink eyes ran close by her.", QrCode::Ecc::HIGH);
+	printQr(qr3);
+}
+
+
+// Creates QR Codes with manually specified segments for better compactness.
+static void doSegmentDemo() {
+	// Illustration "silver"
+	const char *silver0 = "THE SQUARE ROOT OF 2 IS 1.";
+	const char *silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
+	const QrCode qr0 = QrCode::encodeText(
+		(std::string(silver0) + silver1).c_str(),
+		QrCode::Ecc::LOW);
+	printQr(qr0);
+	
+	const QrCode qr1 = QrCode::encodeSegments(
+		{QrSegment::makeAlphanumeric(silver0), QrSegment::makeNumeric(silver1)},
+		QrCode::Ecc::LOW);
+	printQr(qr1);
+	
+	// Illustration "golden"
+	const char *golden0 = "Golden ratio \xCF\x86 = 1.";
+	const char *golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+	const char *golden2 = "......";
+	const QrCode qr2 = QrCode::encodeText(
+		(std::string(golden0) + golden1 + golden2).c_str(),
+		QrCode::Ecc::LOW);
+	printQr(qr2);
+	
+	std::vector<uint8_t> bytes(golden0, golden0 + std::strlen(golden0));
+	const QrCode qr3 = QrCode::encodeSegments(
+		{QrSegment::makeBytes(bytes), QrSegment::makeNumeric(golden1), QrSegment::makeAlphanumeric(golden2)},
+		QrCode::Ecc::LOW);
+	printQr(qr3);
+	
+	// Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+	const char *madoka =  // Encoded in UTF-8
+		"\xE3\x80\x8C\xE9\xAD\x94\xE6\xB3\x95\xE5"
+		"\xB0\x91\xE5\xA5\xB3\xE3\x81\xBE\xE3\x81"
+		"\xA9\xE3\x81\x8B\xE2\x98\x86\xE3\x83\x9E"
+		"\xE3\x82\xAE\xE3\x82\xAB\xE3\x80\x8D\xE3"
+		"\x81\xA3\xE3\x81\xA6\xE3\x80\x81\xE3\x80"
+		"\x80\xD0\x98\xD0\x90\xD0\x98\xE3\x80\x80"
+		"\xEF\xBD\x84\xEF\xBD\x85\xEF\xBD\x93\xEF"
+		"\xBD\x95\xE3\x80\x80\xCE\xBA\xCE\xB1\xEF"
+		"\xBC\x9F";
+	const QrCode qr4 = QrCode::encodeText(madoka, QrCode::Ecc::LOW);
+	printQr(qr4);
+	
+	const std::vector<int> kanjiChars{  // Kanji mode encoding (13 bits per character)
+		0x0035, 0x1002, 0x0FC0, 0x0AED, 0x0AD7,
+		0x015C, 0x0147, 0x0129, 0x0059, 0x01BD,
+		0x018D, 0x018A, 0x0036, 0x0141, 0x0144,
+		0x0001, 0x0000, 0x0249, 0x0240, 0x0249,
+		0x0000, 0x0104, 0x0105, 0x0113, 0x0115,
+		0x0000, 0x0208, 0x01FF, 0x0008,
+	};
+	qrcodegen::BitBuffer bb;
+	for (int c : kanjiChars)
+		bb.appendBits(static_cast<std::uint32_t>(c), 13);
+	const QrCode qr5 = QrCode::encodeSegments(
+		{QrSegment(QrSegment::Mode::KANJI, static_cast<int>(kanjiChars.size()), bb)},
+		QrCode::Ecc::LOW);
+	printQr(qr5);
+}
+
+
+// Creates QR Codes with the same size and contents but different mask patterns.
+static void doMaskDemo() {
+	// Project Nayuki URL
+	std::vector<QrSegment> segs0 = QrSegment::makeSegments("https://www.nayuki.io/");
+	printQr(QrCode::encodeSegments(segs0, QrCode::Ecc::HIGH, QrCode::MIN_VERSION, QrCode::MAX_VERSION, -1, true));  // Automatic mask
+	printQr(QrCode::encodeSegments(segs0, QrCode::Ecc::HIGH, QrCode::MIN_VERSION, QrCode::MAX_VERSION, 3, true));  // Force mask 3
+	
+	// Chinese text as UTF-8
+	std::vector<QrSegment> segs1 = QrSegment::makeSegments(
+		"\xE7\xB6\xAD\xE5\x9F\xBA\xE7\x99\xBE\xE7\xA7\x91\xEF\xBC\x88\x57\x69\x6B\x69\x70"
+		"\x65\x64\x69\x61\xEF\xBC\x8C\xE8\x81\x86\xE8\x81\xBD\x69\x2F\xCB\x8C\x77\xC9\xAA"
+		"\x6B\xE1\xB5\xBB\xCB\x88\x70\x69\xCB\x90\x64\x69\x2E\xC9\x99\x2F\xEF\xBC\x89\xE6"
+		"\x98\xAF\xE4\xB8\x80\xE5\x80\x8B\xE8\x87\xAA\xE7\x94\xB1\xE5\x85\xA7\xE5\xAE\xB9"
+		"\xE3\x80\x81\xE5\x85\xAC\xE9\x96\x8B\xE7\xB7\xA8\xE8\xBC\xAF\xE4\xB8\x94\xE5\xA4"
+		"\x9A\xE8\xAA\x9E\xE8\xA8\x80\xE7\x9A\x84\xE7\xB6\xB2\xE8\xB7\xAF\xE7\x99\xBE\xE7"
+		"\xA7\x91\xE5\x85\xA8\xE6\x9B\xB8\xE5\x8D\x94\xE4\xBD\x9C\xE8\xA8\x88\xE7\x95\xAB");
+	printQr(QrCode::encodeSegments(segs1, QrCode::Ecc::MEDIUM, QrCode::MIN_VERSION, QrCode::MAX_VERSION, 0, true));  // Force mask 0
+	printQr(QrCode::encodeSegments(segs1, QrCode::Ecc::MEDIUM, QrCode::MIN_VERSION, QrCode::MAX_VERSION, 1, true));  // Force mask 1
+	printQr(QrCode::encodeSegments(segs1, QrCode::Ecc::MEDIUM, QrCode::MIN_VERSION, QrCode::MAX_VERSION, 5, true));  // Force mask 5
+	printQr(QrCode::encodeSegments(segs1, QrCode::Ecc::MEDIUM, QrCode::MIN_VERSION, QrCode::MAX_VERSION, 7, true));  // Force mask 7
+}
+
+
+
+/*---- Utilities ----*/
+
+// Returns a string of SVG code for an image depicting the given QR Code, with the given number
+// of border modules. The string always uses Unix newlines (\n), regardless of the platform.
+static std::string toSvgString(const QrCode &qr, int border) {
+	if (border < 0)
+		throw std::domain_error("Border must be non-negative");
+	if (border > INT_MAX / 2 || border * 2 > INT_MAX - qr.getSize())
+		throw std::overflow_error("Border too large");
+	
+	std::ostringstream sb;
+	sb << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+	sb << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
+	sb << "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 ";
+	sb << (qr.getSize() + border * 2) << " " << (qr.getSize() + border * 2) << "\" stroke=\"none\">\n";
+	sb << "\t<rect width=\"100%\" height=\"100%\" fill=\"#FFFFFF\"/>\n";
+	sb << "\t<path d=\"";
+	for (int y = 0; y < qr.getSize(); y++) {
+		for (int x = 0; x < qr.getSize(); x++) {
+			if (qr.getModule(x, y)) {
+				if (x != 0 || y != 0)
+					sb << " ";
+				sb << "M" << (x + border) << "," << (y + border) << "h1v1h-1z";
+			}
+		}
+	}
+	sb << "\" fill=\"#000000\"/>\n";
+	sb << "</svg>\n";
+	return sb.str();
+}
+
+
+// Prints the given QrCode object to the console.
+static void printQr(const QrCode &qr) {
+	int border = 4;
+	for (int y = -border; y < qr.getSize() + border; y++) {
+		for (int x = -border; x < qr.getSize() + border; x++) {
+			std::cout << (qr.getModule(x, y) ? "##" : "  ");
+		}
+		std::cout << std::endl;
+	}
+	std::cout << std::endl;
+}

Telegram/ThirdParty/QR/cpp/Readme.markdown

@@ -0,0 +1,61 @@
+QR Code generator library - C++
+===============================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Coded carefully to prevent memory corruption, integer overflow, platform-dependent inconsistencies, and undefined behavior; tested rigorously to confirm safety
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```c++
+#include <string>
+#include <vector>
+#include "QrCode.hpp"
+using namespace qrcodegen;
+
+// Simple operation
+QrCode qr0 = QrCode::encodeText("Hello, world!", QrCode::Ecc::MEDIUM);
+std::string svg = toSvgString(qr0, 4);  // See QrCodeGeneratorDemo
+
+// Manual operation
+std::vector<QrSegment> segs =
+    QrSegment::makeSegments("3141592653589793238462643383");
+QrCode qr1 = QrCode::encodeSegments(
+    segs, QrCode::Ecc::HIGH, 5, 5, 2, false);
+for (int y = 0; y < qr1.getSize(); y++) {
+    for (int x = 0; x < qr1.getSize(); x++) {
+        (... paint qr1.getModule(x, y) ...)
+    }
+}
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/cpp/QrCodeGeneratorDemo.cpp .

Telegram/ThirdParty/QR/cpp/qrcodegen.cpp

@@ -0,0 +1,830 @@
+/* 
+ * QR Code generator library (C++)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+#include <algorithm>
+#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+#include <utility>
+#include "qrcodegen.hpp"
+
+using std::int8_t;
+using std::uint8_t;
+using std::size_t;
+using std::vector;
+
+
+namespace qrcodegen {
+
+/*---- Class QrSegment ----*/
+
+QrSegment::Mode::Mode(int mode, int cc0, int cc1, int cc2) :
+		modeBits(mode) {
+	numBitsCharCount[0] = cc0;
+	numBitsCharCount[1] = cc1;
+	numBitsCharCount[2] = cc2;
+}
+
+
+int QrSegment::Mode::getModeBits() const {
+	return modeBits;
+}
+
+
+int QrSegment::Mode::numCharCountBits(int ver) const {
+	return numBitsCharCount[(ver + 7) / 17];
+}
+
+
+const QrSegment::Mode QrSegment::Mode::NUMERIC     (0x1, 10, 12, 14);
+const QrSegment::Mode QrSegment::Mode::ALPHANUMERIC(0x2,  9, 11, 13);
+const QrSegment::Mode QrSegment::Mode::BYTE        (0x4,  8, 16, 16);
+const QrSegment::Mode QrSegment::Mode::KANJI       (0x8,  8, 10, 12);
+const QrSegment::Mode QrSegment::Mode::ECI         (0x7,  0,  0,  0);
+
+
+QrSegment QrSegment::makeBytes(const vector<uint8_t> &data) {
+	if (data.size() > static_cast<unsigned int>(INT_MAX))
+		throw std::length_error("Data too long");
+	BitBuffer bb;
+	for (uint8_t b : data)
+		bb.appendBits(b, 8);
+	return QrSegment(Mode::BYTE, static_cast<int>(data.size()), std::move(bb));
+}
+
+
+QrSegment QrSegment::makeNumeric(const char *digits) {
+	BitBuffer bb;
+	int accumData = 0;
+	int accumCount = 0;
+	int charCount = 0;
+	for (; *digits != '\0'; digits++, charCount++) {
+		char c = *digits;
+		if (c < '0' || c > '9')
+			throw std::domain_error("String contains non-numeric characters");
+		accumData = accumData * 10 + (c - '0');
+		accumCount++;
+		if (accumCount == 3) {
+			bb.appendBits(static_cast<uint32_t>(accumData), 10);
+			accumData = 0;
+			accumCount = 0;
+		}
+	}
+	if (accumCount > 0)  // 1 or 2 digits remaining
+		bb.appendBits(static_cast<uint32_t>(accumData), accumCount * 3 + 1);
+	return QrSegment(Mode::NUMERIC, charCount, std::move(bb));
+}
+
+
+QrSegment QrSegment::makeAlphanumeric(const char *text) {
+	BitBuffer bb;
+	int accumData = 0;
+	int accumCount = 0;
+	int charCount = 0;
+	for (; *text != '\0'; text++, charCount++) {
+		const char *temp = std::strchr(ALPHANUMERIC_CHARSET, *text);
+		if (temp == nullptr)
+			throw std::domain_error("String contains unencodable characters in alphanumeric mode");
+		accumData = accumData * 45 + static_cast<int>(temp - ALPHANUMERIC_CHARSET);
+		accumCount++;
+		if (accumCount == 2) {
+			bb.appendBits(static_cast<uint32_t>(accumData), 11);
+			accumData = 0;
+			accumCount = 0;
+		}
+	}
+	if (accumCount > 0)  // 1 character remaining
+		bb.appendBits(static_cast<uint32_t>(accumData), 6);
+	return QrSegment(Mode::ALPHANUMERIC, charCount, std::move(bb));
+}
+
+
+vector<QrSegment> QrSegment::makeSegments(const char *text) {
+	// Select the most efficient segment encoding automatically
+	vector<QrSegment> result;
+	if (*text == '\0');  // Leave result empty
+	else if (isNumeric(text))
+		result.push_back(makeNumeric(text));
+	else if (isAlphanumeric(text))
+		result.push_back(makeAlphanumeric(text));
+	else {
+		vector<uint8_t> bytes;
+		for (; *text != '\0'; text++)
+			bytes.push_back(static_cast<uint8_t>(*text));
+		result.push_back(makeBytes(bytes));
+	}
+	return result;
+}
+
+
+QrSegment QrSegment::makeEci(long assignVal) {
+	BitBuffer bb;
+	if (assignVal < 0)
+		throw std::domain_error("ECI assignment value out of range");
+	else if (assignVal < (1 << 7))
+		bb.appendBits(static_cast<uint32_t>(assignVal), 8);
+	else if (assignVal < (1 << 14)) {
+		bb.appendBits(2, 2);
+		bb.appendBits(static_cast<uint32_t>(assignVal), 14);
+	} else if (assignVal < 1000000L) {
+		bb.appendBits(6, 3);
+		bb.appendBits(static_cast<uint32_t>(assignVal), 21);
+	} else
+		throw std::domain_error("ECI assignment value out of range");
+	return QrSegment(Mode::ECI, 0, std::move(bb));
+}
+
+
+QrSegment::QrSegment(const Mode &md, int numCh, const std::vector<bool> &dt) :
+		mode(&md),
+		numChars(numCh),
+		data(dt) {
+	if (numCh < 0)
+		throw std::domain_error("Invalid value");
+}
+
+
+QrSegment::QrSegment(const Mode &md, int numCh, std::vector<bool> &&dt) :
+		mode(&md),
+		numChars(numCh),
+		data(std::move(dt)) {
+	if (numCh < 0)
+		throw std::domain_error("Invalid value");
+}
+
+
+int QrSegment::getTotalBits(const vector<QrSegment> &segs, int version) {
+	int result = 0;
+	for (const QrSegment &seg : segs) {
+		int ccbits = seg.mode->numCharCountBits(version);
+		if (seg.numChars >= (1L << ccbits))
+			return -1;  // The segment's length doesn't fit the field's bit width
+		if (4 + ccbits > INT_MAX - result)
+			return -1;  // The sum will overflow an int type
+		result += 4 + ccbits;
+		if (seg.data.size() > static_cast<unsigned int>(INT_MAX - result))
+			return -1;  // The sum will overflow an int type
+		result += static_cast<int>(seg.data.size());
+	}
+	return result;
+}
+
+
+bool QrSegment::isNumeric(const char *text) {
+	for (; *text != '\0'; text++) {
+		char c = *text;
+		if (c < '0' || c > '9')
+			return false;
+	}
+	return true;
+}
+
+
+bool QrSegment::isAlphanumeric(const char *text) {
+	for (; *text != '\0'; text++) {
+		if (std::strchr(ALPHANUMERIC_CHARSET, *text) == nullptr)
+			return false;
+	}
+	return true;
+}
+
+
+const QrSegment::Mode &QrSegment::getMode() const {
+	return *mode;
+}
+
+
+int QrSegment::getNumChars() const {
+	return numChars;
+}
+
+
+const std::vector<bool> &QrSegment::getData() const {
+	return data;
+}
+
+
+const char *QrSegment::ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+
+
+
+/*---- Class QrCode ----*/
+
+int QrCode::getFormatBits(Ecc ecl) {
+	switch (ecl) {
+		case Ecc::LOW     :  return 1;
+		case Ecc::MEDIUM  :  return 0;
+		case Ecc::QUARTILE:  return 3;
+		case Ecc::HIGH    :  return 2;
+		default:  throw std::logic_error("Unreachable");
+	}
+}
+
+
+QrCode QrCode::encodeText(const char *text, Ecc ecl) {
+	vector<QrSegment> segs = QrSegment::makeSegments(text);
+	return encodeSegments(segs, ecl);
+}
+
+
+QrCode QrCode::encodeBinary(const vector<uint8_t> &data, Ecc ecl) {
+	vector<QrSegment> segs{QrSegment::makeBytes(data)};
+	return encodeSegments(segs, ecl);
+}
+
+
+QrCode QrCode::encodeSegments(const vector<QrSegment> &segs, Ecc ecl,
+		int minVersion, int maxVersion, int mask, bool boostEcl) {
+	if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7)
+		throw std::invalid_argument("Invalid value");
+	
+	// Find the minimal version number to use
+	int version, dataUsedBits;
+	for (version = minVersion; ; version++) {
+		int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;  // Number of data bits available
+		dataUsedBits = QrSegment::getTotalBits(segs, version);
+		if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
+			break;  // This version number is found to be suitable
+		if (version >= maxVersion) {  // All versions in the range could not fit the given data
+			std::ostringstream sb;
+			if (dataUsedBits == -1)
+				sb << "Segment too long";
+			else {
+				sb << "Data length = " << dataUsedBits << " bits, ";
+				sb << "Max capacity = " << dataCapacityBits << " bits";
+			}
+			throw data_too_long(sb.str());
+		}
+	}
+	assert(dataUsedBits != -1);
+	
+	// Increase the error correction level while the data still fits in the current version number
+	for (Ecc newEcl : {Ecc::MEDIUM, Ecc::QUARTILE, Ecc::HIGH}) {  // From low to high
+		if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8)
+			ecl = newEcl;
+	}
+	
+	// Concatenate all segments to create the data bit string
+	BitBuffer bb;
+	for (const QrSegment &seg : segs) {
+		bb.appendBits(static_cast<uint32_t>(seg.getMode().getModeBits()), 4);
+		bb.appendBits(static_cast<uint32_t>(seg.getNumChars()), seg.getMode().numCharCountBits(version));
+		bb.insert(bb.end(), seg.getData().begin(), seg.getData().end());
+	}
+	assert(bb.size() == static_cast<unsigned int>(dataUsedBits));
+	
+	// Add terminator and pad up to a byte if applicable
+	size_t dataCapacityBits = static_cast<size_t>(getNumDataCodewords(version, ecl)) * 8;
+	assert(bb.size() <= dataCapacityBits);
+	bb.appendBits(0, std::min(4, static_cast<int>(dataCapacityBits - bb.size())));
+	bb.appendBits(0, (8 - static_cast<int>(bb.size() % 8)) % 8);
+	assert(bb.size() % 8 == 0);
+	
+	// Pad with alternating bytes until data capacity is reached
+	for (uint8_t padByte = 0xEC; bb.size() < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
+		bb.appendBits(padByte, 8);
+	
+	// Pack bits into bytes in big endian
+	vector<uint8_t> dataCodewords(bb.size() / 8);
+	for (size_t i = 0; i < bb.size(); i++)
+		dataCodewords.at(i >> 3) |= (bb.at(i) ? 1 : 0) << (7 - (i & 7));
+	
+	// Create the QR Code object
+	return QrCode(version, ecl, dataCodewords, mask);
+}
+
+
+QrCode::QrCode(int ver, Ecc ecl, const vector<uint8_t> &dataCodewords, int msk) :
+		// Initialize fields and check arguments
+		version(ver),
+		errorCorrectionLevel(ecl) {
+	if (ver < MIN_VERSION || ver > MAX_VERSION)
+		throw std::domain_error("Version value out of range");
+	if (msk < -1 || msk > 7)
+		throw std::domain_error("Mask value out of range");
+	size = ver * 4 + 17;
+	size_t sz = static_cast<size_t>(size);
+	modules    = vector<vector<bool> >(sz, vector<bool>(sz));  // Initially all light
+	isFunction = vector<vector<bool> >(sz, vector<bool>(sz));
+	
+	// Compute ECC, draw modules
+	drawFunctionPatterns();
+	const vector<uint8_t> allCodewords = addEccAndInterleave(dataCodewords);
+	drawCodewords(allCodewords);
+	
+	// Do masking
+	if (msk == -1) {  // Automatically choose best mask
+		long minPenalty = LONG_MAX;
+		for (int i = 0; i < 8; i++) {
+			applyMask(i);
+			drawFormatBits(i);
+			long penalty = getPenaltyScore();
+			if (penalty < minPenalty) {
+				msk = i;
+				minPenalty = penalty;
+			}
+			applyMask(i);  // Undoes the mask due to XOR
+		}
+	}
+	assert(0 <= msk && msk <= 7);
+	mask = msk;
+	applyMask(msk);  // Apply the final choice of mask
+	drawFormatBits(msk);  // Overwrite old format bits
+	
+	isFunction.clear();
+	isFunction.shrink_to_fit();
+}
+
+
+int QrCode::getVersion() const {
+	return version;
+}
+
+
+int QrCode::getSize() const {
+	return size;
+}
+
+
+QrCode::Ecc QrCode::getErrorCorrectionLevel() const {
+	return errorCorrectionLevel;
+}
+
+
+int QrCode::getMask() const {
+	return mask;
+}
+
+
+bool QrCode::getModule(int x, int y) const {
+	return 0 <= x && x < size && 0 <= y && y < size && module(x, y);
+}
+
+
+void QrCode::drawFunctionPatterns() {
+	// Draw horizontal and vertical timing patterns
+	for (int i = 0; i < size; i++) {
+		setFunctionModule(6, i, i % 2 == 0);
+		setFunctionModule(i, 6, i % 2 == 0);
+	}
+	
+	// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
+	drawFinderPattern(3, 3);
+	drawFinderPattern(size - 4, 3);
+	drawFinderPattern(3, size - 4);
+	
+	// Draw numerous alignment patterns
+	const vector<int> alignPatPos = getAlignmentPatternPositions();
+	size_t numAlign = alignPatPos.size();
+	for (size_t i = 0; i < numAlign; i++) {
+		for (size_t j = 0; j < numAlign; j++) {
+			// Don't draw on the three finder corners
+			if (!((i == 0 && j == 0) || (i == 0 && j == numAlign - 1) || (i == numAlign - 1 && j == 0)))
+				drawAlignmentPattern(alignPatPos.at(i), alignPatPos.at(j));
+		}
+	}
+	
+	// Draw configuration data
+	drawFormatBits(0);  // Dummy mask value; overwritten later in the constructor
+	drawVersion();
+}
+
+
+void QrCode::drawFormatBits(int msk) {
+	// Calculate error correction code and pack bits
+	int data = getFormatBits(errorCorrectionLevel) << 3 | msk;  // errCorrLvl is uint2, msk is uint3
+	int rem = data;
+	for (int i = 0; i < 10; i++)
+		rem = (rem << 1) ^ ((rem >> 9) * 0x537);
+	int bits = (data << 10 | rem) ^ 0x5412;  // uint15
+	assert(bits >> 15 == 0);
+	
+	// Draw first copy
+	for (int i = 0; i <= 5; i++)
+		setFunctionModule(8, i, getBit(bits, i));
+	setFunctionModule(8, 7, getBit(bits, 6));
+	setFunctionModule(8, 8, getBit(bits, 7));
+	setFunctionModule(7, 8, getBit(bits, 8));
+	for (int i = 9; i < 15; i++)
+		setFunctionModule(14 - i, 8, getBit(bits, i));
+	
+	// Draw second copy
+	for (int i = 0; i < 8; i++)
+		setFunctionModule(size - 1 - i, 8, getBit(bits, i));
+	for (int i = 8; i < 15; i++)
+		setFunctionModule(8, size - 15 + i, getBit(bits, i));
+	setFunctionModule(8, size - 8, true);  // Always dark
+}
+
+
+void QrCode::drawVersion() {
+	if (version < 7)
+		return;
+	
+	// Calculate error correction code and pack bits
+	int rem = version;  // version is uint6, in the range [7, 40]
+	for (int i = 0; i < 12; i++)
+		rem = (rem << 1) ^ ((rem >> 11) * 0x1F25);
+	long bits = static_cast<long>(version) << 12 | rem;  // uint18
+	assert(bits >> 18 == 0);
+	
+	// Draw two copies
+	for (int i = 0; i < 18; i++) {
+		bool bit = getBit(bits, i);
+		int a = size - 11 + i % 3;
+		int b = i / 3;
+		setFunctionModule(a, b, bit);
+		setFunctionModule(b, a, bit);
+	}
+}
+
+
+void QrCode::drawFinderPattern(int x, int y) {
+	for (int dy = -4; dy <= 4; dy++) {
+		for (int dx = -4; dx <= 4; dx++) {
+			int dist = std::max(std::abs(dx), std::abs(dy));  // Chebyshev/infinity norm
+			int xx = x + dx, yy = y + dy;
+			if (0 <= xx && xx < size && 0 <= yy && yy < size)
+				setFunctionModule(xx, yy, dist != 2 && dist != 4);
+		}
+	}
+}
+
+
+void QrCode::drawAlignmentPattern(int x, int y) {
+	for (int dy = -2; dy <= 2; dy++) {
+		for (int dx = -2; dx <= 2; dx++)
+			setFunctionModule(x + dx, y + dy, std::max(std::abs(dx), std::abs(dy)) != 1);
+	}
+}
+
+
+void QrCode::setFunctionModule(int x, int y, bool isDark) {
+	size_t ux = static_cast<size_t>(x);
+	size_t uy = static_cast<size_t>(y);
+	modules   .at(uy).at(ux) = isDark;
+	isFunction.at(uy).at(ux) = true;
+}
+
+
+bool QrCode::module(int x, int y) const {
+	return modules.at(static_cast<size_t>(y)).at(static_cast<size_t>(x));
+}
+
+
+vector<uint8_t> QrCode::addEccAndInterleave(const vector<uint8_t> &data) const {
+	if (data.size() != static_cast<unsigned int>(getNumDataCodewords(version, errorCorrectionLevel)))
+		throw std::invalid_argument("Invalid argument");
+	
+	// Calculate parameter numbers
+	int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[static_cast<int>(errorCorrectionLevel)][version];
+	int blockEccLen = ECC_CODEWORDS_PER_BLOCK  [static_cast<int>(errorCorrectionLevel)][version];
+	int rawCodewords = getNumRawDataModules(version) / 8;
+	int numShortBlocks = numBlocks - rawCodewords % numBlocks;
+	int shortBlockLen = rawCodewords / numBlocks;
+	
+	// Split data into blocks and append ECC to each block
+	vector<vector<uint8_t> > blocks;
+	const vector<uint8_t> rsDiv = reedSolomonComputeDivisor(blockEccLen);
+	for (int i = 0, k = 0; i < numBlocks; i++) {
+		vector<uint8_t> dat(data.cbegin() + k, data.cbegin() + (k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1)));
+		k += static_cast<int>(dat.size());
+		const vector<uint8_t> ecc = reedSolomonComputeRemainder(dat, rsDiv);
+		if (i < numShortBlocks)
+			dat.push_back(0);
+		dat.insert(dat.end(), ecc.cbegin(), ecc.cend());
+		blocks.push_back(std::move(dat));
+	}
+	
+	// Interleave (not concatenate) the bytes from every block into a single sequence
+	vector<uint8_t> result;
+	for (size_t i = 0; i < blocks.at(0).size(); i++) {
+		for (size_t j = 0; j < blocks.size(); j++) {
+			// Skip the padding byte in short blocks
+			if (i != static_cast<unsigned int>(shortBlockLen - blockEccLen) || j >= static_cast<unsigned int>(numShortBlocks))
+				result.push_back(blocks.at(j).at(i));
+		}
+	}
+	assert(result.size() == static_cast<unsigned int>(rawCodewords));
+	return result;
+}
+
+
+void QrCode::drawCodewords(const vector<uint8_t> &data) {
+	if (data.size() != static_cast<unsigned int>(getNumRawDataModules(version) / 8))
+		throw std::invalid_argument("Invalid argument");
+	
+	size_t i = 0;  // Bit index into the data
+	// Do the funny zigzag scan
+	for (int right = size - 1; right >= 1; right -= 2) {  // Index of right column in each column pair
+		if (right == 6)
+			right = 5;
+		for (int vert = 0; vert < size; vert++) {  // Vertical counter
+			for (int j = 0; j < 2; j++) {
+				size_t x = static_cast<size_t>(right - j);  // Actual x coordinate
+				bool upward = ((right + 1) & 2) == 0;
+				size_t y = static_cast<size_t>(upward ? size - 1 - vert : vert);  // Actual y coordinate
+				if (!isFunction.at(y).at(x) && i < data.size() * 8) {
+					modules.at(y).at(x) = getBit(data.at(i >> 3), 7 - static_cast<int>(i & 7));
+					i++;
+				}
+				// If this QR Code has any remainder bits (0 to 7), they were assigned as
+				// 0/false/light by the constructor and are left unchanged by this method
+			}
+		}
+	}
+	assert(i == data.size() * 8);
+}
+
+
+void QrCode::applyMask(int msk) {
+	if (msk < 0 || msk > 7)
+		throw std::domain_error("Mask value out of range");
+	size_t sz = static_cast<size_t>(size);
+	for (size_t y = 0; y < sz; y++) {
+		for (size_t x = 0; x < sz; x++) {
+			bool invert;
+			switch (msk) {
+				case 0:  invert = (x + y) % 2 == 0;                    break;
+				case 1:  invert = y % 2 == 0;                          break;
+				case 2:  invert = x % 3 == 0;                          break;
+				case 3:  invert = (x + y) % 3 == 0;                    break;
+				case 4:  invert = (x / 3 + y / 2) % 2 == 0;            break;
+				case 5:  invert = x * y % 2 + x * y % 3 == 0;          break;
+				case 6:  invert = (x * y % 2 + x * y % 3) % 2 == 0;    break;
+				case 7:  invert = ((x + y) % 2 + x * y % 3) % 2 == 0;  break;
+				default:  throw std::logic_error("Unreachable");
+			}
+			modules.at(y).at(x) = modules.at(y).at(x) ^ (invert & !isFunction.at(y).at(x));
+		}
+	}
+}
+
+
+long QrCode::getPenaltyScore() const {
+	long result = 0;
+	
+	// Adjacent modules in row having same color, and finder-like patterns
+	for (int y = 0; y < size; y++) {
+		bool runColor = false;
+		int runX = 0;
+		std::array<int,7> runHistory = {};
+		for (int x = 0; x < size; x++) {
+			if (module(x, y) == runColor) {
+				runX++;
+				if (runX == 5)
+					result += PENALTY_N1;
+				else if (runX > 5)
+					result++;
+			} else {
+				finderPenaltyAddHistory(runX, runHistory);
+				if (!runColor)
+					result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+				runColor = module(x, y);
+				runX = 1;
+			}
+		}
+		result += finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
+	}
+	// Adjacent modules in column having same color, and finder-like patterns
+	for (int x = 0; x < size; x++) {
+		bool runColor = false;
+		int runY = 0;
+		std::array<int,7> runHistory = {};
+		for (int y = 0; y < size; y++) {
+			if (module(x, y) == runColor) {
+				runY++;
+				if (runY == 5)
+					result += PENALTY_N1;
+				else if (runY > 5)
+					result++;
+			} else {
+				finderPenaltyAddHistory(runY, runHistory);
+				if (!runColor)
+					result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+				runColor = module(x, y);
+				runY = 1;
+			}
+		}
+		result += finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
+	}
+	
+	// 2*2 blocks of modules having same color
+	for (int y = 0; y < size - 1; y++) {
+		for (int x = 0; x < size - 1; x++) {
+			bool  color = module(x, y);
+			if (  color == module(x + 1, y) &&
+			      color == module(x, y + 1) &&
+			      color == module(x + 1, y + 1))
+				result += PENALTY_N2;
+		}
+	}
+	
+	// Balance of dark and light modules
+	int dark = 0;
+	for (const vector<bool> &row : modules) {
+		for (bool color : row) {
+			if (color)
+				dark++;
+		}
+	}
+	int total = size * size;  // Note that size is odd, so dark/total != 1/2
+	// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+	int k = static_cast<int>((std::abs(dark * 20L - total * 10L) + total - 1) / total) - 1;
+	assert(0 <= k && k <= 9);
+	result += k * PENALTY_N4;
+	assert(0 <= result && result <= 2568888L);  // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
+	return result;
+}
+
+
+vector<int> QrCode::getAlignmentPatternPositions() const {
+	if (version == 1)
+		return vector<int>();
+	else {
+		int numAlign = version / 7 + 2;
+		int step = (version == 32) ? 26 :
+			(version * 4 + numAlign * 2 + 1) / (numAlign * 2 - 2) * 2;
+		vector<int> result;
+		for (int i = 0, pos = size - 7; i < numAlign - 1; i++, pos -= step)
+			result.insert(result.begin(), pos);
+		result.insert(result.begin(), 6);
+		return result;
+	}
+}
+
+
+int QrCode::getNumRawDataModules(int ver) {
+	if (ver < MIN_VERSION || ver > MAX_VERSION)
+		throw std::domain_error("Version number out of range");
+	int result = (16 * ver + 128) * ver + 64;
+	if (ver >= 2) {
+		int numAlign = ver / 7 + 2;
+		result -= (25 * numAlign - 10) * numAlign - 55;
+		if (ver >= 7)
+			result -= 36;
+	}
+	assert(208 <= result && result <= 29648);
+	return result;
+}
+
+
+int QrCode::getNumDataCodewords(int ver, Ecc ecl) {
+	return getNumRawDataModules(ver) / 8
+		- ECC_CODEWORDS_PER_BLOCK    [static_cast<int>(ecl)][ver]
+		* NUM_ERROR_CORRECTION_BLOCKS[static_cast<int>(ecl)][ver];
+}
+
+
+vector<uint8_t> QrCode::reedSolomonComputeDivisor(int degree) {
+	if (degree < 1 || degree > 255)
+		throw std::domain_error("Degree out of range");
+	// Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
+	// For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array {255, 8, 93}.
+	vector<uint8_t> result(static_cast<size_t>(degree));
+	result.at(result.size() - 1) = 1;  // Start off with the monomial x^0
+	
+	// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
+	// and drop the highest monomial term which is always 1x^degree.
+	// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
+	uint8_t root = 1;
+	for (int i = 0; i < degree; i++) {
+		// Multiply the current product by (x - r^i)
+		for (size_t j = 0; j < result.size(); j++) {
+			result.at(j) = reedSolomonMultiply(result.at(j), root);
+			if (j + 1 < result.size())
+				result.at(j) ^= result.at(j + 1);
+		}
+		root = reedSolomonMultiply(root, 0x02);
+	}
+	return result;
+}
+
+
+vector<uint8_t> QrCode::reedSolomonComputeRemainder(const vector<uint8_t> &data, const vector<uint8_t> &divisor) {
+	vector<uint8_t> result(divisor.size());
+	for (uint8_t b : data) {  // Polynomial division
+		uint8_t factor = b ^ result.at(0);
+		result.erase(result.begin());
+		result.push_back(0);
+		for (size_t i = 0; i < result.size(); i++)
+			result.at(i) ^= reedSolomonMultiply(divisor.at(i), factor);
+	}
+	return result;
+}
+
+
+uint8_t QrCode::reedSolomonMultiply(uint8_t x, uint8_t y) {
+	// Russian peasant multiplication
+	int z = 0;
+	for (int i = 7; i >= 0; i--) {
+		z = (z << 1) ^ ((z >> 7) * 0x11D);
+		z ^= ((y >> i) & 1) * x;
+	}
+	assert(z >> 8 == 0);
+	return static_cast<uint8_t>(z);
+}
+
+
+int QrCode::finderPenaltyCountPatterns(const std::array<int,7> &runHistory) const {
+	int n = runHistory.at(1);
+	assert(n <= size * 3);
+	bool core = n > 0 && runHistory.at(2) == n && runHistory.at(3) == n * 3 && runHistory.at(4) == n && runHistory.at(5) == n;
+	return (core && runHistory.at(0) >= n * 4 && runHistory.at(6) >= n ? 1 : 0)
+	     + (core && runHistory.at(6) >= n * 4 && runHistory.at(0) >= n ? 1 : 0);
+}
+
+
+int QrCode::finderPenaltyTerminateAndCount(bool currentRunColor, int currentRunLength, std::array<int,7> &runHistory) const {
+	if (currentRunColor) {  // Terminate dark run
+		finderPenaltyAddHistory(currentRunLength, runHistory);
+		currentRunLength = 0;
+	}
+	currentRunLength += size;  // Add light border to final run
+	finderPenaltyAddHistory(currentRunLength, runHistory);
+	return finderPenaltyCountPatterns(runHistory);
+}
+
+
+void QrCode::finderPenaltyAddHistory(int currentRunLength, std::array<int,7> &runHistory) const {
+	if (runHistory.at(0) == 0)
+		currentRunLength += size;  // Add light border to initial run
+	std::copy_backward(runHistory.cbegin(), runHistory.cend() - 1, runHistory.end());
+	runHistory.at(0) = currentRunLength;
+}
+
+
+bool QrCode::getBit(long x, int i) {
+	return ((x >> i) & 1) != 0;
+}
+
+
+/*---- Tables of constants ----*/
+
+const int QrCode::PENALTY_N1 =  3;
+const int QrCode::PENALTY_N2 =  3;
+const int QrCode::PENALTY_N3 = 40;
+const int QrCode::PENALTY_N4 = 10;
+
+
+const int8_t QrCode::ECC_CODEWORDS_PER_BLOCK[4][41] = {
+	// Version: (note that index 0 is for padding, and is set to an illegal value)
+	//0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+	{-1,  7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // Low
+	{-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28},  // Medium
+	{-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // Quartile
+	{-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // High
+};
+
+const int8_t QrCode::NUM_ERROR_CORRECTION_BLOCKS[4][41] = {
+	// Version: (note that index 0 is for padding, and is set to an illegal value)
+	//0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+	{-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4,  4,  4,  4,  4,  6,  6,  6,  6,  7,  8,  8,  9,  9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25},  // Low
+	{-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5,  5,  8,  9,  9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49},  // Medium
+	{-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8,  8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68},  // Quartile
+	{-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81},  // High
+};
+
+
+data_too_long::data_too_long(const std::string &msg) :
+	std::length_error(msg) {}
+
+
+
+/*---- Class BitBuffer ----*/
+
+BitBuffer::BitBuffer()
+	: std::vector<bool>() {}
+
+
+void BitBuffer::appendBits(std::uint32_t val, int len) {
+	if (len < 0 || len > 31 || val >> len != 0)
+		throw std::domain_error("Value out of range");
+	for (int i = len - 1; i >= 0; i--)  // Append bit by bit
+		this->push_back(((val >> i) & 1) != 0);
+}
+
+}

Telegram/ThirdParty/QR/cpp/qrcodegen.hpp

@@ -0,0 +1,549 @@
+/* 
+ * QR Code generator library (C++)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+
+namespace qrcodegen {
+
+/* 
+ * A segment of character/binary/control data in a QR Code symbol.
+ * Instances of this class are immutable.
+ * The mid-level way to create a segment is to take the payload data
+ * and call a static factory function such as QrSegment::makeNumeric().
+ * The low-level way to create a segment is to custom-make the bit buffer
+ * and call the QrSegment() constructor with appropriate values.
+ * This segment class imposes no length restrictions, but QR Codes have restrictions.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ */
+class QrSegment final {
+	
+	/*---- Public helper enumeration ----*/
+	
+	/* 
+	 * Describes how a segment's data bits are interpreted. Immutable.
+	 */
+	public: class Mode final {
+		
+		/*-- Constants --*/
+		
+		public: static const Mode NUMERIC;
+		public: static const Mode ALPHANUMERIC;
+		public: static const Mode BYTE;
+		public: static const Mode KANJI;
+		public: static const Mode ECI;
+		
+		
+		/*-- Fields --*/
+		
+		// The mode indicator bits, which is a uint4 value (range 0 to 15).
+		private: int modeBits;
+		
+		// Number of character count bits for three different version ranges.
+		private: int numBitsCharCount[3];
+		
+		
+		/*-- Constructor --*/
+		
+		private: Mode(int mode, int cc0, int cc1, int cc2);
+		
+		
+		/*-- Methods --*/
+		
+		/* 
+		 * (Package-private) Returns the mode indicator bits, which is an unsigned 4-bit value (range 0 to 15).
+		 */
+		public: int getModeBits() const;
+		
+		/* 
+		 * (Package-private) Returns the bit width of the character count field for a segment in
+		 * this mode in a QR Code at the given version number. The result is in the range [0, 16].
+		 */
+		public: int numCharCountBits(int ver) const;
+		
+	};
+	
+	
+	
+	/*---- Static factory functions (mid level) ----*/
+	
+	/* 
+	 * Returns a segment representing the given binary data encoded in
+	 * byte mode. All input byte vectors are acceptable. Any text string
+	 * can be converted to UTF-8 bytes and encoded as a byte mode segment.
+	 */
+	public: static QrSegment makeBytes(const std::vector<std::uint8_t> &data);
+	
+	
+	/* 
+	 * Returns a segment representing the given string of decimal digits encoded in numeric mode.
+	 */
+	public: static QrSegment makeNumeric(const char *digits);
+	
+	
+	/* 
+	 * Returns a segment representing the given text string encoded in alphanumeric mode.
+	 * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+	 * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	 */
+	public: static QrSegment makeAlphanumeric(const char *text);
+	
+	
+	/* 
+	 * Returns a list of zero or more segments to represent the given text string. The result
+	 * may use various segment modes and switch modes to optimize the length of the bit stream.
+	 */
+	public: static std::vector<QrSegment> makeSegments(const char *text);
+	
+	
+	/* 
+	 * Returns a segment representing an Extended Channel Interpretation
+	 * (ECI) designator with the given assignment value.
+	 */
+	public: static QrSegment makeEci(long assignVal);
+	
+	
+	/*---- Public static helper functions ----*/
+	
+	/* 
+	 * Tests whether the given string can be encoded as a segment in numeric mode.
+	 * A string is encodable iff each character is in the range 0 to 9.
+	 */
+	public: static bool isNumeric(const char *text);
+	
+	
+	/* 
+	 * Tests whether the given string can be encoded as a segment in alphanumeric mode.
+	 * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+	 * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	 */
+	public: static bool isAlphanumeric(const char *text);
+	
+	
+	
+	/*---- Instance fields ----*/
+	
+	/* The mode indicator of this segment. Accessed through getMode(). */
+	private: const Mode *mode;
+	
+	/* The length of this segment's unencoded data. Measured in characters for
+	 * numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	 * Always zero or positive. Not the same as the data's bit length.
+	 * Accessed through getNumChars(). */
+	private: int numChars;
+	
+	/* The data bits of this segment. Accessed through getData(). */
+	private: std::vector<bool> data;
+	
+	
+	/*---- Constructors (low level) ----*/
+	
+	/* 
+	 * Creates a new QR Code segment with the given attributes and data.
+	 * The character count (numCh) must agree with the mode and the bit buffer length,
+	 * but the constraint isn't checked. The given bit buffer is copied and stored.
+	 */
+	public: QrSegment(const Mode &md, int numCh, const std::vector<bool> &dt);
+	
+	
+	/* 
+	 * Creates a new QR Code segment with the given parameters and data.
+	 * The character count (numCh) must agree with the mode and the bit buffer length,
+	 * but the constraint isn't checked. The given bit buffer is moved and stored.
+	 */
+	public: QrSegment(const Mode &md, int numCh, std::vector<bool> &&dt);
+	
+	
+	/*---- Methods ----*/
+	
+	/* 
+	 * Returns the mode field of this segment.
+	 */
+	public: const Mode &getMode() const;
+	
+	
+	/* 
+	 * Returns the character count field of this segment.
+	 */
+	public: int getNumChars() const;
+	
+	
+	/* 
+	 * Returns the data bits of this segment.
+	 */
+	public: const std::vector<bool> &getData() const;
+	
+	
+	// (Package-private) Calculates the number of bits needed to encode the given segments at
+	// the given version. Returns a non-negative number if successful. Otherwise returns -1 if a
+	// segment has too many characters to fit its length field, or the total bits exceeds INT_MAX.
+	public: static int getTotalBits(const std::vector<QrSegment> &segs, int version);
+	
+	
+	/*---- Private constant ----*/
+	
+	/* The set of all legal characters in alphanumeric mode, where
+	 * each character value maps to the index in the string. */
+	private: static const char *ALPHANUMERIC_CHARSET;
+	
+};
+
+
+
+/* 
+ * A QR Code symbol, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * Instances of this class represent an immutable square grid of dark and light cells.
+ * The class provides static factory functions to create a QR Code from text or binary data.
+ * The class covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+ * 
+ * Ways to create a QR Code object:
+ * - High level: Take the payload data and call QrCode::encodeText() or QrCode::encodeBinary().
+ * - Mid level: Custom-make the list of segments and call QrCode::encodeSegments().
+ * - Low level: Custom-make the array of data codeword bytes (including
+ *   segment headers and final padding, excluding error correction codewords),
+ *   supply the appropriate version number, and call the QrCode() constructor.
+ * (Note that all ways require supplying the desired error correction level.)
+ */
+class QrCode final {
+	
+	/*---- Public helper enumeration ----*/
+	
+	/* 
+	 * The error correction level in a QR Code symbol.
+	 */
+	public: enum class Ecc {
+		LOW = 0 ,  // The QR Code can tolerate about  7% erroneous codewords
+		MEDIUM  ,  // The QR Code can tolerate about 15% erroneous codewords
+		QUARTILE,  // The QR Code can tolerate about 25% erroneous codewords
+		HIGH    ,  // The QR Code can tolerate about 30% erroneous codewords
+	};
+	
+	
+	// Returns a value in the range 0 to 3 (unsigned 2-bit integer).
+	private: static int getFormatBits(Ecc ecl);
+	
+	
+	
+	/*---- Static factory functions (high level) ----*/
+	
+	/* 
+	 * Returns a QR Code representing the given Unicode text string at the given error correction level.
+	 * As a conservative upper bound, this function is guaranteed to succeed for strings that have 2953 or fewer
+	 * UTF-8 code units (not Unicode code points) if the low error correction level is used. The smallest possible
+	 * QR Code version is automatically chosen for the output. The ECC level of the result may be higher than
+	 * the ecl argument if it can be done without increasing the version.
+	 */
+	public: static QrCode encodeText(const char *text, Ecc ecl);
+	
+	
+	/* 
+	 * Returns a QR Code representing the given binary data at the given error correction level.
+	 * This function always encodes using the binary segment mode, not any text mode. The maximum number of
+	 * bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+	 * The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
+	 */
+	public: static QrCode encodeBinary(const std::vector<std::uint8_t> &data, Ecc ecl);
+	
+	
+	/*---- Static factory functions (mid level) ----*/
+	
+	/* 
+	 * Returns a QR Code representing the given segments with the given encoding parameters.
+	 * The smallest possible QR Code version within the given range is automatically
+	 * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+	 * may be higher than the ecl argument if it can be done without increasing the
+	 * version. The mask number is either between 0 to 7 (inclusive) to force that
+	 * mask, or -1 to automatically choose an appropriate mask (which may be slow).
+	 * This function allows the user to create a custom sequence of segments that switches
+	 * between modes (such as alphanumeric and byte) to encode text in less space.
+	 * This is a mid-level API; the high-level API is encodeText() and encodeBinary().
+	 */
+	public: static QrCode encodeSegments(const std::vector<QrSegment> &segs, Ecc ecl,
+		int minVersion=1, int maxVersion=40, int mask=-1, bool boostEcl=true);  // All optional parameters
+	
+	
+	
+	/*---- Instance fields ----*/
+	
+	// Immutable scalar parameters:
+	
+	/* The version number of this QR Code, which is between 1 and 40 (inclusive).
+	 * This determines the size of this barcode. */
+	private: int version;
+	
+	/* The width and height of this QR Code, measured in modules, between
+	 * 21 and 177 (inclusive). This is equal to version * 4 + 17. */
+	private: int size;
+	
+	/* The error correction level used in this QR Code. */
+	private: Ecc errorCorrectionLevel;
+	
+	/* The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+	 * Even if a QR Code is created with automatic masking requested (mask = -1),
+	 * the resulting object still has a mask value between 0 and 7. */
+	private: int mask;
+	
+	// Private grids of modules/pixels, with dimensions of size*size:
+	
+	// The modules of this QR Code (false = light, true = dark).
+	// Immutable after constructor finishes. Accessed through getModule().
+	private: std::vector<std::vector<bool> > modules;
+	
+	// Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+	private: std::vector<std::vector<bool> > isFunction;
+	
+	
+	
+	/*---- Constructor (low level) ----*/
+	
+	/* 
+	 * Creates a new QR Code with the given version number,
+	 * error correction level, data codeword bytes, and mask number.
+	 * This is a low-level API that most users should not use directly.
+	 * A mid-level API is the encodeSegments() function.
+	 */
+	public: QrCode(int ver, Ecc ecl, const std::vector<std::uint8_t> &dataCodewords, int msk);
+	
+	
+	
+	/*---- Public instance methods ----*/
+	
+	/* 
+	 * Returns this QR Code's version, in the range [1, 40].
+	 */
+	public: int getVersion() const;
+	
+	
+	/* 
+	 * Returns this QR Code's size, in the range [21, 177].
+	 */
+	public: int getSize() const;
+	
+	
+	/* 
+	 * Returns this QR Code's error correction level.
+	 */
+	public: Ecc getErrorCorrectionLevel() const;
+	
+	
+	/* 
+	 * Returns this QR Code's mask, in the range [0, 7].
+	 */
+	public: int getMask() const;
+	
+	
+	/* 
+	 * Returns the color of the module (pixel) at the given coordinates, which is false
+	 * for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+	 * If the given coordinates are out of bounds, then false (light) is returned.
+	 */
+	public: bool getModule(int x, int y) const;
+	
+	
+	
+	/*---- Private helper methods for constructor: Drawing function modules ----*/
+	
+	// Reads this object's version field, and draws and marks all function modules.
+	private: void drawFunctionPatterns();
+	
+	
+	// Draws two copies of the format bits (with its own error correction code)
+	// based on the given mask and this object's error correction level field.
+	private: void drawFormatBits(int msk);
+	
+	
+	// Draws two copies of the version bits (with its own error correction code),
+	// based on this object's version field, iff 7 <= version <= 40.
+	private: void drawVersion();
+	
+	
+	// Draws a 9*9 finder pattern including the border separator,
+	// with the center module at (x, y). Modules can be out of bounds.
+	private: void drawFinderPattern(int x, int y);
+	
+	
+	// Draws a 5*5 alignment pattern, with the center module
+	// at (x, y). All modules must be in bounds.
+	private: void drawAlignmentPattern(int x, int y);
+	
+	
+	// Sets the color of a module and marks it as a function module.
+	// Only used by the constructor. Coordinates must be in bounds.
+	private: void setFunctionModule(int x, int y, bool isDark);
+	
+	
+	// Returns the color of the module at the given coordinates, which must be in range.
+	private: bool module(int x, int y) const;
+	
+	
+	/*---- Private helper methods for constructor: Codewords and masking ----*/
+	
+	// Returns a new byte string representing the given data with the appropriate error correction
+	// codewords appended to it, based on this object's version and error correction level.
+	private: std::vector<std::uint8_t> addEccAndInterleave(const std::vector<std::uint8_t> &data) const;
+	
+	
+	// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+	// data area of this QR Code. Function modules need to be marked off before this is called.
+	private: void drawCodewords(const std::vector<std::uint8_t> &data);
+	
+	
+	// XORs the codeword modules in this QR Code with the given mask pattern.
+	// The function modules must be marked and the codeword bits must be drawn
+	// before masking. Due to the arithmetic of XOR, calling applyMask() with
+	// the same mask value a second time will undo the mask. A final well-formed
+	// QR Code needs exactly one (not zero, two, etc.) mask applied.
+	private: void applyMask(int msk);
+	
+	
+	// Calculates and returns the penalty score based on state of this QR Code's current modules.
+	// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+	private: long getPenaltyScore() const;
+	
+	
+	
+	/*---- Private helper functions ----*/
+	
+	// Returns an ascending list of positions of alignment patterns for this version number.
+	// Each position is in the range [0,177), and are used on both the x and y axes.
+	// This could be implemented as lookup table of 40 variable-length lists of unsigned bytes.
+	private: std::vector<int> getAlignmentPatternPositions() const;
+	
+	
+	// Returns the number of data bits that can be stored in a QR Code of the given version number, after
+	// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+	// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
+	private: static int getNumRawDataModules(int ver);
+	
+	
+	// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+	// QR Code of the given version number and error correction level, with remainder bits discarded.
+	// This stateless pure function could be implemented as a (40*4)-cell lookup table.
+	private: static int getNumDataCodewords(int ver, Ecc ecl);
+	
+	
+	// Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
+	// implemented as a lookup table over all possible parameter values, instead of as an algorithm.
+	private: static std::vector<std::uint8_t> reedSolomonComputeDivisor(int degree);
+	
+	
+	// Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
+	private: static std::vector<std::uint8_t> reedSolomonComputeRemainder(const std::vector<std::uint8_t> &data, const std::vector<std::uint8_t> &divisor);
+	
+	
+	// Returns the product of the two given field elements modulo GF(2^8/0x11D).
+	// All inputs are valid. This could be implemented as a 256*256 lookup table.
+	private: static std::uint8_t reedSolomonMultiply(std::uint8_t x, std::uint8_t y);
+	
+	
+	// Can only be called immediately after a light run is added, and
+	// returns either 0, 1, or 2. A helper function for getPenaltyScore().
+	private: int finderPenaltyCountPatterns(const std::array<int,7> &runHistory) const;
+	
+	
+	// Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+	private: int finderPenaltyTerminateAndCount(bool currentRunColor, int currentRunLength, std::array<int,7> &runHistory) const;
+	
+	
+	// Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+	private: void finderPenaltyAddHistory(int currentRunLength, std::array<int,7> &runHistory) const;
+	
+	
+	// Returns true iff the i'th bit of x is set to 1.
+	private: static bool getBit(long x, int i);
+	
+	
+	/*---- Constants and tables ----*/
+	
+	// The minimum version number supported in the QR Code Model 2 standard.
+	public: static constexpr int MIN_VERSION =  1;
+	
+	// The maximum version number supported in the QR Code Model 2 standard.
+	public: static constexpr int MAX_VERSION = 40;
+	
+	
+	// For use in getPenaltyScore(), when evaluating which mask is best.
+	private: static const int PENALTY_N1;
+	private: static const int PENALTY_N2;
+	private: static const int PENALTY_N3;
+	private: static const int PENALTY_N4;
+	
+	
+	private: static const std::int8_t ECC_CODEWORDS_PER_BLOCK[4][41];
+	private: static const std::int8_t NUM_ERROR_CORRECTION_BLOCKS[4][41];
+	
+};
+
+
+
+/*---- Public exception class ----*/
+
+/* 
+ * Thrown when the supplied data does not fit any QR Code version. Ways to handle this exception include:
+ * - Decrease the error correction level if it was greater than Ecc::LOW.
+ * - If the encodeSegments() function was called with a maxVersion argument, then increase
+ *   it if it was less than QrCode::MAX_VERSION. (This advice does not apply to the other
+ *   factory functions because they search all versions up to QrCode::MAX_VERSION.)
+ * - Split the text data into better or optimal segments in order to reduce the number of bits required.
+ * - Change the text or binary data to be shorter.
+ * - Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).
+ * - Propagate the error upward to the caller/user.
+ */
+class data_too_long : public std::length_error {
+	
+	public: explicit data_too_long(const std::string &msg);
+	
+};
+
+
+
+/* 
+ * An appendable sequence of bits (0s and 1s). Mainly used by QrSegment.
+ */
+class BitBuffer final : public std::vector<bool> {
+	
+	/*---- Constructor ----*/
+	
+	// Creates an empty bit buffer (length 0).
+	public: BitBuffer();
+	
+	
+	
+	/*---- Method ----*/
+	
+	// Appends the given number of low-order bits of the given value
+	// to this buffer. Requires 0 <= len <= 31 and val < 2^len.
+	public: void appendBits(std::uint32_t val, int len);
+	
+};
+
+}

Telegram/ThirdParty/QR/java-fast/Readme.markdown

@@ -0,0 +1,65 @@
+QR Code generator library - Java, fast
+======================================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page for this fast library with design explanation and benchmarks: https://www.nayuki.io/page/fast-qr-code-generator-library
+
+Home page for the main project with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Approximately 1.5× to 10× faster than other Java implementation
+* Shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes
+* Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```java
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.List;
+import javax.imageio.ImageIO;
+import io.nayuki.fastqrcodegen.*;
+
+// Simple operation
+QrCode qr0 = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
+BufferedImage img = toImage(qr0, 4, 10);  // See QrCodeGeneratorDemo
+ImageIO.write(img, "png", new File("qr-code.png"));
+
+// Manual operation
+List<QrSegment> segs = QrSegment.makeSegments("3141592653589793238462643383");
+QrCode qr1 = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
+for (int y = 0; y < qr1.size; y++) {
+    for (int x = 0; x < qr1.size; x++) {
+        (... paint qr1.getModule(x, y) ...)
+    }
+}
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/java-fast/io/nayuki/fastqrcodegen/QrCodeGeneratorDemo.java .

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/BitBuffer.java

@@ -0,0 +1,134 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+
+// An appendable sequence of bits (0s and 1s), mainly used by QrSegment.
+final class BitBuffer {
+	
+	/*---- Fields ----*/
+	
+	int[] data;  // In each 32-bit word, bits are filled from top down.
+	
+	int bitLength;  // Always non-negative.
+	
+	
+	
+	/*---- Constructor ----*/
+	
+	// Creates an empty bit buffer.
+	public BitBuffer() {
+		data = new int[64];
+		bitLength = 0;
+	}
+	
+	
+	
+	/*---- Methods ----*/
+	
+	// Returns the bit at the given index, yielding 0 or 1.
+	public int getBit(int index) {
+		if (index < 0 || index >= bitLength)
+			throw new IndexOutOfBoundsException();
+		return (data[index >>> 5] >>> ~index) & 1;
+	}
+	
+	
+	// Returns a new array representing this buffer's bits packed into
+	// bytes in big endian. The current bit length must be a multiple of 8.
+	public byte[] getBytes() {
+		if (bitLength % 8 != 0)
+			throw new IllegalStateException("Data is not a whole number of bytes");
+		byte[] result = new byte[bitLength / 8];
+		for (int i = 0; i < result.length; i++)
+			result[i] = (byte)(data[i >>> 2] >>> (~i << 3));
+		return result;
+	}
+	
+	
+	// Appends the given number of low-order bits of the given value
+	// to this buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
+	public void appendBits(int val, int len) {
+		if (len < 0 || len > 31 || val >>> len != 0)
+			throw new IllegalArgumentException("Value out of range");
+		if (len > Integer.MAX_VALUE - bitLength)
+			throw new IllegalStateException("Maximum length reached");
+		
+		if (bitLength + len + 1 > data.length << 5)
+			data = Arrays.copyOf(data, data.length * 2);
+		assert bitLength + len <= data.length << 5;
+		
+		int remain = 32 - (bitLength & 0x1F);
+		assert 1 <= remain && remain <= 32;
+		if (remain < len) {
+			data[bitLength >>> 5] |= val >>> (len - remain);
+			bitLength += remain;
+			assert (bitLength & 0x1F) == 0;
+			len -= remain;
+			val &= (1 << len) - 1;
+			remain = 32;
+		}
+		data[bitLength >>> 5] |= val << (remain - len);
+		bitLength += len;
+	}
+	
+	
+	// Appends to this buffer the sequence of bits represented by the given
+	// word array and given bit length. Requires 0 <= len <= 32 * vals.length.
+	public void appendBits(int[] vals, int len) {
+		Objects.requireNonNull(vals);
+		if (len == 0)
+			return;
+		if (len < 0 || len > vals.length * 32L)
+			throw new IllegalArgumentException("Value out of range");
+		int wholeWords = len / 32;
+		int tailBits = len % 32;
+		if (tailBits > 0 && vals[wholeWords] << tailBits != 0)
+			throw new IllegalArgumentException("Last word must have low bits clear");
+		if (len > Integer.MAX_VALUE - bitLength)
+			throw new IllegalStateException("Maximum length reached");
+		
+		while (bitLength + len > data.length * 32)
+			data = Arrays.copyOf(data, data.length * 2);
+		
+		int shift = bitLength % 32;
+		if (shift == 0) {
+			System.arraycopy(vals, 0, data, bitLength / 32, (len + 31) / 32);
+			bitLength += len;
+		} else {
+			for (int i = 0; i < wholeWords; i++) {
+				int word = vals[i];
+				data[bitLength >>> 5] |= word >>> shift;
+				bitLength += 32;
+				data[bitLength >>> 5] = word << (32 - shift);
+			}
+			if (tailBits > 0)
+				appendBits(vals[wholeWords] >>> (32 - tailBits), tailBits);
+		}
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/DataTooLongException.java

@@ -0,0 +1,57 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+
+/**
+ * Thrown when the supplied data does not fit any QR Code version. Ways to handle this exception include:
+ * <ul>
+ *   <li><p>Decrease the error correction level if it was greater than {@code Ecc.LOW}.</p></li>
+ *   <li><p>If the advanced {@code encodeSegments()} function with 6 arguments or the
+ *     {@code makeSegmentsOptimally()} function was called, then increase the maxVersion argument
+ *     if it was less than {@link QrCode#MAX_VERSION}. (This advice does not apply to the other
+ *     factory functions because they search all versions up to {@code QrCode.MAX_VERSION}.)</p></li>
+ *   <li><p>Split the text data into better or optimal segments in order to reduce the number of
+ *     bits required. (See {@link QrSegmentAdvanced#makeSegmentsOptimally(String,QrCode.Ecc,int,int)
+ *     QrSegmentAdvanced.makeSegmentsOptimally()}.)</p></li>
+ *   <li><p>Change the text or binary data to be shorter.</p></li>
+ *   <li><p>Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).</p></li>
+ *   <li><p>Propagate the error upward to the caller/user.</p></li>
+ * </ul>
+ * @see QrCode#encodeText(String, QrCode.Ecc)
+ * @see QrCode#encodeBinary(byte[], QrCode.Ecc)
+ * @see QrCode#encodeSegments(java.util.List, QrCode.Ecc)
+ * @see QrCode#encodeSegments(java.util.List, QrCode.Ecc, int, int, int, boolean)
+ * @see QrSegmentAdvanced#makeSegmentsOptimally(String, QrCode.Ecc, int, int)
+ */
+public class DataTooLongException extends IllegalArgumentException {
+	
+	public DataTooLongException() {}
+	
+	
+	public DataTooLongException(String msg) {
+		super(msg);
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/Memoizer.java

@@ -0,0 +1,95 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.lang.ref.SoftReference;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+
+// A thread-safe cache based on soft references.
+final class Memoizer<T,R> {
+	
+	private final Function<T,R> function;
+	Map<T,SoftReference<R>> cache = new ConcurrentHashMap<>();
+	private Set<T> pending = new HashSet<>();
+	
+	
+	// Creates a memoizer based on the given function that takes one input to compute an output.
+	public Memoizer(Function<T,R> func) {
+		function = func;
+	}
+	
+	
+	// Computes function.apply(arg) or returns a cached copy of a previous call.
+	public R get(T arg) {
+		// Non-blocking fast path
+		{
+			SoftReference<R> ref = cache.get(arg);
+			if (ref != null) {
+				R result = ref.get();
+				if (result != null)
+					return result;
+			}
+		}
+		
+		// Sequential slow path
+		while (true) {
+			synchronized(this) {
+				SoftReference<R> ref = cache.get(arg);
+				if (ref != null) {
+					R result = ref.get();
+					if (result != null)
+						return result;
+					cache.remove(arg);
+				}
+				assert !cache.containsKey(arg);
+				
+				if (pending.add(arg))
+					break;
+				
+				try {
+					this.wait();
+				} catch (InterruptedException e) {
+					throw new RuntimeException(e);
+				}
+			}
+		}
+		
+		try {
+			R result = function.apply(arg);
+			cache.put(arg, new SoftReference<>(result));
+			return result;
+		} finally {
+			synchronized(this) {
+				pending.remove(arg);
+				this.notifyAll();
+			}
+		}
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/QrCode.java

@@ -0,0 +1,595 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+
+/**
+ * A QR Code symbol, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * <p>Instances of this class represent an immutable square grid of dark and light cells.
+ * The class provides static factory functions to create a QR Code from text or binary data.
+ * The class covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.</p>
+ * <p>Ways to create a QR Code object:</p>
+ * <ul>
+ *   <li><p>High level: Take the payload data and call {@link QrCode#encodeText(String,Ecc)}
+ *     or {@link QrCode#encodeBinary(byte[],Ecc)}.</p></li>
+ *   <li><p>Mid level: Custom-make the list of {@link QrSegment segments}
+ *     and call {@link QrCode#encodeSegments(List,Ecc)} or
+ *     {@link QrCode#encodeSegments(List,Ecc,int,int,int,boolean)}</p></li>
+ *   <li><p>Low level: Custom-make the array of data codeword bytes (including segment headers and
+ *     final padding, excluding error correction codewords), supply the appropriate version number,
+ *     and call the {@link QrCode#QrCode(int,Ecc,byte[],int) constructor}.</p></li>
+ * </ul>
+ * <p>(Note that all ways require supplying the desired error correction level.)</p>
+ * @see QrSegment
+ */
+public final class QrCode {
+	
+	/*---- Static factory functions (high level) ----*/
+	
+	/**
+	 * Returns a QR Code representing the specified Unicode text string at the specified error correction level.
+	 * As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
+	 * Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
+	 * QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
+	 * ecl argument if it can be done without increasing the version.
+	 * @param text the text to be encoded (not {@code null}), which can be any Unicode string
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @return a QR Code (not {@code null}) representing the text
+	 * @throws NullPointerException if the text or error correction level is {@code null}
+	 * @throws DataTooLongException if the text fails to fit in the
+	 * largest version QR Code at the ECL, which means it is too long
+	 */
+	public static QrCode encodeText(String text, Ecc ecl) {
+		Objects.requireNonNull(text);
+		Objects.requireNonNull(ecl);
+		List<QrSegment> segs = QrSegment.makeSegments(text);
+		return encodeSegments(segs, ecl);
+	}
+	
+	
+	/**
+	 * Returns a QR Code representing the specified binary data at the specified error correction level.
+	 * This function always encodes using the binary segment mode, not any text mode. The maximum number of
+	 * bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+	 * The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
+	 * @param data the binary data to encode (not {@code null})
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @return a QR Code (not {@code null}) representing the data
+	 * @throws NullPointerException if the data or error correction level is {@code null}
+	 * @throws DataTooLongException if the data fails to fit in the
+	 * largest version QR Code at the ECL, which means it is too long
+	 */
+	public static QrCode encodeBinary(byte[] data, Ecc ecl) {
+		Objects.requireNonNull(data);
+		Objects.requireNonNull(ecl);
+		QrSegment seg = QrSegment.makeBytes(data);
+		return encodeSegments(Arrays.asList(seg), ecl);
+	}
+	
+	
+	/*---- Static factory functions (mid level) ----*/
+	
+	/**
+	 * Returns a QR Code representing the specified segments at the specified error correction
+	 * level. The smallest possible QR Code version is automatically chosen for the output. The ECC level
+	 * of the result may be higher than the ecl argument if it can be done without increasing the version.
+	 * <p>This function allows the user to create a custom sequence of segments that switches
+	 * between modes (such as alphanumeric and byte) to encode text in less space.
+	 * This is a mid-level API; the high-level API is {@link #encodeText(String,Ecc)}
+	 * and {@link #encodeBinary(byte[],Ecc)}.</p>
+	 * @param segs the segments to encode
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @return a QR Code (not {@code null}) representing the segments
+	 * @throws NullPointerException if the list of segments, any segment, or the error correction level is {@code null}
+	 * @throws DataTooLongException if the segments fail to fit in the
+	 * largest version QR Code at the ECL, which means they are too long
+	 */
+	public static QrCode encodeSegments(List<QrSegment> segs, Ecc ecl) {
+		return encodeSegments(segs, ecl, MIN_VERSION, MAX_VERSION, -1, true);
+	}
+	
+	
+	/**
+	 * Returns a QR Code representing the specified segments with the specified encoding parameters.
+	 * The smallest possible QR Code version within the specified range is automatically
+	 * chosen for the output. Iff boostEcl is {@code true}, then the ECC level of the
+	 * result may be higher than the ecl argument if it can be done without increasing
+	 * the version. The mask number is either between 0 to 7 (inclusive) to force that
+	 * mask, or &#x2212;1 to automatically choose an appropriate mask (which may be slow).
+	 * <p>This function allows the user to create a custom sequence of segments that switches
+	 * between modes (such as alphanumeric and byte) to encode text in less space.
+	 * This is a mid-level API; the high-level API is {@link #encodeText(String,Ecc)}
+	 * and {@link #encodeBinary(byte[],Ecc)}.</p>
+	 * @param segs the segments to encode
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @param minVersion the minimum allowed version of the QR Code (at least 1)
+	 * @param maxVersion the maximum allowed version of the QR Code (at most 40)
+	 * @param mask the mask number to use (between 0 and 7 (inclusive)), or &#x2212;1 for automatic mask
+	 * @param boostEcl increases the ECC level as long as it doesn't increase the version number
+	 * @return a QR Code (not {@code null}) representing the segments
+	 * @throws NullPointerException if the list of segments, any segment, or the error correction level is {@code null}
+	 * @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40
+	 * or &#x2212;1 &#x2264; mask &#x2264; 7 is violated
+	 * @throws DataTooLongException if the segments fail to fit in
+	 * the maxVersion QR Code at the ECL, which means they are too long
+	 */
+	public static QrCode encodeSegments(List<QrSegment> segs, Ecc ecl, int minVersion, int maxVersion, int mask, boolean boostEcl) {
+		Objects.requireNonNull(segs);
+		Objects.requireNonNull(ecl);
+		if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7)
+			throw new IllegalArgumentException("Invalid value");
+		
+		// Find the minimal version number to use
+		int version, dataUsedBits;
+		for (version = minVersion; ; version++) {
+			int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;  // Number of data bits available
+			dataUsedBits = QrSegment.getTotalBits(segs, version);
+			if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
+				break;  // This version number is found to be suitable
+			if (version >= maxVersion) {  // All versions in the range could not fit the given data
+				String msg = "Segment too long";
+				if (dataUsedBits != -1)
+					msg = String.format("Data length = %d bits, Max capacity = %d bits", dataUsedBits, dataCapacityBits);
+				throw new DataTooLongException(msg);
+			}
+		}
+		assert dataUsedBits != -1;
+		
+		// Increase the error correction level while the data still fits in the current version number
+		for (Ecc newEcl : Ecc.values()) {  // From low to high
+			if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8)
+				ecl = newEcl;
+		}
+		
+		// Concatenate all segments to create the data bit string
+		BitBuffer bb = new BitBuffer();
+		for (QrSegment seg : segs) {
+			bb.appendBits(seg.mode.modeBits, 4);
+			bb.appendBits(seg.numChars, seg.mode.numCharCountBits(version));
+			bb.appendBits(seg.data, seg.bitLength);
+		}
+		assert bb.bitLength == dataUsedBits;
+		
+		// Add terminator and pad up to a byte if applicable
+		int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
+		assert bb.bitLength <= dataCapacityBits;
+		bb.appendBits(0, Math.min(4, dataCapacityBits - bb.bitLength));
+		bb.appendBits(0, (8 - bb.bitLength % 8) % 8);
+		assert bb.bitLength % 8 == 0;
+		
+		// Pad with alternating bytes until data capacity is reached
+		for (int padByte = 0xEC; bb.bitLength < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
+			bb.appendBits(padByte, 8);
+		
+		// Create the QR Code object
+		return new QrCode(version, ecl, bb.getBytes(), mask);
+	}
+	
+	
+	
+	/*---- Instance fields ----*/
+	
+	// Public immutable scalar parameters:
+	
+	/** The version number of this QR Code, which is between 1 and 40 (inclusive).
+	 * This determines the size of this barcode. */
+	public final int version;
+	
+	/** The width and height of this QR Code, measured in modules, between
+	 * 21 and 177 (inclusive). This is equal to version &#xD7; 4 + 17. */
+	public final int size;
+	
+	/** The error correction level used in this QR Code, which is not {@code null}. */
+	public final Ecc errorCorrectionLevel;
+	
+	/** The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+	 * <p>Even if a QR Code is created with automatic masking requested (mask =
+	 * &#x2212;1), the resulting object still has a mask value between 0 and 7. */
+	public final int mask;
+	
+	// Private grid of modules of this QR Code, packed tightly into bits.
+	// Immutable after constructor finishes. Accessed through getModule().
+	private final int[] modules;
+	
+	
+	
+	/*---- Constructor (low level) ----*/
+	
+	/**
+	 * Constructs a QR Code with the specified version number,
+	 * error correction level, data codeword bytes, and mask number.
+	 * <p>This is a low-level API that most users should not use directly. A mid-level
+	 * API is the {@link #encodeSegments(List,Ecc,int,int,int,boolean)} function.</p>
+	 * @param ver the version number to use, which must be in the range 1 to 40 (inclusive)
+	 * @param ecl the error correction level to use
+	 * @param dataCodewords the bytes representing segments to encode (without ECC)
+	 * @param msk the mask pattern to use, which is either &#x2212;1 for automatic choice or from 0 to 7 for fixed choice
+	 * @throws NullPointerException if the byte array or error correction level is {@code null}
+	 * @throws IllegalArgumentException if the version or mask value is out of range,
+	 * or if the data is the wrong length for the specified version and error correction level
+	 */
+	public QrCode(int ver, Ecc ecl, byte[] dataCodewords, int msk) {
+		// Check arguments and initialize fields
+		if (ver < MIN_VERSION || ver > MAX_VERSION)
+			throw new IllegalArgumentException("Version value out of range");
+		if (msk < -1 || msk > 7)
+			throw new IllegalArgumentException("Mask value out of range");
+		version = ver;
+		size = ver * 4 + 17;
+		errorCorrectionLevel = Objects.requireNonNull(ecl);
+		Objects.requireNonNull(dataCodewords);
+		
+		QrTemplate tpl = QrTemplate.MEMOIZER.get(ver);
+		modules = tpl.template.clone();
+		
+		// Compute ECC, draw modules, do masking
+		byte[] allCodewords = addEccAndInterleave(dataCodewords);
+		drawCodewords(tpl.dataOutputBitIndexes, allCodewords);
+		mask = handleConstructorMasking(tpl.masks, msk);
+	}
+	
+	
+	
+	/*---- Public instance methods ----*/
+	
+	/**
+	 * Returns the color of the module (pixel) at the specified coordinates, which is {@code false}
+	 * for light or {@code true} for dark. The top left corner has the coordinates (x=0, y=0).
+	 * If the specified coordinates are out of bounds, then {@code false} (light) is returned.
+	 * @param x the x coordinate, where 0 is the left edge and size&#x2212;1 is the right edge
+	 * @param y the y coordinate, where 0 is the top edge and size&#x2212;1 is the bottom edge
+	 * @return {@code true} if the coordinates are in bounds and the module
+	 * at that location is dark, or {@code false} (light) otherwise
+	 */
+	public boolean getModule(int x, int y) {
+		if (0 <= x && x < size && 0 <= y && y < size) {
+			int i = y * size + x;
+			return getBit(modules[i >>> 5], i) != 0;
+		} else
+			return false;
+	}
+	
+	
+	
+	/*---- Private helper methods for constructor: Drawing function modules ----*/
+	
+	// Draws two copies of the format bits (with its own error correction code)
+	// based on the given mask and this object's error correction level field.
+	private void drawFormatBits(int msk) {
+		// Calculate error correction code and pack bits
+		int data = errorCorrectionLevel.formatBits << 3 | msk;  // errCorrLvl is uint2, mask is uint3
+		int rem = data;
+		for (int i = 0; i < 10; i++)
+			rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+		int bits = (data << 10 | rem) ^ 0x5412;  // uint15
+		assert bits >>> 15 == 0;
+		
+		// Draw first copy
+		for (int i = 0; i <= 5; i++)
+			setModule(8, i, getBit(bits, i));
+		setModule(8, 7, getBit(bits, 6));
+		setModule(8, 8, getBit(bits, 7));
+		setModule(7, 8, getBit(bits, 8));
+		for (int i = 9; i < 15; i++)
+			setModule(14 - i, 8, getBit(bits, i));
+		
+		// Draw second copy
+		for (int i = 0; i < 8; i++)
+			setModule(size - 1 - i, 8, getBit(bits, i));
+		for (int i = 8; i < 15; i++)
+			setModule(8, size - 15 + i, getBit(bits, i));
+		setModule(8, size - 8, 1);  // Always dark
+	}
+	
+	
+	// Sets the module at the given coordinates to the given color.
+	// Only used by the constructor. Coordinates must be in bounds.
+	private void setModule(int x, int y, int dark) {
+		assert 0 <= x && x < size;
+		assert 0 <= y && y < size;
+		assert dark == 0 || dark == 1;
+		int i = y * size + x;
+		modules[i >>> 5] &= ~(1 << i);
+		modules[i >>> 5] |= dark << i;
+	}
+	
+	
+	/*---- Private helper methods for constructor: Codewords and masking ----*/
+	
+	// Returns a new byte string representing the given data with the appropriate error correction
+	// codewords appended to it, based on this object's version and error correction level.
+	private byte[] addEccAndInterleave(byte[] data) {
+		Objects.requireNonNull(data);
+		if (data.length != getNumDataCodewords(version, errorCorrectionLevel))
+			throw new IllegalArgumentException();
+		
+		// Calculate parameter numbers
+		int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[errorCorrectionLevel.ordinal()][version];
+		int blockEccLen = ECC_CODEWORDS_PER_BLOCK  [errorCorrectionLevel.ordinal()][version];
+		int rawCodewords = QrTemplate.getNumRawDataModules(version) / 8;
+		int numShortBlocks = numBlocks - rawCodewords % numBlocks;
+		int shortBlockDataLen = rawCodewords / numBlocks - blockEccLen;
+		
+		// Split data into blocks, calculate ECC, and interleave
+		// (not concatenate) the bytes into a single sequence
+		byte[] result = new byte[rawCodewords];
+		ReedSolomonGenerator rs = ReedSolomonGenerator.MEMOIZER.get(blockEccLen);
+		byte[] ecc = new byte[blockEccLen];  // Temporary storage per iteration
+		for (int i = 0, k = 0; i < numBlocks; i++) {
+			int datLen = shortBlockDataLen + (i < numShortBlocks ? 0 : 1);
+			rs.getRemainder(data, k, datLen, ecc);
+			for (int j = 0, l = i; j < datLen; j++, k++, l += numBlocks) {  // Copy data
+				if (j == shortBlockDataLen)
+					l -= numShortBlocks;
+				result[l] = data[k];
+			}
+			for (int j = 0, l = data.length + i; j < blockEccLen; j++, l += numBlocks)  // Copy ECC
+				result[l] = ecc[j];
+		}
+		return result;
+	}
+	
+	
+	// Draws the given sequence of 8-bit codewords (data and error correction)
+	// onto the entire data area of this QR Code, based on the given bit indexes.
+	private void drawCodewords(int[] dataOutputBitIndexes, byte[] allCodewords) {
+		Objects.requireNonNull(dataOutputBitIndexes);
+		Objects.requireNonNull(allCodewords);
+		if (allCodewords.length * 8 != dataOutputBitIndexes.length)
+			throw new IllegalArgumentException();
+		for (int i = 0; i < dataOutputBitIndexes.length; i++) {
+			int j = dataOutputBitIndexes[i];
+			int bit = getBit(allCodewords[i >>> 3], ~i & 7);
+			modules[j >>> 5] |= bit << j;
+		}
+	}
+	
+	
+	// XORs the codeword modules in this QR Code with the given mask pattern.
+	// The function modules must be marked and the codeword bits must be drawn
+	// before masking. Due to the arithmetic of XOR, calling applyMask() with
+	// the same mask value a second time will undo the mask. A final well-formed
+	// QR Code needs exactly one (not zero, two, etc.) mask applied.
+	private void applyMask(int[] msk) {
+		if (msk.length != modules.length)
+			throw new IllegalArgumentException();
+		for (int i = 0; i < msk.length; i++)
+			modules[i] ^= msk[i];
+	}
+	
+	
+	// A messy helper function for the constructor. This QR Code must be in an unmasked state when this
+	// method is called. The 'mask' argument is the requested mask, which is -1 for auto or 0 to 7 for fixed.
+	// This method applies and returns the actual mask chosen, from 0 to 7.
+	private int handleConstructorMasking(int[][] masks, int msk) {
+		if (msk == -1) {  // Automatically choose best mask
+			int minPenalty = Integer.MAX_VALUE;
+			for (int i = 0; i < 8; i++) {
+				applyMask(masks[i]);
+				drawFormatBits(i);
+				int penalty = getPenaltyScore();
+				if (penalty < minPenalty) {
+					msk = i;
+					minPenalty = penalty;
+				}
+				applyMask(masks[i]);  // Undoes the mask due to XOR
+			}
+		}
+		assert 0 <= msk && msk <= 7;
+		applyMask(masks[msk]);  // Apply the final choice of mask
+		drawFormatBits(msk);  // Overwrite old format bits
+		return msk;  // The caller shall assign this value to the final-declared field
+	}
+	
+	
+	// Calculates and returns the penalty score based on state of this QR Code's current modules.
+	// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+	private int getPenaltyScore() {
+		int result = 0;
+		int dark = 0;
+		int[] runHistory = new int[7];
+		
+		// Iterate over adjacent pairs of rows
+		for (int index = 0, downIndex = size, end = size * size; index < end; ) {
+			int runColor = 0;
+			int runX = 0;
+			Arrays.fill(runHistory, 0);
+			int curRow = 0;
+			int nextRow = 0;
+			for (int x = 0; x < size; x++, index++, downIndex++) {
+				int c = getBit(modules[index >>> 5], index);
+				if (c == runColor) {
+					runX++;
+					if (runX == 5)
+						result += PENALTY_N1;
+					else if (runX > 5)
+						result++;
+				} else {
+					finderPenaltyAddHistory(runX, runHistory);
+					if (runColor == 0)
+						result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+					runColor = c;
+					runX = 1;
+				}
+				dark += c;
+				if (downIndex < end) {
+					curRow = ((curRow << 1) | c) & 3;
+					nextRow = ((nextRow << 1) | getBit(modules[downIndex >>> 5], downIndex)) & 3;
+					// 2*2 blocks of modules having same color
+					if (x >= 1 && (curRow == 0 || curRow == 3) && curRow == nextRow)
+						result += PENALTY_N2;
+				}
+			}
+			result += finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
+		}
+		
+		// Iterate over single columns
+		for (int x = 0; x < size; x++) {
+			int runColor = 0;
+			int runY = 0;
+			Arrays.fill(runHistory, 0);
+			for (int y = 0, index = x; y < size; y++, index += size) {
+				int c = getBit(modules[index >>> 5], index);
+				if (c == runColor) {
+					runY++;
+					if (runY == 5)
+						result += PENALTY_N1;
+					else if (runY > 5)
+						result++;
+				} else {
+					finderPenaltyAddHistory(runY, runHistory);
+					if (runColor == 0)
+						result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+					runColor = c;
+					runY = 1;
+				}
+			}
+			result += finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
+		}
+		
+		// Balance of dark and light modules
+		int total = size * size;  // Note that size is odd, so dark/total != 1/2
+		// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+		int k = (Math.abs(dark * 20 - total * 10) + total - 1) / total - 1;
+		result += k * PENALTY_N4;
+		return result;
+	}
+	
+	
+	
+	/*---- Private helper functions ----*/
+	
+	// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+	// QR Code of the given version number and error correction level, with remainder bits discarded.
+	// This stateless pure function could be implemented as a (40*4)-cell lookup table.
+	static int getNumDataCodewords(int ver, Ecc ecl) {
+		return QrTemplate.getNumRawDataModules(ver) / 8
+			- ECC_CODEWORDS_PER_BLOCK    [ecl.ordinal()][ver]
+			* NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal()][ver];
+	}
+	
+	
+	// Can only be called immediately after a light run is added, and
+	// returns either 0, 1, or 2. A helper function for getPenaltyScore().
+	private int finderPenaltyCountPatterns(int[] runHistory) {
+		int n = runHistory[1];
+		assert n <= size * 3;
+		boolean core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
+		return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)
+		     + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
+	}
+	
+	
+	// Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+	private int finderPenaltyTerminateAndCount(int currentRunColor, int currentRunLength, int[] runHistory) {
+		if (currentRunColor == 1) {  // Terminate dark run
+			finderPenaltyAddHistory(currentRunLength, runHistory);
+			currentRunLength = 0;
+		}
+		currentRunLength += size;  // Add light border to final run
+		finderPenaltyAddHistory(currentRunLength, runHistory);
+		return finderPenaltyCountPatterns(runHistory);
+	}
+	
+	
+	// Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+	private void finderPenaltyAddHistory(int currentRunLength, int[] runHistory) {
+		if (runHistory[0] == 0)
+			currentRunLength += size;  // Add light border to initial run
+		System.arraycopy(runHistory, 0, runHistory, 1, runHistory.length - 1);
+		runHistory[0] = currentRunLength;
+	}
+	
+	
+	// Returns 0 or 1 based on the (i mod 32)'th bit of x.
+	static int getBit(int x, int i) {
+		return (x >>> i) & 1;
+	}
+	
+	
+	/*---- Constants and tables ----*/
+	
+	/** The minimum version number  (1) supported in the QR Code Model 2 standard. */
+	public static final int MIN_VERSION =  1;
+	
+	/** The maximum version number (40) supported in the QR Code Model 2 standard. */
+	public static final int MAX_VERSION = 40;
+	
+	
+	// For use in getPenaltyScore(), when evaluating which mask is best.
+	private static final int PENALTY_N1 =  3;
+	private static final int PENALTY_N2 =  3;
+	private static final int PENALTY_N3 = 40;
+	private static final int PENALTY_N4 = 10;
+	
+	
+	private static final byte[][] ECC_CODEWORDS_PER_BLOCK = {
+		// Version: (note that index 0 is for padding, and is set to an illegal value)
+		//0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+		{-1,  7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // Low
+		{-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28},  // Medium
+		{-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // Quartile
+		{-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // High
+	};
+	
+	private static final byte[][] NUM_ERROR_CORRECTION_BLOCKS = {
+		// Version: (note that index 0 is for padding, and is set to an illegal value)
+		//0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+		{-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4,  4,  4,  4,  4,  6,  6,  6,  6,  7,  8,  8,  9,  9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25},  // Low
+		{-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5,  5,  8,  9,  9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49},  // Medium
+		{-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8,  8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68},  // Quartile
+		{-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81},  // High
+	};
+	
+	
+	
+	/*---- Public helper enumeration ----*/
+	
+	/**
+	 * The error correction level in a QR Code symbol.
+	 */
+	public enum Ecc {
+		// Must be declared in ascending order of error protection
+		// so that the implicit ordinal() and values() work properly
+		/** The QR Code can tolerate about  7% erroneous codewords. */ LOW(1),
+		/** The QR Code can tolerate about 15% erroneous codewords. */ MEDIUM(0),
+		/** The QR Code can tolerate about 25% erroneous codewords. */ QUARTILE(3),
+		/** The QR Code can tolerate about 30% erroneous codewords. */ HIGH(2);
+		
+		// In the range 0 to 3 (unsigned 2-bit integer).
+		final int formatBits;
+		
+		// Constructor.
+		private Ecc(int fb) {
+			formatBits = fb;
+		}
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/QrCodeGeneratorDemo.java

@@ -0,0 +1,255 @@
+/* 
+ * Fast QR Code generator demo
+ * 
+ * Run this command-line program with no arguments. The program creates/overwrites a bunch of
+ * PNG and SVG files in the current working directory to demonstrate the creation of QR Codes.
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import javax.imageio.ImageIO;
+
+
+public final class QrCodeGeneratorDemo {
+	
+	// The main application program.
+	public static void main(String[] args) throws IOException {
+		doBasicDemo();
+		doVarietyDemo();
+		doSegmentDemo();
+		doMaskDemo();
+	}
+	
+	
+	
+	/*---- Demo suite ----*/
+	
+	// Creates a single QR Code, then writes it to a PNG file and an SVG file.
+	private static void doBasicDemo() throws IOException {
+		String text = "Hello, world!";          // User-supplied Unicode text
+		QrCode.Ecc errCorLvl = QrCode.Ecc.LOW;  // Error correction level
+		
+		QrCode qr = QrCode.encodeText(text, errCorLvl);  // Make the QR Code symbol
+		
+		BufferedImage img = toImage(qr, 10, 4);          // Convert to bitmap image
+		File imgFile = new File("hello-world-QR.png");   // File path for output
+		ImageIO.write(img, "png", imgFile);              // Write image to file
+		
+		String svg = toSvgString(qr, 4, "#FFFFFF", "#000000");  // Convert to SVG XML code
+		File svgFile = new File("hello-world-QR.svg");          // File path for output
+		Files.write(svgFile.toPath(),                           // Write image to file
+			svg.getBytes(StandardCharsets.UTF_8));
+	}
+	
+	
+	// Creates a variety of QR Codes that exercise different features of the library, and writes each one to file.
+	private static void doVarietyDemo() throws IOException {
+		QrCode qr;
+		
+		// Numeric mode encoding (3.33 bits per digit)
+		qr = QrCode.encodeText("314159265358979323846264338327950288419716939937510", QrCode.Ecc.MEDIUM);
+		writePng(toImage(qr, 13, 1), "pi-digits-QR.png");
+		
+		// Alphanumeric mode encoding (5.5 bits per character)
+		qr = QrCode.encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCode.Ecc.HIGH);
+		writePng(toImage(qr, 10, 2), "alphanumeric-QR.png");
+		
+		// Unicode text as UTF-8
+		qr = QrCode.encodeText("こんにちwa、世界！ αβγδ", QrCode.Ecc.QUARTILE);
+		writePng(toImage(qr, 10, 3), "unicode-QR.png");
+		
+		// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+		qr = QrCode.encodeText(
+			"Alice was beginning to get very tired of sitting by her sister on the bank, "
+			+ "and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
+			+ "but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
+			+ "'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
+			+ "for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
+			+ "daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
+			+ "a White Rabbit with pink eyes ran close by her.", QrCode.Ecc.HIGH);
+		writePng(toImage(qr, 6, 10), "alice-wonderland-QR.png");
+	}
+	
+	
+	// Creates QR Codes with manually specified segments for better compactness.
+	private static void doSegmentDemo() throws IOException {
+		QrCode qr;
+		List<QrSegment> segs;
+		
+		// Illustration "silver"
+		String silver0 = "THE SQUARE ROOT OF 2 IS 1.";
+		String silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
+		qr = QrCode.encodeText(silver0 + silver1, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 10, 3), "sqrt2-monolithic-QR.png");
+		
+		segs = Arrays.asList(
+			QrSegment.makeAlphanumeric(silver0),
+			QrSegment.makeNumeric(silver1));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 10, 3), "sqrt2-segmented-QR.png");
+		
+		// Illustration "golden"
+		String golden0 = "Golden ratio φ = 1.";
+		String golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+		String golden2 = "......";
+		qr = QrCode.encodeText(golden0 + golden1 + golden2, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 8, 5), "phi-monolithic-QR.png");
+		
+		segs = Arrays.asList(
+			QrSegment.makeBytes(golden0.getBytes(StandardCharsets.UTF_8)),
+			QrSegment.makeNumeric(golden1),
+			QrSegment.makeAlphanumeric(golden2));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 8, 5), "phi-segmented-QR.png");
+		
+		// Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+		String madoka = "「魔法少女まどか☆マギカ」って、　ИАИ　ｄｅｓｕ　κα？";
+		qr = QrCode.encodeText(madoka, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 9, 4, 0xFFFFE0, 0x303080), "madoka-utf8-QR.png");
+		
+		segs = Arrays.asList(QrSegmentAdvanced.makeKanji(madoka));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 9, 4, 0xE0F0FF, 0x404040), "madoka-kanji-QR.png");
+	}
+	
+	
+	// Creates QR Codes with the same size and contents but different mask patterns.
+	private static void doMaskDemo() throws IOException {
+		QrCode qr;
+		List<QrSegment> segs;
+		
+		// Project Nayuki URL
+		segs = QrSegment.makeSegments("https://www.nayuki.io/");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -1, true);  // Automatic mask
+		writePng(toImage(qr, 8, 6, 0xE0FFE0, 0x206020), "project-nayuki-automask-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 3, true);  // Force mask 3
+		writePng(toImage(qr, 8, 6, 0xFFE0E0, 0x602020), "project-nayuki-mask3-QR.png");
+		
+		// Chinese text as UTF-8
+		segs = QrSegment.makeSegments("維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 0, true);  // Force mask 0
+		writePng(toImage(qr, 10, 3), "unicode-mask0-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 1, true);  // Force mask 1
+		writePng(toImage(qr, 10, 3), "unicode-mask1-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 5, true);  // Force mask 5
+		writePng(toImage(qr, 10, 3), "unicode-mask5-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 7, true);  // Force mask 7
+		writePng(toImage(qr, 10, 3), "unicode-mask7-QR.png");
+	}
+	
+	
+	
+	/*---- Utilities ----*/
+	
+	private static BufferedImage toImage(QrCode qr, int scale, int border) {
+		return toImage(qr, scale, border, 0xFFFFFF, 0x000000);
+	}
+	
+	
+	/**
+	 * Returns a raster image depicting the specified QR Code, with
+	 * the specified module scale, border modules, and module colors.
+	 * <p>For example, scale=10 and border=4 means to pad the QR Code with 4 light border
+	 * modules on all four sides, and use 10&#xD7;10 pixels to represent each module.
+	 * @param qr the QR Code to render (not {@code null})
+	 * @param scale the side length (measured in pixels, must be positive) of each module
+	 * @param border the number of border modules to add, which must be non-negative
+	 * @param lightColor the color to use for light modules, in 0xRRGGBB format
+	 * @param darkColor the color to use for dark modules, in 0xRRGGBB format
+	 * @return a new image representing the QR Code, with padding and scaling
+	 * @throws NullPointerException if the QR Code is {@code null}
+	 * @throws IllegalArgumentException if the scale or border is out of range, or if
+	 * {scale, border, size} cause the image dimensions to exceed Integer.MAX_VALUE
+	 */
+	private static BufferedImage toImage(QrCode qr, int scale, int border, int lightColor, int darkColor) {
+		Objects.requireNonNull(qr);
+		if (scale <= 0 || border < 0)
+			throw new IllegalArgumentException("Value out of range");
+		if (border > Integer.MAX_VALUE / 2 || qr.size + border * 2L > Integer.MAX_VALUE / scale)
+			throw new IllegalArgumentException("Scale or border too large");
+		
+		BufferedImage result = new BufferedImage((qr.size + border * 2) * scale, (qr.size + border * 2) * scale, BufferedImage.TYPE_INT_RGB);
+		for (int y = 0; y < result.getHeight(); y++) {
+			for (int x = 0; x < result.getWidth(); x++) {
+				boolean color = qr.getModule(x / scale - border, y / scale - border);
+				result.setRGB(x, y, color ? darkColor : lightColor);
+			}
+		}
+		return result;
+	}
+	
+	
+	// Helper function to reduce code duplication.
+	private static void writePng(BufferedImage img, String filepath) throws IOException {
+		ImageIO.write(img, "png", new File(filepath));
+	}
+	
+	
+	/**
+	 * Returns a string of SVG code for an image depicting the specified QR Code, with the specified
+	 * number of border modules. The string always uses Unix newlines (\n), regardless of the platform.
+	 * @param qr the QR Code to render (not {@code null})
+	 * @param border the number of border modules to add, which must be non-negative
+	 * @param lightColor the color to use for light modules, in any format supported by CSS, not {@code null}
+	 * @param darkColor the color to use for dark modules, in any format supported by CSS, not {@code null}
+	 * @return a string representing the QR Code as an SVG XML document
+	 * @throws NullPointerException if any object is {@code null}
+	 * @throws IllegalArgumentException if the border is negative
+	 */
+	private static String toSvgString(QrCode qr, int border, String lightColor, String darkColor) {
+		Objects.requireNonNull(qr);
+		Objects.requireNonNull(lightColor);
+		Objects.requireNonNull(darkColor);
+		if (border < 0)
+			throw new IllegalArgumentException("Border must be non-negative");
+		long brd = border;
+		StringBuilder sb = new StringBuilder()
+			.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+			.append("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
+			.append(String.format("<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 %1$d %1$d\" stroke=\"none\">\n",
+				qr.size + brd * 2))
+			.append("\t<rect width=\"100%\" height=\"100%\" fill=\"" + lightColor + "\"/>\n")
+			.append("\t<path d=\"");
+		for (int y = 0; y < qr.size; y++) {
+			for (int x = 0; x < qr.size; x++) {
+				if (qr.getModule(x, y)) {
+					if (x != 0 || y != 0)
+						sb.append(" ");
+					sb.append(String.format("M%d,%dh1v1h-1z", x + brd, y + brd));
+				}
+			}
+		}
+		return sb
+			.append("\" fill=\"" + darkColor + "\"/>\n")
+			.append("</svg>\n")
+			.toString();
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/QrSegment.java

@@ -0,0 +1,338 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+
+/**
+ * A segment of character/binary/control data in a QR Code symbol.
+ * Instances of this class are immutable.
+ * <p>The mid-level way to create a segment is to take the payload data and call a
+ * static factory function such as {@link QrSegment#makeNumeric(String)}. The low-level
+ * way to create a segment is to custom-make the bit buffer and call the {@link
+ * QrSegment#QrSegment(Mode,int,int[],int) constructor} with appropriate values.</p>
+ * <p>This segment class imposes no length restrictions, but QR Codes have restrictions.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * This class can represent kanji mode segments, but provides no help in encoding them
+ * - see {@link QrSegmentAdvanced} for full kanji support.</p>
+ */
+public final class QrSegment {
+	
+	/*---- Static factory functions (mid level) ----*/
+	
+	/**
+	 * Returns a segment representing the specified binary data
+	 * encoded in byte mode. All input byte arrays are acceptable.
+	 * <p>Any text string can be converted to UTF-8 bytes ({@code
+	 * s.getBytes(StandardCharsets.UTF_8)}) and encoded as a byte mode segment.</p>
+	 * @param data the binary data (not {@code null})
+	 * @return a segment (not {@code null}) containing the data
+	 * @throws NullPointerException if the array is {@code null}
+	 */
+	public static QrSegment makeBytes(byte[] data) {
+		Objects.requireNonNull(data);
+		if (data.length * 8L > Integer.MAX_VALUE)
+			throw new IllegalArgumentException("Data too long");
+		int[] bits = new int[(data.length + 3) / 4];
+		for (int i = 0; i < data.length; i++)
+			bits[i >>> 2] |= (data[i] & 0xFF) << (~i << 3);
+		return new QrSegment(Mode.BYTE, data.length, bits, data.length * 8);
+	}
+	
+	
+	/**
+	 * Returns a segment representing the specified string of decimal digits encoded in numeric mode.
+	 * @param digits the text (not {@code null}), with only digits from 0 to 9 allowed
+	 * @return a segment (not {@code null}) containing the text
+	 * @throws NullPointerException if the string is {@code null}
+	 * @throws IllegalArgumentException if the string contains non-digit characters
+	 */
+	public static QrSegment makeNumeric(String digits) {
+		Objects.requireNonNull(digits);
+		BitBuffer bb = new BitBuffer();
+		int accumData = 0;
+		int accumCount = 0;
+		for (int i = 0; i < digits.length(); i++) {
+			char c = digits.charAt(i);
+			if (c < '0' || c > '9')
+				throw new IllegalArgumentException("String contains non-numeric characters");
+			accumData = accumData * 10 + (c - '0');
+			accumCount++;
+			if (accumCount == 3) {
+				bb.appendBits(accumData, 10);
+				accumData = 0;
+				accumCount = 0;
+			}
+		}
+		if (accumCount > 0)  // 1 or 2 digits remaining
+			bb.appendBits(accumData, accumCount * 3 + 1);
+		return new QrSegment(Mode.NUMERIC, digits.length(), bb.data, bb.bitLength);
+	}
+	
+	
+	/**
+	 * Returns a segment representing the specified text string encoded in alphanumeric mode.
+	 * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+	 * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	 * @param text the text (not {@code null}), with only certain characters allowed
+	 * @return a segment (not {@code null}) containing the text
+	 * @throws NullPointerException if the string is {@code null}
+	 * @throws IllegalArgumentException if the string contains non-encodable characters
+	 */
+	public static QrSegment makeAlphanumeric(String text) {
+		Objects.requireNonNull(text);
+		BitBuffer bb = new BitBuffer();
+		int accumData = 0;
+		int accumCount = 0;
+		for (int i = 0; i < text.length(); i++) {
+			char c = text.charAt(i);
+			if (c >= ALPHANUMERIC_MAP.length || ALPHANUMERIC_MAP[c] == -1)
+				throw new IllegalArgumentException("String contains unencodable characters in alphanumeric mode");
+			accumData = accumData * 45 + ALPHANUMERIC_MAP[c];
+			accumCount++;
+			if (accumCount == 2) {
+				bb.appendBits(accumData, 11);
+				accumData = 0;
+				accumCount = 0;
+			}
+		}
+		if (accumCount > 0)  // 1 character remaining
+			bb.appendBits(accumData, 6);
+		return new QrSegment(Mode.ALPHANUMERIC, text.length(), bb.data, bb.bitLength);
+	}
+	
+	
+	/**
+	 * Returns a list of zero or more segments to represent the specified Unicode text string.
+	 * The result may use various segment modes and switch modes to optimize the length of the bit stream.
+	 * @param text the text to be encoded, which can be any Unicode string
+	 * @return a new mutable list (not {@code null}) of segments (not {@code null}) containing the text
+	 * @throws NullPointerException if the text is {@code null}
+	 */
+	public static List<QrSegment> makeSegments(String text) {
+		Objects.requireNonNull(text);
+		
+		// Select the most efficient segment encoding automatically
+		List<QrSegment> result = new ArrayList<>();
+		if (text.equals(""));  // Leave result empty
+		else if (isNumeric(text))
+			result.add(makeNumeric(text));
+		else if (isAlphanumeric(text))
+			result.add(makeAlphanumeric(text));
+		else
+			result.add(makeBytes(text.getBytes(StandardCharsets.UTF_8)));
+		return result;
+	}
+	
+	
+	/**
+	 * Returns a segment representing an Extended Channel Interpretation
+	 * (ECI) designator with the specified assignment value.
+	 * @param assignVal the ECI assignment number (see the AIM ECI specification)
+	 * @return a segment (not {@code null}) containing the data
+	 * @throws IllegalArgumentException if the value is outside the range [0, 10<sup>6</sup>)
+	 */
+	public static QrSegment makeEci(int assignVal) {
+		BitBuffer bb = new BitBuffer();
+		if (assignVal < 0)
+			throw new IllegalArgumentException("ECI assignment value out of range");
+		else if (assignVal < (1 << 7))
+			bb.appendBits(assignVal, 8);
+		else if (assignVal < (1 << 14)) {
+			bb.appendBits(2, 2);
+			bb.appendBits(assignVal, 14);
+		} else if (assignVal < 1_000_000) {
+			bb.appendBits(6, 3);
+			bb.appendBits(assignVal, 21);
+		} else
+			throw new IllegalArgumentException("ECI assignment value out of range");
+		return new QrSegment(Mode.ECI, 0, bb.data, bb.bitLength);
+	}
+	
+	
+	/**
+	 * Tests whether the specified string can be encoded as a segment in numeric mode.
+	 * A string is encodable iff each character is in the range 0 to 9.
+	 * @param text the string to test for encodability (not {@code null})
+	 * @return {@code true} iff each character is in the range 0 to 9.
+	 * @throws NullPointerException if the string is {@code null}
+	 * @see #makeNumeric(String)
+	 */
+	public static boolean isNumeric(String text) {
+		for (int i = 0; i < text.length(); i++) {
+			char c = text.charAt(i);
+			if (c < '0' || c > '9')
+				return false;
+		}
+		return true;
+	}
+	
+	
+	/**
+	 * Tests whether the specified string can be encoded as a segment in alphanumeric mode.
+	 * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+	 * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	 * @param text the string to test for encodability (not {@code null})
+	 * @return {@code true} iff each character is in the alphanumeric mode character set
+	 * @throws NullPointerException if the string is {@code null}
+	 * @see #makeAlphanumeric(String)
+	 */
+	public static boolean isAlphanumeric(String text) {
+		for (int i = 0; i < text.length(); i++) {
+			char c = text.charAt(i);
+			if (c >= ALPHANUMERIC_MAP.length || ALPHANUMERIC_MAP[c] == -1)
+				return false;
+		}
+		return true;
+	}
+	
+	
+	
+	/*---- Instance fields ----*/
+	
+	/** The mode indicator of this segment. Not {@code null}. */
+	public final Mode mode;
+	
+	/** The length of this segment's unencoded data. Measured in characters for
+	 * numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	 * Always zero or positive. Not the same as the data's bit length. */
+	public final int numChars;
+	
+	// The data bits of this segment. Not null.
+	final int[] data;
+	
+	// Requires 0 <= bitLength <= data.length * 32.
+	final int bitLength;
+	
+	
+	/*---- Constructor (low level) ----*/
+	
+	/**
+	 * Constructs a QR Code segment with the specified attributes and data.
+	 * The character count (numCh) must agree with the mode and the bit buffer length,
+	 * but the constraint isn't checked. The specified bit buffer is cloned and stored.
+	 * @param md the mode (not {@code null})
+	 * @param numCh the data length in characters or bytes, which is non-negative
+	 * @param data the data bits (not {@code null})
+	 * @param bitLen the number of valid prefix bits in the data array
+	 * @throws NullPointerException if the mode or data is {@code null}
+	 * @throws IllegalArgumentException if the character count is negative
+	 */
+	public QrSegment(Mode md, int numCh, int[] data, int bitLen) {
+		mode = Objects.requireNonNull(md);
+		this.data = Objects.requireNonNull(data);
+		if (numCh < 0 || bitLen < 0 || bitLen > data.length * 32L)
+			throw new IllegalArgumentException("Invalid value");
+		numChars = numCh;
+		bitLength = bitLen;
+	}
+	
+	
+	// Calculates the number of bits needed to encode the given segments at the given version.
+	// Returns a non-negative number if successful. Otherwise returns -1 if a segment has too
+	// many characters to fit its length field, or the total bits exceeds Integer.MAX_VALUE.
+	static int getTotalBits(List<QrSegment> segs, int version) {
+		Objects.requireNonNull(segs);
+		long result = 0;
+		for (QrSegment seg : segs) {
+			Objects.requireNonNull(seg);
+			int ccbits = seg.mode.numCharCountBits(version);
+			if (seg.numChars >= (1 << ccbits))
+				return -1;  // The segment's length doesn't fit the field's bit width
+			result += 4L + ccbits + seg.bitLength;
+			if (result > Integer.MAX_VALUE)
+				return -1;  // The sum will overflow an int type
+		}
+		return (int)result;
+	}
+	
+	
+	/*---- Constants ----*/
+	
+	static final int[] ALPHANUMERIC_MAP;
+	
+	static {
+		final String ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+		int maxCh = -1;
+		for (int i = 0; i < ALPHANUMERIC_CHARSET.length(); i++)
+			maxCh = Math.max(ALPHANUMERIC_CHARSET.charAt(i), maxCh);
+		ALPHANUMERIC_MAP = new int[maxCh + 1];
+		Arrays.fill(ALPHANUMERIC_MAP, -1);
+		for (int i = 0; i < ALPHANUMERIC_CHARSET.length(); i++)
+			ALPHANUMERIC_MAP[ALPHANUMERIC_CHARSET.charAt(i)] = i;
+	}
+	
+	
+	
+	/*---- Public helper enumeration ----*/
+	
+	/**
+	 * Describes how a segment's data bits are interpreted.
+	 */
+	public enum Mode {
+		
+		/*-- Constants --*/
+		
+		NUMERIC     (0x1, 10, 12, 14),
+		ALPHANUMERIC(0x2,  9, 11, 13),
+		BYTE        (0x4,  8, 16, 16),
+		KANJI       (0x8,  8, 10, 12),
+		ECI         (0x7,  0,  0,  0);
+		
+		
+		/*-- Fields --*/
+		
+		// The mode indicator bits, which is a uint4 value (range 0 to 15).
+		final int modeBits;
+		
+		// Number of character count bits for three different version ranges.
+		private final int[] numBitsCharCount;
+		
+		
+		/*-- Constructor --*/
+		
+		private Mode(int mode, int... ccbits) {
+			modeBits = mode;
+			numBitsCharCount = ccbits;
+		}
+		
+		
+		/*-- Method --*/
+		
+		// Returns the bit width of the character count field for a segment in this mode
+		// in a QR Code at the given version number. The result is in the range [0, 16].
+		int numCharCountBits(int ver) {
+			assert QrCode.MIN_VERSION <= ver && ver <= QrCode.MAX_VERSION;
+			return numBitsCharCount[(ver + 7) / 17];
+		}
+		
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/QrSegmentAdvanced.java

@@ -0,0 +1,424 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.List;
+import java.util.Objects;
+import io.nayuki.fastqrcodegen.QrSegment.Mode;
+
+
+/**
+ * Splits text into optimal segments and encodes kanji segments.
+ * Provides static functions only; not instantiable.
+ * @see QrSegment
+ * @see QrCode
+ */
+public final class QrSegmentAdvanced {
+	
+	/*---- Optimal list of segments encoder ----*/
+	
+	/**
+	 * Returns a list of zero or more segments to represent the specified Unicode text string.
+	 * The resulting list optimally minimizes the total encoded bit length, subjected to the constraints
+	 * in the specified {error correction level, minimum version number, maximum version number}.
+	 * <p>This function can utilize all four text encoding modes: numeric, alphanumeric, byte (UTF-8),
+	 * and kanji. This can be considered as a sophisticated but slower replacement for {@link
+	 * QrSegment#makeSegments(String)}. This requires more input parameters because it searches a
+	 * range of versions, like {@link QrCode#encodeSegments(List,QrCode.Ecc,int,int,int,boolean)}.</p>
+	 * @param text the text to be encoded (not {@code null}), which can be any Unicode string
+	 * @param ecl the error correction level to use (not {@code null})
+	 * @param minVersion the minimum allowed version of the QR Code (at least 1)
+	 * @param maxVersion the maximum allowed version of the QR Code (at most 40)
+	 * @return a new mutable list (not {@code null}) of segments (not {@code null})
+	 * containing the text, minimizing the bit length with respect to the constraints
+	 * @throws NullPointerException if the text or error correction level is {@code null}
+	 * @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40 is violated
+	 * @throws DataTooLongException if the text fails to fit in the maxVersion QR Code at the ECL
+	 */
+	public static List<QrSegment> makeSegmentsOptimally(String text, QrCode.Ecc ecl, int minVersion, int maxVersion) {
+		// Check arguments
+		Objects.requireNonNull(text);
+		Objects.requireNonNull(ecl);
+		if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION))
+			throw new IllegalArgumentException("Invalid value");
+		
+		// Iterate through version numbers, and make tentative segments
+		List<QrSegment> segs = null;
+		int[] codePoints = toCodePoints(text);
+		for (int version = minVersion; ; version++) {
+			if (version == minVersion || version == 10 || version == 27)
+				segs = makeSegmentsOptimally(codePoints, version);
+			assert segs != null;
+			
+			// Check if the segments fit
+			int dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8;  // Number of data bits available
+			int dataUsedBits = QrSegment.getTotalBits(segs, version);
+			if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
+				return segs;  // This version number is found to be suitable
+			if (version >= maxVersion) {  // All versions in the range could not fit the given text
+				String msg = "Segment too long";
+				if (dataUsedBits != -1)
+					msg = String.format("Data length = %d bits, Max capacity = %d bits", dataUsedBits, dataCapacityBits);
+				throw new DataTooLongException(msg);
+			}
+		}
+	}
+	
+	
+	// Returns a new list of segments that is optimal for the given text at the given version number.
+	private static List<QrSegment> makeSegmentsOptimally(int[] codePoints, int version) {
+		if (codePoints.length == 0)
+			return new ArrayList<>();
+		Mode[] charModes = computeCharacterModes(codePoints, version);
+		return splitIntoSegments(codePoints, charModes);
+	}
+	
+	
+	// Returns a new array representing the optimal mode per code point based on the given text and version.
+	private static Mode[] computeCharacterModes(int[] codePoints, int version) {
+		if (codePoints.length == 0)
+			throw new IllegalArgumentException();
+		final Mode[] modeTypes = {Mode.BYTE, Mode.ALPHANUMERIC, Mode.NUMERIC, Mode.KANJI};  // Do not modify
+		final int numModes = modeTypes.length;
+		
+		// Segment header sizes, measured in 1/6 bits
+		final int[] headCosts = new int[numModes];
+		for (int i = 0; i < numModes; i++)
+			headCosts[i] = (4 + modeTypes[i].numCharCountBits(version)) * 6;
+		
+		// charModes[i][j] represents the mode to encode the code point at
+		// index i such that the final segment ends in modeTypes[j] and the
+		// total number of bits is minimized over all possible choices
+		Mode[][] charModes = new Mode[codePoints.length][numModes];
+		
+		// At the beginning of each iteration of the loop below,
+		// prevCosts[j] is the exact minimum number of 1/6 bits needed to
+		// encode the entire string prefix of length i, and end in modeTypes[j]
+		int[] prevCosts = headCosts.clone();
+		
+		// Calculate costs using dynamic programming
+		for (int i = 0; i < codePoints.length; i++) {
+			int c = codePoints[i];
+			int[] curCosts = new int[numModes];
+			{  // Always extend a byte mode segment
+				curCosts[0] = prevCosts[0] + countUtf8Bytes(c) * 8 * 6;
+				charModes[i][0] = modeTypes[0];
+			}
+			// Extend a segment if possible
+			if (QrSegment.ALPHANUMERIC_MAP[c] != -1) {  // Is alphanumeric
+				curCosts[1] = prevCosts[1] + 33;  // 5.5 bits per alphanumeric char
+				charModes[i][1] = modeTypes[1];
+			}
+			if ('0' <= c && c <= '9') {  // Is numeric
+				curCosts[2] = prevCosts[2] + 20;  // 3.33 bits per digit
+				charModes[i][2] = modeTypes[2];
+			}
+			if (isKanji(c)) {
+				curCosts[3] = prevCosts[3] + 78;  // 13 bits per Shift JIS char
+				charModes[i][3] = modeTypes[3];
+			}
+			
+			// Start new segment at the end to switch modes
+			for (int j = 0; j < numModes; j++) {  // To mode
+				for (int k = 0; k < numModes; k++) {  // From mode
+					int newCost = (curCosts[k] + 5) / 6 * 6 + headCosts[j];
+					if (charModes[i][k] != null && (charModes[i][j] == null || newCost < curCosts[j])) {
+						curCosts[j] = newCost;
+						charModes[i][j] = modeTypes[k];
+					}
+				}
+			}
+			
+			prevCosts = curCosts;
+		}
+		
+		// Find optimal ending mode
+		Mode curMode = null;
+		for (int i = 0, minCost = 0; i < numModes; i++) {
+			if (curMode == null || prevCosts[i] < minCost) {
+				minCost = prevCosts[i];
+				curMode = modeTypes[i];
+			}
+		}
+		
+		// Get optimal mode for each code point by tracing backwards
+		Mode[] result = new Mode[charModes.length];
+		for (int i = result.length - 1; i >= 0; i--) {
+			for (int j = 0; j < numModes; j++) {
+				if (modeTypes[j] == curMode) {
+					curMode = charModes[i][j];
+					result[i] = curMode;
+					break;
+				}
+			}
+		}
+		return result;
+	}
+	
+	
+	// Returns a new list of segments based on the given text and modes, such that
+	// consecutive code points in the same mode are put into the same segment.
+	private static List<QrSegment> splitIntoSegments(int[] codePoints, Mode[] charModes) {
+		if (codePoints.length == 0)
+			throw new IllegalArgumentException();
+		List<QrSegment> result = new ArrayList<>();
+		
+		// Accumulate run of modes
+		Mode curMode = charModes[0];
+		int start = 0;
+		for (int i = 1; ; i++) {
+			if (i < codePoints.length && charModes[i] == curMode)
+				continue;
+			String s = new String(codePoints, start, i - start);
+			if (curMode == Mode.BYTE)
+				result.add(QrSegment.makeBytes(s.getBytes(StandardCharsets.UTF_8)));
+			else if (curMode == Mode.NUMERIC)
+				result.add(QrSegment.makeNumeric(s));
+			else if (curMode == Mode.ALPHANUMERIC)
+				result.add(QrSegment.makeAlphanumeric(s));
+			else if (curMode == Mode.KANJI)
+				result.add(makeKanji(s));
+			else
+				throw new AssertionError();
+			if (i >= codePoints.length)
+				return result;
+			curMode = charModes[i];
+			start = i;
+		}
+	}
+	
+	
+	// Returns a new array of Unicode code points (effectively
+	// UTF-32 / UCS-4) representing the given UTF-16 string.
+	private static int[] toCodePoints(String s) {
+		int[] result = s.codePoints().toArray();
+		for (int c : result) {
+			if (Character.isSurrogate((char)c))
+				throw new IllegalArgumentException("Invalid UTF-16 string");
+		}
+		return result;
+	}
+	
+	
+	// Returns the number of UTF-8 bytes needed to encode the given Unicode code point.
+	private static int countUtf8Bytes(int cp) {
+		if      (cp <        0) throw new IllegalArgumentException("Invalid code point");
+		else if (cp <     0x80) return 1;
+		else if (cp <    0x800) return 2;
+		else if (cp <  0x10000) return 3;
+		else if (cp < 0x110000) return 4;
+		else                    throw new IllegalArgumentException("Invalid code point");
+	}
+	
+	
+	
+	/*---- Kanji mode segment encoder ----*/
+	
+	/**
+	 * Returns a segment representing the specified text string encoded in kanji mode.
+	 * Broadly speaking, the set of encodable characters are {kanji used in Japan,
+	 * hiragana, katakana, East Asian punctuation, full-width ASCII, Greek, Cyrillic}.
+	 * Examples of non-encodable characters include {ordinary ASCII, half-width katakana,
+	 * more extensive Chinese hanzi}.
+	 * @param text the text (not {@code null}), with only certain characters allowed
+	 * @return a segment (not {@code null}) containing the text
+	 * @throws NullPointerException if the string is {@code null}
+	 * @throws IllegalArgumentException if the string contains non-encodable characters
+	 * @see #isEncodableAsKanji(String)
+	 */
+	public static QrSegment makeKanji(String text) {
+		Objects.requireNonNull(text);
+		BitBuffer bb = new BitBuffer();
+		text.chars().forEachOrdered(c -> {
+			int val = UNICODE_TO_QR_KANJI[c];
+			if (val == -1)
+				throw new IllegalArgumentException("String contains non-kanji-mode characters");
+			bb.appendBits(val, 13);
+		});
+		return new QrSegment(Mode.KANJI, text.length(), bb.data, bb.bitLength);
+	}
+	
+	
+	/**
+	 * Tests whether the specified string can be encoded as a segment in kanji mode.
+	 * Broadly speaking, the set of encodable characters are {kanji used in Japan,
+	 * hiragana, katakana, East Asian punctuation, full-width ASCII, Greek, Cyrillic}.
+	 * Examples of non-encodable characters include {ordinary ASCII, half-width katakana,
+	 * more extensive Chinese hanzi}.
+	 * @param text the string to test for encodability (not {@code null})
+	 * @return {@code true} iff each character is in the kanji mode character set
+	 * @throws NullPointerException if the string is {@code null}
+	 * @see #makeKanji(String)
+	 */
+	public static boolean isEncodableAsKanji(String text) {
+		Objects.requireNonNull(text);
+		return text.chars().allMatch(
+			c -> isKanji((char)c));
+	}
+	
+	
+	private static boolean isKanji(int c) {
+		return c < UNICODE_TO_QR_KANJI.length && UNICODE_TO_QR_KANJI[c] != -1;
+	}
+	
+	
+	// Data derived from ftp://ftp.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/SHIFTJIS.TXT
+	private static final String PACKED_QR_KANJI_TO_UNICODE =
+		"MAAwATAC/wz/DjD7/xr/G/8f/wEwmzCcALT/QACo/z7/4/8/MP0w/jCdMJ4wA07dMAUwBjAHMPwgFSAQ/w8AXDAcIBb/XCAmICUgGCAZIBwgHf8I/wkwFDAV/zv/Pf9b/10wCDAJMAowCzAMMA0wDjAPMBAwEf8LIhIAsQDX//8A9/8dImD/HP8eImYiZyIeIjQmQiZA" +
+		"ALAgMiAzIQP/5f8EAKIAo/8F/wP/Bv8K/yAApyYGJgUlyyXPJc4lxyXGJaEloCWzJbIlvSW8IDswEiGSIZAhkSGTMBP/////////////////////////////IggiCyKGIocigiKDIioiKf////////////////////8iJyIoAKwh0iHUIgAiA///////////////////" +
+		"//////////8iICKlIxIiAiIHImEiUiJqImsiGiI9Ih0iNSIrIiz//////////////////yErIDAmbyZtJmogICAhALb//////////yXv/////////////////////////////////////////////////xD/Ef8S/xP/FP8V/xb/F/8Y/xn///////////////////8h" +
+		"/yL/I/8k/yX/Jv8n/yj/Kf8q/yv/LP8t/y7/L/8w/zH/Mv8z/zT/Nf82/zf/OP85/zr///////////////////9B/0L/Q/9E/0X/Rv9H/0j/Sf9K/0v/TP9N/07/T/9Q/1H/Uv9T/1T/Vf9W/1f/WP9Z/1r//////////zBBMEIwQzBEMEUwRjBHMEgwSTBKMEswTDBN" +
+		"ME4wTzBQMFEwUjBTMFQwVTBWMFcwWDBZMFowWzBcMF0wXjBfMGAwYTBiMGMwZDBlMGYwZzBoMGkwajBrMGwwbTBuMG8wcDBxMHIwczB0MHUwdjB3MHgweTB6MHswfDB9MH4wfzCAMIEwgjCDMIQwhTCGMIcwiDCJMIowizCMMI0wjjCPMJAwkTCSMJP/////////////" +
+		"////////////////////////MKEwojCjMKQwpTCmMKcwqDCpMKowqzCsMK0wrjCvMLAwsTCyMLMwtDC1MLYwtzC4MLkwujC7MLwwvTC+ML8wwDDBMMIwwzDEMMUwxjDHMMgwyTDKMMswzDDNMM4wzzDQMNEw0jDTMNQw1TDWMNcw2DDZMNow2zDcMN0w3jDf//8w4DDh" +
+		"MOIw4zDkMOUw5jDnMOgw6TDqMOsw7DDtMO4w7zDwMPEw8jDzMPQw9TD2/////////////////////wORA5IDkwOUA5UDlgOXA5gDmQOaA5sDnAOdA54DnwOgA6EDowOkA6UDpgOnA6gDqf////////////////////8DsQOyA7MDtAO1A7YDtwO4A7kDugO7A7wDvQO+" +
+		"A78DwAPBA8MDxAPFA8YDxwPIA8n/////////////////////////////////////////////////////////////////////////////////////////////////////////////BBAEEQQSBBMEFAQVBAEEFgQXBBgEGQQaBBsEHAQdBB4EHwQgBCEEIgQjBCQEJQQm" +
+		"BCcEKAQpBCoEKwQsBC0ELgQv////////////////////////////////////////BDAEMQQyBDMENAQ1BFEENgQ3BDgEOQQ6BDsEPAQ9//8EPgQ/BEAEQQRCBEMERARFBEYERwRIBEkESgRLBEwETQROBE///////////////////////////////////yUAJQIlDCUQ" +
+		"JRglFCUcJSwlJCU0JTwlASUDJQ8lEyUbJRclIyUzJSslOyVLJSAlLyUoJTclPyUdJTAlJSU4JUL/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"/////////////////////////////////////06cVRZaA5Y/VMBhG2MoWfaQIoR1gxx6UGCqY+FuJWXthGaCppv1aJNXJ2WhYnFbm1nQhnuY9H1ifb6bjmIWfJ+It1uJXrVjCWaXaEiVx5eNZ09O5U8KT01PnVBJVvJZN1nUWgFcCWDfYQ9hcGYTaQVwunVPdXB5+32t" +
+		"fe+Aw4QOiGOLApBVkHpTO06VTqVX34CykMF4704AWPFuopA4ejKDKIKLnC9RQVNwVL1U4VbgWftfFZjybeuA5IUt////////lmKWcJagl/tUC1PzW4dwz3+9j8KW6FNvnVx6uk4ReJOB/G4mVhhVBGsdhRqcO1nlU6ltZnTclY9WQk6RkEuW8oNPmQxT4VW2WzBfcWYg" +
+		"ZvNoBGw4bPNtKXRbdsh6Tpg0gvGIW4pgku1tsnWrdsqZxWCmiwGNipWyaY5TrVGG//9XElgwWURbtF72YChjqWP0bL9vFHCOcRRxWXHVcz9+AYJ2gtGFl5BgkludG1hpZbxsWnUlUflZLlllX4Bf3GK8ZfpqKmsna7Rzi3/BiVadLJ0OnsRcoWyWg3tRBFxLYbaBxmh2" +
+		"cmFOWU/6U3hgaW4pek+X804LUxZO7k9VTz1PoU9zUqBT71YJWQ9awVu2W+F50WaHZ5xntmtMbLNwa3PCeY15vno8e4eCsYLbgwSDd4Pvg9OHZoqyVimMqI/mkE6XHoaKT8Rc6GIRcll1O4Hlgr2G/ozAlsWZE5nVTstPGonjVt5YSljKXvtf62AqYJRgYmHQYhJi0GU5" +
+		"////////m0FmZmiwbXdwcHVMdoZ9dYKlh/mVi5aOjJ1R8VK+WRZUs1uzXRZhaGmCba94jYTLiFeKcpOnmrhtbJmohtlXo2f/hs6SDlKDVodUBF7TYuFkuWg8aDhru3NyeLp6a4maidKNa48DkO2Vo5aUl2lbZlyzaX2YTZhOY5t7IGor//9qf2i2nA1vX1JyVZ1gcGLs" +
+		"bTtuB27RhFuJEI9EThScOVP2aRtqOpeEaCpRXHrDhLKR3JOMVludKGgigwWEMXylUgiCxXTmTn5Pg1GgW9JSClLYUudd+1WaWCpZ5luMW5hb215yXnlgo2EfYWNhvmPbZWJn0WhTaPprPmtTbFdvIm+Xb0V0sHUYduN3C3r/e6F8IX3pfzZ/8ICdgmaDnomzisyMq5CE" +
+		"lFGVk5WRlaKWZZfTmSiCGE44VCtcuF3Mc6l2THc8XKl/640LlsGYEZhUmFhPAU8OU3FVnFZoV/pZR1sJW8RckF4MXn5fzGPuZzpl12XiZx9oy2jE////////al9eMGvFbBdsfXV/eUhbY3oAfQBfvYmPihiMtI13jsyPHZjimg6bPE6AUH1RAFmTW5xiL2KAZOxrOnKg" +
+		"dZF5R3+ph/uKvItwY6yDypegVAlUA1WraFRqWIpweCdndZ7NU3RbooEahlCQBk4YTkVOx08RU8pUOFuuXxNgJWVR//9nPWxCbHJs43B4dAN6dnquewh9Gnz+fWZl53JbU7tcRV3oYtJi4GMZbiCGWooxjd2S+G8BeaabWk6oTqtOrE+bT6BQ0VFHevZRcVH2U1RTIVN/" +
+		"U+tVrFiDXOFfN19KYC9gUGBtYx9lWWpLbMFywnLtd++A+IEFggiFTpD3k+GX/5lXmlpO8FHdXC1mgWltXEBm8ml1c4loUHyBUMVS5FdHXf6TJmWkayNrPXQ0eYF5vXtLfcqCuYPMiH+JX4s5j9GR0VQfkoBOXVA2U+VTOnLXc5Z36YLmjq+ZxpnImdJRd2Eahl5VsHp6" +
+		"UHZb05BHloVOMmrbkedcUVxI////////Y5h6n2yTl3SPYXqqcYqWiHyCaBd+cGhRk2xS8lQbhauKE3+kjs2Q4VNmiIh5QU/CUL5SEVFEVVNXLXPqV4tZUV9iX4RgdWF2YWdhqWOyZDplbGZvaEJuE3Vmej18+31MfZl+S39rgw6DSobNigiKY4tmjv2YGp2PgriPzpvo" +
+		"//9Sh2IfZINvwJaZaEFQkWsgbHpvVHp0fVCIQIojZwhO9lA5UCZQZVF8UjhSY1WnVw9YBVrMXvphsmH4YvNjcmkcailyfXKscy54FHhvfXl3DICpiYuLGYzijtKQY5N1lnqYVZoTnnhRQ1OfU7Nee18mbhtukHOEc/59Q4I3igCK+pZQTk5QC1PkVHxW+lnRW2Rd8V6r" +
+		"XydiOGVFZ69uVnLQfMqItIChgOGD8IZOioeN6JI3lseYZ58TTpROkk8NU0hUSVQ+Wi9fjF+hYJ9op2qOdFp4gYqeiqSLd5GQTl6byU6kT3xPr1AZUBZRSVFsUp9SuVL+U5pT41QR////////VA5ViVdRV6JZfVtUW11bj13lXedd9154XoNeml63XxhgUmFMYpdi2GOn" +
+		"ZTtmAmZDZvRnbWghaJdpy2xfbSptaW4vbp11MnaHeGx6P3zgfQV9GH1efbGAFYADgK+AsYFUgY+CKoNSiEyIYYsbjKKM/JDKkXWScXg/kvyVpJZN//+YBZmZmtidO1JbUqtT91QIWNVi92/gjGqPX565UUtSO1RKVv16QJF3nWCe0nNEbwmBcHURX/1g2pqoctuPvGtk" +
+		"mANOylbwV2RYvlpaYGhhx2YPZgZoOWixbfd11X06gm6bQk6bT1BTyVUGXW9d5l3uZ/tsmXRzeAKKUJOWiN9XUF6nYytQtVCsUY1nAFTJWF5Zu1uwX2liTWOhaD1rc24IcH2Rx3KAeBV4JnltZY59MIPciMGPCZabUmRXKGdQf2qMoVG0V0KWKlg6aYqAtFSyXQ5X/HiV" +
+		"nfpPXFJKVItkPmYoZxRn9XqEe1Z9IpMvaFybrXs5UxlRilI3////////W99i9mSuZOZnLWu6hamW0XaQm9ZjTJMGm6t2v2ZSTglQmFPCXHFg6GSSZWNoX3Hmc8p1I3uXfoKGlYuDjNuReJkQZaxmq2uLTtVO1E86T39SOlP4U/JV41bbWOtZy1nJWf9bUFxNXgJeK1/X" +
+		"YB1jB2UvW1xlr2W9ZehnnWti//9re2wPc0V5SXnBfPh9GX0rgKKBAoHziZaKXoppimaKjIrujMeM3JbMmPxrb06LTzxPjVFQW1db+mFIYwFmQmshbstsu3I+dL111HjBeTqADIAzgeqElI+ebFCef18Pi1idK3r6jvhbjZbrTgNT8Vf3WTFayVukYIluf28Gdb6M6luf" +
+		"hQB74FByZ/SCnVxhhUp+HoIOUZlcBGNojWZlnHFueT59F4AFix2OypBuhseQqlAfUvpcOmdTcHxyNZFMkciTK4LlW8JfMWD5TjtT1luIYktnMWuKculz4HougWuNo5FSmZZRElPXVGpb/2OIajl9rJcAVtpTzlRo////////W5dcMV3eT+5hAWL+bTJ5wHnLfUJ+TX/S" +
+		"ge2CH4SQiEaJcouQjnSPL5AxkUuRbJbGkZxOwE9PUUVTQV+TYg5n1GxBbgtzY34mkc2Sg1PUWRlbv23ReV1+LnybWH5xn1H6iFOP8E/KXPtmJXeseuOCHJn/UcZfqmXsaW9riW3z//9ulm9kdv59FF3hkHWRh5gGUeZSHWJAZpFm2W4aXrZ90n9yZviFr4X3ivhSqVPZ" +
+		"WXNej1+QYFWS5JZkULdRH1LdUyBTR1PsVOhVRlUxVhdZaFm+WjxbtVwGXA9cEVwaXoReil7gX3Bif2KEYttjjGN3ZgdmDGYtZnZnfmiiah9qNWy8bYhuCW5YcTxxJnFndcd3AXhdeQF5ZXnweuB7EXynfTmAloPWhIuFSYhdiPOKH4o8ilSKc4xhjN6RpJJmk36UGJac" +
+		"l5hOCk4ITh5OV1GXUnBXzlg0WMxbIl44YMVk/mdhZ1ZtRHK2dXN6Y4S4i3KRuJMgVjFX9Jj+////////Yu1pDWuWce1+VIB3gnKJ5pjfh1WPsVw7TzhP4U+1VQdaIFvdW+lfw2FOYy9lsGZLaO5pm214bfF1M3W5dx95XnnmfTOB44KvhaqJqoo6jquPm5Aykd2XB066" +
+		"TsFSA1h1WOxcC3UaXD2BTooKj8WWY5dteyWKz5gIkWJW81Oo//+QF1Q5V4JeJWOobDRwindhfIt/4IhwkEKRVJMQkxiWj3RemsRdB11pZXBnoo2olttjbmdJaRmDxZgXlsCI/m+EZHpb+E4WcCx1XWYvUcRSNlLiWdNfgWAnYhBlP2V0Zh9mdGjyaBZrY24FcnJ1H3bb" +
+		"fL6AVljwiP2Jf4qgipOKy5AdkZKXUpdZZYl6DoEGlrteLWDcYhplpWYUZ5B383pNfE1+PoEKjKyNZI3hjl94qVIHYtljpWRCYpiKLXqDe8CKrJbqfXaCDIdJTtlRSFNDU2Bbo1wCXBZd3WImYkdksGgTaDRsyW1FbRdn029ccU5xfWXLen97rX3a////////fkp/qIF6" +
+		"ghuCOYWmim6Mzo31kHiQd5KtkpGVg5uuUk1VhG84cTZRaHmFflWBs3zOVkxYUVyoY6pm/mb9aVpy2XWPdY55DnlWed98l30gfUSGB4o0ljuQYZ8gUOdSdVPMU+JQCVWqWO5ZT3I9W4tcZFMdYONg82NcY4NjP2O7//9kzWXpZvld42nNaf1vFXHlTol16Xb4epN8333P" +
+		"fZyAYYNJg1iEbIS8hfuIxY1wkAGQbZOXlxyaElDPWJdhjoHThTWNCJAgT8NQdFJHU3Ngb2NJZ19uLI2zkB9P11xejMplz32aU1KIllF2Y8NbWFtrXApkDWdRkFxO1lkaWSpscIpRVT5YFVmlYPBiU2fBgjVpVZZAmcSaKE9TWAZb/oAQXLFeL1+FYCBhS2I0Zv9s8G7e" +
+		"gM6Bf4LUiIuMuJAAkC6Wip7bm9tO41PwWSd7LJGNmEyd+W7dcCdTU1VEW4ViWGKeYtNsom/vdCKKF5Q4b8GK/oM4UeeG+FPq////////U+lPRpBUj7BZaoExXf166o+/aNqMN3L4nEhqPYqwTjlTWFYGV2ZixWOiZeZrTm3hbltwrXfteu97qn27gD2AxobLipWTW1bj" +
+		"WMdfPmWtZpZqgGu1dTeKx1Akd+VXMF8bYGVmemxgdfR6Gn9ugfSHGJBFmbN7yXVcevl7UYTE//+QEHnpepKDNlrhd0BOLU7yW5lf4GK9Zjxn8WzohmuId4o7kU6S85nQahdwJnMqgueEV4yvTgFRRlHLVYtb9V4WXjNegV8UXzVfa1+0YfJjEWaiZx1vbnJSdTp3OoB0" +
+		"gTmBeId2ir+K3I2FjfOSmpV3mAKc5VLFY1d29GcVbIhzzYzDk66Wc20lWJxpDmnMj/2TmnXbkBpYWmgCY7Rp+09Dbyxn2I+7hSZ9tJNUaT9vcFdqWPdbLH0scipUCpHjnbROrU9OUFxQdVJDjJ5USFgkW5peHV6VXq1e918fYIxitWM6Y9Bor2xAeId5jnoLfeCCR4oC" +
+		"iuaORJAT////////kLiRLZHYnw5s5WRYZOJldW70doR7G5Bpk9FuulTyX7lkpI9Nj+2SRFF4WGtZKVxVXpdt+36PdRyMvI7imFtwuU8da79vsXUwlvtRTlQQWDVYV1msXGBfkmWXZ1xuIXZ7g9+M7ZAUkP2TTXgleDpSql6mVx9ZdGASUBJRWlGs//9RzVIAVRBYVFhY" +
+		"WVdblVz2XYtgvGKVZC1ncWhDaLxo33bXbdhub22bcG9xyF9Tddh5d3tJe1R7UnzWfXFSMIRjhWmF5IoOiwSMRo4PkAOQD5QZlnaYLZowldhQzVLVVAxYAlwOYadknm0ed7N65YD0hASQU5KFXOCdB1M/X5dfs22ccnl3Y3m/e+Rr0nLsiq1oA2phUfh6gWk0XEqc9oLr" +
+		"W8WRSXAeVnhcb2DHZWZsjIxakEGYE1RRZseSDVlIkKNRhU5NUeqFmYsOcFhjepNLaWKZtH4EdXdTV2lgjt+W42xdToxcPF8Qj+lTAozRgImGeV7/ZeVOc1Fl////////WYJcP5fuTvtZil/Nio1v4XmweWJb54RxcytxsV50X/Vje2SaccN8mE5DXvxOS1fcVqJgqW/D" +
+		"fQ2A/YEzgb+PsomXhqRd9GKKZK2Jh2d3bOJtPnQ2eDRaRn91gq2ZrE/zXsNi3WOSZVdnb3bDckyAzIC6jymRTVANV/lakmiF//9pc3Fkcv2Mt1jyjOCWapAZh3955HfnhClPL1JlU1pizWfPbMp2fXuUfJWCNoWEj+tm3W8gcgZ+G4OrmcGeplH9e7F4cnu4gId7SGro" +
+		"XmGAjHVRdWBRa5Jibox2epGXmupPEH9wYpx7T5WlnOlWelhZhuSWvE80UiRTSlPNU9teBmQsZZFnf2w+bE5ySHKvc+11VH5BgiyF6Yype8SRxnFpmBKY72M9Zml1anbkeNCFQ4buUypTUVQmWYNeh198YLJiSWJ5YqtlkGvUbMx1snaueJF52H3Lf3eApYirirmMu5B/" +
+		"l16Y22oLfDhQmVw+X65nh2vYdDV3CX+O////////nztnynoXUzl1i5rtX2aBnYPxgJhfPF/FdWJ7RpA8aGdZ61qbfRB2fossT/VfamoZbDdvAnTieWiIaIpVjHle32PPdcV50oLXkyiS8oSchu2cLVTBX2xljG1ccBWMp4zTmDtlT3T2Tg1O2FfgWStaZlvMUaheA16c" +
+		"YBZidmV3//9lp2ZubW5yNnsmgVCBmoKZi1yMoIzmjXSWHJZET65kq2tmgh6EYYVqkOhcAWlTmKiEeoVXTw9Sb1+pXkVnDXmPgXmJB4mGbfVfF2JVbLhOz3Jpm5JSBlQ7VnRYs2GkYm5xGllufIl83n0blvBlh4BeThlPdVF1WEBeY15zXwpnxE4mhT2ViZZbfHOYAVD7" +
+		"WMF2VninUiV3pYURe4ZQT1kJckd7x33oj7qP1JBNT79SyVopXwGXrU/dgheS6lcDY1VraXUriNyPFHpCUt9Yk2FVYgpmrmvNfD+D6VAjT/hTBVRGWDFZSVudXPBc710pXpZisWNnZT5luWcL////////bNVs4XD5eDJ+K4DegrOEDITshwKJEooqjEqQppLSmP2c851s" +
+		"Tk9OoVCNUlZXSlmoXj1f2F/ZYj9mtGcbZ9Bo0lGSfSGAqoGoiwCMjIy/kn6WMlQgmCxTF1DVU1xYqGSyZzRyZ3dmekaR5lLDbKFrhlgAXkxZVGcsf/tR4XbG//9kaXjom1Seu1fLWblmJ2eaa85U6WnZXlWBnGeVm6pn/pxSaF1Opk/jU8hiuWcrbKuPxE+tfm2ev04H" +
+		"YWJugG8rhRNUc2cqm0Vd83uVXKxbxoccbkqE0XoUgQhZmXyNbBF3IFLZWSJxIXJfd9uXJ51haQtaf1oYUaVUDVR9Zg5234/3kpic9Fnqcl1uxVFNaMl9v33sl2KeumR4aiGDAlmEW19r23MbdvJ9soAXhJlRMmcontl27mdiUv+ZBVwkYjt8foywVU9gtn0LlYBTAU5f" +
+		"UbZZHHI6gDaRzl8ld+JThF95fQSFrIozjo2XVmfzha6UU2EJYQhsuXZS////////iu2POFUvT1FRKlLHU8tbpV59YKBhgmPWZwln2m5nbYxzNnM3dTF5UIjVipiQSpCRkPWWxIeNWRVOiE9ZTg6KiY8/mBBQrV58WZZbuV64Y9pj+mTBZtxpSmnYbQtutnGUdSh6r3+K" +
+		"gACESYTJiYGLIY4KkGWWfZkKYX5ikWsy//9sg210f8x//G3Af4WHuoj4Z2WDsZg8lvdtG31hhD2Rak5xU3VdUGsEb+uFzYYtiadSKVQPXGVnTmiodAZ0g3XiiM+I4ZHMluKWeF+Lc4d6y4ROY6B1ZVKJbUFunHQJdVl4a3ySloZ63J+NT7ZhbmXFhlxOhk6uUNpOIVHM" +
+		"W+5lmWiBbbxzH3ZCd616HHzngm+K0pB8kc+WdZgYUpt90VArU5hnl23LcdB0M4HojyqWo5xXnp90YFhBbZl9L5heTuRPNk+LUbdSsV26YBxzsnk8gtOSNJa3lvaXCp6Xn2Jmpmt0UhdSo3DIiMJeyWBLYZBvI3FJfD599IBv////////hO6QI5MsVEKbb2rTcImMwo3v" +
+		"lzJStFpBXspfBGcXaXxplG1qbw9yYnL8e+2AAYB+h0uQzlFtnpN5hICLkzKK1lAtVIyKcWtqjMSBB2DRZ6Cd8k6ZTpicEIprhcGFaGkAbn54l4FV////////////////////////////////////////////////////////////////////////////////////////" +
+		"/////////////////////////////18MThBOFU4qTjFONk48Tj9OQk5WTlhOgk6FjGtOioISXw1Ojk6eTp9OoE6iTrBOs062Ts5OzU7ETsZOwk7XTt5O7U7fTvdPCU9aTzBPW09dT1dPR092T4hPj0+YT3tPaU9wT5FPb0+GT5ZRGE/UT99Pzk/YT9tP0U/aT9BP5E/l" +
+		"UBpQKFAUUCpQJVAFTxxP9lAhUClQLE/+T+9QEVAGUENQR2cDUFVQUFBIUFpQVlBsUHhQgFCaUIVQtFCy////////UMlQylCzUMJQ1lDeUOVQ7VDjUO5Q+VD1UQlRAVECURZRFVEUURpRIVE6UTdRPFE7UT9RQFFSUUxRVFFievhRaVFqUW5RgFGCVthRjFGJUY9RkVGT" +
+		"UZVRllGkUaZRolGpUapRq1GzUbFRslGwUbVRvVHFUclR21HghlVR6VHt//9R8FH1Uf5SBFILUhRSDlInUipSLlIzUjlST1JEUktSTFJeUlRSalJ0UmlSc1J/Un1SjVKUUpJScVKIUpGPqI+nUqxSrVK8UrVSwVLNUtdS3lLjUuaY7VLgUvNS9VL4UvlTBlMIdThTDVMQ" +
+		"Uw9TFVMaUyNTL1MxUzNTOFNAU0ZTRU4XU0lTTVHWU15TaVNuWRhTe1N3U4JTllOgU6ZTpVOuU7BTtlPDfBKW2VPfZvxx7lPuU+hT7VP6VAFUPVRAVCxULVQ8VC5UNlQpVB1UTlSPVHVUjlRfVHFUd1RwVJJUe1SAVHZUhFSQVIZUx1SiVLhUpVSsVMRUyFSo////////" +
+		"VKtUwlSkVL5UvFTYVOVU5lUPVRRU/VTuVO1U+lTiVTlVQFVjVUxVLlVcVUVVVlVXVThVM1VdVZlVgFSvVYpVn1V7VX5VmFWeVa5VfFWDValVh1WoVdpVxVXfVcRV3FXkVdRWFFX3VhZV/lX9VhtV+VZOVlBx31Y0VjZWMlY4//9Wa1ZkVi9WbFZqVoZWgFaKVqBWlFaP" +
+		"VqVWrla2VrRWwla8VsFWw1bAVshWzlbRVtNW11buVvlXAFb/VwRXCVcIVwtXDVcTVxhXFlXHVxxXJlc3VzhXTlc7V0BXT1dpV8BXiFdhV39XiVeTV6BXs1ekV6pXsFfDV8ZX1FfSV9NYClfWV+NYC1gZWB1YclghWGJYS1hwa8BYUlg9WHlYhVi5WJ9Yq1i6WN5Yu1i4" +
+		"WK5YxVjTWNFY11jZWNhY5VjcWORY31jvWPpY+Vj7WPxY/VkCWQpZEFkbaKZZJVksWS1ZMlk4WT560llVWVBZTllaWVhZYllgWWdZbFlp////////WXhZgVmdT15Pq1mjWbJZxlnoWdxZjVnZWdpaJVofWhFaHFoJWhpaQFpsWklaNVo2WmJaalqaWrxavlrLWsJavVrj" +
+		"Wtda5lrpWtZa+lr7WwxbC1sWWzJa0FsqWzZbPltDW0VbQFtRW1VbWltbW2VbaVtwW3NbdVt4ZYhbeluA//9bg1umW7hbw1vHW8lb1FvQW+Rb5lviW95b5VvrW/Bb9lvzXAVcB1wIXA1cE1wgXCJcKFw4XDlcQVxGXE5cU1xQXE9bcVxsXG5OYlx2XHlcjFyRXJRZm1yr" +
+		"XLtctly8XLdcxVy+XMdc2VzpXP1c+lztXYxc6l0LXRVdF11cXR9dG10RXRRdIl0aXRldGF1MXVJdTl1LXWxdc112XYddhF2CXaJdnV2sXa5dvV2QXbddvF3JXc1d013SXdZd213rXfJd9V4LXhpeGV4RXhteNl43XkReQ15AXk5eV15UXl9eYl5kXkdedV52XnqevF5/" +
+		"XqBewV7CXshe0F7P////////XtZe417dXtpe217iXuFe6F7pXuxe8V7zXvBe9F74Xv5fA18JX11fXF8LXxFfFl8pXy1fOF9BX0hfTF9OXy9fUV9WX1dfWV9hX21fc193X4Nfgl9/X4pfiF+RX4dfnl+ZX5hfoF+oX61fvF/WX/tf5F/4X/Ff3WCzX/9gIWBg//9gGWAQ" +
+		"YClgDmAxYBtgFWArYCZgD2A6YFpgQWBqYHdgX2BKYEZgTWBjYENgZGBCYGxga2BZYIFgjWDnYINgmmCEYJtglmCXYJJgp2CLYOFguGDgYNNgtF/wYL1gxmC1YNhhTWEVYQZg9mD3YQBg9GD6YQNhIWD7YPFhDWEOYUdhPmEoYSdhSmE/YTxhLGE0YT1hQmFEYXNhd2FY" +
+		"YVlhWmFrYXRhb2FlYXFhX2FdYVNhdWGZYZZhh2GsYZRhmmGKYZFhq2GuYcxhymHJYfdhyGHDYcZhumHLf3lhzWHmYeNh9mH6YfRh/2H9Yfxh/mIAYghiCWINYgxiFGIb////////Yh5iIWIqYi5iMGIyYjNiQWJOYl5iY2JbYmBiaGJ8YoJiiWJ+YpJik2KWYtRig2KU" +
+		"Ytdi0WK7Ys9i/2LGZNRiyGLcYsxiymLCYsdim2LJYwxi7mLxYydjAmMIYu9i9WNQYz5jTWQcY09jlmOOY4Bjq2N2Y6Njj2OJY59jtWNr//9jaWO+Y+ljwGPGY+NjyWPSY/ZjxGQWZDRkBmQTZCZkNmUdZBdkKGQPZGdkb2R2ZE5lKmSVZJNkpWSpZIhkvGTaZNJkxWTH" +
+		"ZLtk2GTCZPFk54IJZOBk4WKsZONk72UsZPZk9GTyZPplAGT9ZRhlHGUFZSRlI2UrZTRlNWU3ZTZlOHVLZUhlVmVVZU1lWGVeZV1lcmV4ZYJlg4uKZZtln2WrZbdlw2XGZcFlxGXMZdJl22XZZeBl4WXxZ3JmCmYDZftnc2Y1ZjZmNGYcZk9mRGZJZkFmXmZdZmRmZ2Zo" +
+		"Zl9mYmZwZoNmiGaOZolmhGaYZp1mwWa5Zslmvma8////////ZsRmuGbWZtpm4GY/ZuZm6WbwZvVm92cPZxZnHmcmZyeXOGcuZz9nNmdBZzhnN2dGZ15nYGdZZ2NnZGeJZ3BnqWd8Z2pnjGeLZ6ZnoWeFZ7dn72e0Z+xns2fpZ7hn5GfeZ91n4mfuZ7lnzmfGZ+dqnGge" +
+		"aEZoKWhAaE1oMmhO//9os2graFloY2h3aH9on2iPaK1olGidaJtog2quaLlodGi1aKBoumkPaI1ofmkBaMppCGjYaSJpJmjhaQxozWjUaOdo1Wk2aRJpBGjXaONpJWj5aOBo72koaSppGmkjaSFoxml5aXdpXGl4aWtpVGl+aW5pOWl0aT1pWWkwaWFpXmldaYFpammy" +
+		"aa5p0Gm/acFp02m+ac5b6GnKad1pu2nDaadqLmmRaaBpnGmVabRp3mnoagJqG2n/awpp+WnyaedqBWmxah5p7WoUaetqCmoSasFqI2oTakRqDGpyajZqeGpHamJqWWpmakhqOGoiapBqjWqgaoRqomqj////////apeGF2q7asNqwmq4arNqrGreatFq32qqatpq6mr7" +
+		"awWGFmr6axJrFpsxax9rOGs3dtxrOZjua0drQ2tJa1BrWWtUa1trX2tha3hreWt/a4BrhGuDa41rmGuVa55rpGuqa6trr2uya7Frs2u3a7xrxmvLa9Nr32vsa+tr82vv//+evmwIbBNsFGwbbCRsI2xebFVsYmxqbIJsjWyabIFsm2x+bGhsc2ySbJBsxGzxbNNsvWzX" +
+		"bMVs3WyubLFsvmy6bNts72zZbOptH4hNbTZtK209bThtGW01bTNtEm0MbWNtk21kbVpteW1ZbY5tlW/kbYVt+W4VbgpttW3HbeZtuG3Gbext3m3Mbeht0m3Fbfpt2W3kbdVt6m3ubi1ubm4ubhlucm5fbj5uI25rbitudm5Nbh9uQ246bk5uJG7/bh1uOG6CbqpumG7J" +
+		"brdu0269bq9uxG6ybtRu1W6PbqVuwm6fb0FvEXBMbuxu+G7+bz9u8m8xbu9vMm7M////////bz5vE273b4Zvem94b4FvgG9vb1tv829tb4JvfG9Yb45vkW/Cb2Zvs2+jb6FvpG+5b8Zvqm/fb9Vv7G/Ub9hv8W/ub9twCXALb/pwEXABcA9v/nAbcBpvdHAdcBhwH3Aw" +
+		"cD5wMnBRcGNwmXCScK9w8XCscLhws3CucN9wy3Dd//9w2XEJcP1xHHEZcWVxVXGIcWZxYnFMcVZxbHGPcftxhHGVcahxrHHXcblxvnHScclx1HHOceBx7HHncfVx/HH5cf9yDXIQchtyKHItcixyMHIycjtyPHI/ckByRnJLclhydHJ+coJygXKHcpJylnKicqdyuXKy" +
+		"csNyxnLEcs5y0nLicuBy4XL5cvdQD3MXcwpzHHMWcx1zNHMvcylzJXM+c05zT57Yc1dzanNoc3BzeHN1c3tzenPIc7NzznO7c8Bz5XPuc950onQFdG90JXP4dDJ0OnRVdD90X3RZdEF0XHRpdHB0Y3RqdHZ0fnSLdJ50p3TKdM901HPx////////dOB043TndOl07nTy" +
+		"dPB08XT4dPd1BHUDdQV1DHUOdQ11FXUTdR51JnUsdTx1RHVNdUp1SXVbdUZ1WnVpdWR1Z3VrdW11eHV2dYZ1h3V0dYp1iXWCdZR1mnWddaV1o3XCdbN1w3W1db11uHW8dbF1zXXKddJ12XXjdd51/nX///91/HYBdfB1+nXydfN2C3YNdgl2H3YndiB2IXYidiR2NHYw" +
+		"djt2R3ZIdkZ2XHZYdmF2YnZodml2anZndmx2cHZydnZ2eHZ8doB2g3aIdot2jnaWdpN2mXaadrB2tHa4drl2unbCds121nbSdt524Xbldud26oYvdvt3CHcHdwR3KXckdx53JXcmdxt3N3c4d0d3Wndod2t3W3dld393fnd5d453i3eRd6B3nnewd7Z3uXe/d7x3vXe7" +
+		"d8d3zXfXd9p33Hfjd+53/HgMeBJ5JnggeSp4RXiOeHR4hnh8eJp4jHijeLV4qniveNF4xnjLeNR4vni8eMV4ynjs////////eOd42nj9ePR5B3kSeRF5GXkseSt5QHlgeVd5X3laeVV5U3l6eX95inmdeaefS3mqea55s3m5ebp5yXnVeed57HnheeN6CHoNehh6GXog" +
+		"eh95gHoxejt6Pno3ekN6V3pJemF6Ynppn516cHp5en16iHqXepV6mHqWeql6yHqw//96tnrFesR6v5CDesd6ynrNes961XrTetl62nrdeuF64nrmeu168HsCew97CnsGezN7GHsZex57NXsoezZ7UHt6ewR7TXsLe0x7RXt1e2V7dHtne3B7cXtse257nXuYe597jXuc" +
+		"e5p7i3uSe497XXuZe8t7wXvMe897tHvGe9176XwRfBR75nvlfGB8AHwHfBN783v3fBd8DXv2fCN8J3wqfB98N3wrfD18THxDfFR8T3xAfFB8WHxffGR8VnxlfGx8dXyDfJB8pHytfKJ8q3yhfKh8s3yyfLF8rny5fL18wHzFfMJ82HzSfNx84ps7fO988nz0fPZ8+n0G" +
+		"////////fQJ9HH0VfQp9RX1LfS59Mn0/fTV9Rn1zfVZ9Tn1yfWh9bn1PfWN9k32JfVt9j319fZt9un2ufaN9tX3Hfb19q349faJ9r33cfbh9n32wfdh93X3kfd59+33yfeF+BX4KfiN+IX4SfjF+H34Jfgt+In5GfmZ+O341fjl+Q343//9+Mn46fmd+XX5Wfl5+WX5a" +
+		"fnl+an5pfnx+e36DfdV+fY+ufn9+iH6Jfox+kn6QfpN+lH6Wfo5+m36cfzh/On9Ff0x/TX9Of1B/UX9Vf1R/WH9ff2B/aH9pf2d/eH+Cf4Z/g3+If4d/jH+Uf55/nX+af6N/r3+yf7l/rn+2f7iLcX/Ff8Z/yn/Vf9R/4X/mf+l/83/5mNyABoAEgAuAEoAYgBmAHIAh" +
+		"gCiAP4A7gEqARoBSgFiAWoBfgGKAaIBzgHKAcIB2gHmAfYB/gISAhoCFgJuAk4CagK1RkICsgNuA5YDZgN2AxIDagNaBCYDvgPGBG4EpgSOBL4FL////////louBRoE+gVOBUYD8gXGBboFlgWaBdIGDgYiBioGAgYKBoIGVgaSBo4FfgZOBqYGwgbWBvoG4gb2BwIHC" +
+		"gbqByYHNgdGB2YHYgciB2oHfgeCB54H6gfuB/oIBggKCBYIHggqCDYIQghaCKYIrgjiCM4JAglmCWIJdglqCX4Jk//+CYoJogmqCa4IugnGCd4J4gn6CjYKSgquCn4K7gqyC4YLjgt+C0oL0gvOC+oOTgwOC+4L5gt6DBoLcgwmC2YM1gzSDFoMygzGDQIM5g1CDRYMv" +
+		"gyuDF4MYg4WDmoOqg5+DooOWgyODjoOHg4qDfIO1g3ODdYOgg4mDqIP0hBOD64POg/2EA4PYhAuDwYP3hAeD4IPyhA2EIoQgg72EOIUGg/uEbYQqhDyFWoSEhHeEa4SthG6EgoRphEaELIRvhHmENYTKhGKEuYS/hJ+E2YTNhLuE2oTQhMGExoTWhKGFIYT/hPSFF4UY" +
+		"hSyFH4UVhRSE/IVAhWOFWIVI////////hUGGAoVLhVWFgIWkhYiFkYWKhaiFbYWUhZuF6oWHhZyFd4V+hZCFyYW6hc+FuYXQhdWF3YXlhdyF+YYKhhOGC4X+hfqGBoYihhqGMIY/hk1OVYZUhl+GZ4ZxhpOGo4aphqqGi4aMhraGr4bEhsaGsIbJiCOGq4bUht6G6Ybs" +
+		"//+G34bbhu+HEocGhwiHAIcDhvuHEYcJhw2G+YcKhzSHP4c3hzuHJYcphxqHYIdfh3iHTIdOh3SHV4doh26HWYdTh2OHaogFh6KHn4eCh6+Hy4e9h8CH0JbWh6uHxIezh8eHxoe7h++H8ofgiA+IDYf+h/aH94gOh9KIEYgWiBWIIoghiDGINog5iCeIO4hEiEKIUohZ" +
+		"iF6IYohriIGIfoieiHWIfYi1iHKIgoiXiJKIroiZiKKIjYikiLCIv4ixiMOIxIjUiNiI2YjdiPmJAoj8iPSI6IjyiQSJDIkKiROJQ4keiSWJKokriUGJRIk7iTaJOIlMiR2JYIle////////iWaJZIltiWqJb4l0iXeJfomDiYiJiomTiZiJoYmpiaaJrImvibKJuom9" +
+		"ib+JwInaidyJ3YnnifSJ+IoDihaKEIoMihuKHYolijaKQYpbilKKRopIinyKbYpsimKKhYqCioSKqIqhipGKpYqmipqKo4rEis2KworaiuuK84rn//+K5IrxixSK4IriiveK3orbiwyLB4saiuGLFosQixeLIIszl6uLJosriz6LKItBi0yLT4tOi0mLVotbi1qLa4tf" +
+		"i2yLb4t0i32LgIuMi46LkouTi5aLmYuajDqMQYw/jEiMTIxOjFCMVYxijGyMeIx6jIKMiYyFjIqMjYyOjJSMfIyYYh2MrYyqjL2MsoyzjK6MtozIjMGM5IzjjNqM/Yz6jPuNBI0FjQqNB40PjQ2NEJ9OjROMzY0UjRaNZ41tjXGNc42BjZmNwo2+jbqNz43ajdaNzI3b" +
+		"jcuN6o3rjd+N4438jgiOCY3/jh2OHo4Qjh+OQo41jjCONI5K////////jkeOSY5MjlCOSI5ZjmSOYI4qjmOOVY52jnKOfI6BjoeOhY6EjouOio6TjpGOlI6ZjqqOoY6sjrCOxo6xjr6OxY7IjsuO247jjvyO+47rjv6PCo8FjxWPEo8ZjxOPHI8fjxuPDI8mjzOPO485" +
+		"j0WPQo8+j0yPSY9Gj06PV49c//+PYo9jj2SPnI+fj6OPrY+vj7eP2o/lj+KP6o/vkIeP9JAFj/mP+pARkBWQIZANkB6QFpALkCeQNpA1kDmP+JBPkFCQUZBSkA6QSZA+kFaQWJBekGiQb5B2lqiQcpCCkH2QgZCAkIqQiZCPkKiQr5CxkLWQ4pDkYkiQ25ECkRKRGZEy" +
+		"kTCRSpFWkViRY5FlkWmRc5FykYuRiZGCkaKRq5GvkaqRtZG0kbqRwJHBkcmRy5HQkdaR35HhkduR/JH1kfaSHpH/khSSLJIVkhGSXpJXkkWSSZJkkkiSlZI/kkuSUJKckpaSk5KbklqSz5K5kreS6ZMPkvqTRJMu////////kxmTIpMakyOTOpM1kzuTXJNgk3yTbpNW" +
+		"k7CTrJOtk5STuZPWk9eT6JPlk9iTw5Pdk9CTyJPklBqUFJQTlAOUB5QQlDaUK5Q1lCGUOpRBlFKURJRblGCUYpRelGqSKZRwlHWUd5R9lFqUfJR+lIGUf5WClYeVipWUlZaVmJWZ//+VoJWolaeVrZW8lbuVuZW+lcpv9pXDlc2VzJXVldSV1pXcleGV5ZXiliGWKJYu" +
+		"li+WQpZMlk+WS5Z3llyWXpZdll+WZpZylmyWjZaYlpWWl5aqlqeWsZaylrCWtJa2lriWuZbOlsuWyZbNiU2W3JcNltWW+ZcElwaXCJcTlw6XEZcPlxaXGZcklyqXMJc5lz2XPpdEl0aXSJdCl0mXXJdgl2SXZpdoUtKXa5dxl3mXhZd8l4GXepeGl4uXj5eQl5yXqJem" +
+		"l6OXs5e0l8OXxpfIl8uX3Jftn0+X8nrfl/aX9ZgPmAyYOJgkmCGYN5g9mEaYT5hLmGuYb5hw////////mHGYdJhzmKqYr5ixmLaYxJjDmMaY6ZjrmQOZCZkSmRSZGJkhmR2ZHpkkmSCZLJkumT2ZPplCmUmZRZlQmUuZUZlSmUyZVZmXmZiZpZmtma6ZvJnfmduZ3ZnY" +
+		"mdGZ7ZnumfGZ8pn7mfiaAZoPmgWZ4poZmiuaN5pFmkKaQJpD//+aPppVmk2aW5pXml+aYpplmmSaaZprmmqarZqwmryawJrPmtGa05rUmt6a35rimuOa5prvmuua7pr0mvGa95r7mwabGJsamx+bIpsjmyWbJ5somymbKpsumy+bMptEm0ObT5tNm06bUZtYm3Sbk5uD" +
+		"m5GblpuXm5+boJuom7SbwJvKm7mbxpvPm9Gb0pvjm+Kb5JvUm+GcOpvym/Gb8JwVnBScCZwTnAycBpwInBKcCpwEnC6cG5wlnCScIZwwnEecMpxGnD6cWpxgnGecdpx4nOec7JzwnQmdCJzrnQOdBp0qnSadr50jnR+dRJ0VnRKdQZ0/nT6dRp1I////////nV2dXp1k" +
+		"nVGdUJ1ZnXKdiZ2Hnaudb516nZqdpJ2pnbKdxJ3BnbuduJ26ncadz53Cndmd0534nead7Z3vnf2eGp4bnh6edZ55nn2egZ6InouejJ6SnpWekZ6dnqWeqZ64nqqerZdhnsyezp7PntCe1J7cnt6e3Z7gnuWe6J7v//+e9J72nvee+Z77nvye/Z8Hnwh2t58VnyGfLJ8+" +
+		"n0qfUp9Un2OfX59gn2GfZp9nn2yfap93n3Kfdp+Vn5yfoFgvaceQWXRkUdxxmf//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"/////////////////////////////////////////////w==";
+	
+	
+	private static short[] UNICODE_TO_QR_KANJI = new short[1 << 16];
+	
+	static {  // Unpack the Shift JIS table into a more computation-friendly form
+		Arrays.fill(UNICODE_TO_QR_KANJI, (short)-1);
+		byte[] bytes = Base64.getDecoder().decode(PACKED_QR_KANJI_TO_UNICODE);
+		for (int i = 0; i < bytes.length; i += 2) {
+			char c = (char)(((bytes[i] & 0xFF) << 8) | (bytes[i + 1] & 0xFF));
+			if (c == 0xFFFF)
+				continue;
+			assert UNICODE_TO_QR_KANJI[c] == -1;
+			UNICODE_TO_QR_KANJI[c] = (short)(i / 2);
+		}
+	}
+	
+	
+	
+	/*---- Miscellaneous ----*/
+	
+	private QrSegmentAdvanced() {}  // Not instantiable
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/QrTemplate.java

@@ -0,0 +1,270 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+
+// Stores the parts of a QR Code that depend only on the version number,
+// and does not depend on the data or error correction level or mask.
+final class QrTemplate {
+	
+	// Use this memoizer to get instances of this class.
+	public static final Memoizer<Integer,QrTemplate> MEMOIZER
+		= new Memoizer<>(QrTemplate::new);
+	
+	
+	private final int version;  // In the range [1, 40].
+	private final int size;  // Derived from version.
+	
+	final int[] template;  // Length and values depend on version.
+	final int[][] masks;  // masks.length == 8, and masks[i].length == template.length.
+	final int[] dataOutputBitIndexes;  // Length and values depend on version.
+	
+	// Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+	// Otherwise when the constructor is running, isFunction.length == template.length.
+	private int[] isFunction;
+	
+	
+	// Creates a QR Code template for the given version number.
+	private QrTemplate(int ver) {
+		if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
+			throw new IllegalArgumentException("Version out of range");
+		version = ver;
+		size = version * 4 + 17;
+		template = new int[(size * size + 31) / 32];
+		isFunction = new int[template.length];
+		
+		drawFunctionPatterns();  // Reads and writes fields
+		masks = generateMasks();  // Reads fields, returns array
+		dataOutputBitIndexes = generateZigzagScan();  // Reads fields, returns array
+		isFunction = null;
+	}
+	
+	
+	// Reads this object's version field, and draws and marks all function modules.
+	private void drawFunctionPatterns() {
+		// Draw horizontal and vertical timing patterns
+		for (int i = 0; i < size; i++) {
+			darkenFunctionModule(6, i, ~i & 1);
+			darkenFunctionModule(i, 6, ~i & 1);
+		}
+		
+		// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
+		drawFinderPattern(3, 3);
+		drawFinderPattern(size - 4, 3);
+		drawFinderPattern(3, size - 4);
+		
+		// Draw numerous alignment patterns
+		int[] alignPatPos = getAlignmentPatternPositions();
+		int numAlign = alignPatPos.length;
+		for (int i = 0; i < numAlign; i++) {
+			for (int j = 0; j < numAlign; j++) {
+				// Don't draw on the three finder corners
+				if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0))
+					drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+			}
+		}
+		
+		// Draw configuration data
+		drawDummyFormatBits();
+		drawVersion();
+	}
+	
+	
+	// Draws two blank copies of the format bits.
+	private void drawDummyFormatBits() {
+		// Draw first copy
+		for (int i = 0; i <= 5; i++)
+			darkenFunctionModule(8, i, 0);
+		darkenFunctionModule(8, 7, 0);
+		darkenFunctionModule(8, 8, 0);
+		darkenFunctionModule(7, 8, 0);
+		for (int i = 9; i < 15; i++)
+			darkenFunctionModule(14 - i, 8, 0);
+		
+		// Draw second copy
+		for (int i = 0; i < 8; i++)
+			darkenFunctionModule(size - 1 - i, 8, 0);
+		for (int i = 8; i < 15; i++)
+			darkenFunctionModule(8, size - 15 + i, 0);
+		darkenFunctionModule(8, size - 8, 1);  // Always dark
+	}
+	
+	
+	// Draws two copies of the version bits (with its own error correction code),
+	// based on this object's version field, iff 7 <= version <= 40.
+	private void drawVersion() {
+		if (version < 7)
+			return;
+		
+		// Calculate error correction code and pack bits
+		int rem = version;  // version is uint6, in the range [7, 40]
+		for (int i = 0; i < 12; i++)
+			rem = (rem << 1) ^ ((rem >>> 11) * 0x1F25);
+		int bits = version << 12 | rem;  // uint18
+		assert bits >>> 18 == 0;
+		
+		// Draw two copies
+		for (int i = 0; i < 18; i++) {
+			int bit = QrCode.getBit(bits, i);
+			int a = size - 11 + i % 3;
+			int b = i / 3;
+			darkenFunctionModule(a, b, bit);
+			darkenFunctionModule(b, a, bit);
+		}
+	}
+	
+	
+	// Draws a 9*9 finder pattern including the border separator,
+	// with the center module at (x, y). Modules can be out of bounds.
+	private void drawFinderPattern(int x, int y) {
+		for (int dy = -4; dy <= 4; dy++) {
+			for (int dx = -4; dx <= 4; dx++) {
+				int dist = Math.max(Math.abs(dx), Math.abs(dy));  // Chebyshev/infinity norm
+				int xx = x + dx, yy = y + dy;
+				if (0 <= xx && xx < size && 0 <= yy && yy < size)
+					darkenFunctionModule(xx, yy, (dist != 2 && dist != 4) ? 1 : 0);
+			}
+		}
+	}
+	
+	
+	// Draws a 5*5 alignment pattern, with the center module
+	// at (x, y). All modules must be in bounds.
+	private void drawAlignmentPattern(int x, int y) {
+		for (int dy = -2; dy <= 2; dy++) {
+			for (int dx = -2; dx <= 2; dx++)
+				darkenFunctionModule(x + dx, y + dy, Math.abs(Math.max(Math.abs(dx), Math.abs(dy)) - 1));
+		}
+	}
+	
+	
+	// Computes and returns a new array of masks, based on this object's various fields.
+	private int[][] generateMasks() {
+		int[][] result = new int[8][template.length];
+		for (int mask = 0; mask < result.length; mask++) {
+			int[] maskModules = result[mask];
+			for (int y = 0, i = 0; y < size; y++) {
+				for (int x = 0; x < size; x++, i++) {
+					boolean invert;
+					switch (mask) {
+						case 0:  invert = (x + y) % 2 == 0;                    break;
+						case 1:  invert = y % 2 == 0;                          break;
+						case 2:  invert = x % 3 == 0;                          break;
+						case 3:  invert = (x + y) % 3 == 0;                    break;
+						case 4:  invert = (x / 3 + y / 2) % 2 == 0;            break;
+						case 5:  invert = x * y % 2 + x * y % 3 == 0;          break;
+						case 6:  invert = (x * y % 2 + x * y % 3) % 2 == 0;    break;
+						case 7:  invert = ((x + y) % 2 + x * y % 3) % 2 == 0;  break;
+						default:  throw new AssertionError();
+					}
+					int bit = (invert ? 1 : 0) & ~getModule(isFunction, x, y);
+					maskModules[i >>> 5] |= bit << i;
+				}
+			}
+		}
+		return result;
+	}
+	
+	
+	// Computes and returns an array of bit indexes, based on this object's various fields.
+	private int[] generateZigzagScan() {
+		int[] result = new int[getNumRawDataModules(version) / 8 * 8];
+		int i = 0;  // Bit index into the data
+		for (int right = size - 1; right >= 1; right -= 2) {  // Index of right column in each column pair
+			if (right == 6)
+				right = 5;
+			for (int vert = 0; vert < size; vert++) {  // Vertical counter
+				for (int j = 0; j < 2; j++) {
+					int x = right - j;  // Actual x coordinate
+					boolean upward = ((right + 1) & 2) == 0;
+					int y = upward ? size - 1 - vert : vert;  // Actual y coordinate
+					if (getModule(isFunction, x, y) == 0 && i < result.length) {
+						result[i] = y * size + x;
+						i++;
+					}
+				}
+			}
+		}
+		assert i == result.length;
+		return result;
+	}
+	
+	
+	// Returns the value of the bit at the given coordinates in the given grid.
+	private int getModule(int[] grid, int x, int y) {
+		assert 0 <= x && x < size;
+		assert 0 <= y && y < size;
+		int i = y * size + x;
+		return QrCode.getBit(grid[i >>> 5], i);
+	}
+	
+	
+	// Marks the module at the given coordinates as a function module.
+	// Also either sets that module dark or keeps its color unchanged.
+	private void darkenFunctionModule(int x, int y, int enable) {
+		assert 0 <= x && x < size;
+		assert 0 <= y && y < size;
+		assert enable == 0 || enable == 1;
+		int i = y * size + x;
+		template[i >>> 5] |= enable << i;
+		isFunction[i >>> 5] |= 1 << i;
+	}
+	
+	
+	// Returns an ascending list of positions of alignment patterns for this version number.
+	// Each position is in the range [0,177), and are used on both the x and y axes.
+	// This could be implemented as lookup table of 40 variable-length lists of unsigned bytes.
+	private int[] getAlignmentPatternPositions() {
+		if (version == 1)
+			return new int[]{};
+		else {
+			int numAlign = version / 7 + 2;
+			int step = (version == 32) ? 26 :
+				(version * 4 + numAlign * 2 + 1) / (numAlign * 2 - 2) * 2;
+			int[] result = new int[numAlign];
+			result[0] = 6;
+			for (int i = result.length - 1, pos = size - 7; i >= 1; i--, pos -= step)
+				result[i] = pos;
+			return result;
+		}
+	}
+	
+	
+	// Returns the number of data bits that can be stored in a QR Code of the given version number, after
+	// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+	// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
+	static int getNumRawDataModules(int ver) {
+		if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
+			throw new IllegalArgumentException("Version number out of range");
+		int result = (16 * ver + 128) * ver + 64;
+		if (ver >= 2) {
+			int numAlign = ver / 7 + 2;
+			result -= (25 * numAlign - 10) * numAlign - 55;
+			if (ver >= 7)
+				result -= 36;
+		}
+		return result;
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/ReedSolomonGenerator.java

@@ -0,0 +1,106 @@
+/* 
+ * Fast QR Code generator library
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/fast-qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.fastqrcodegen;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+
+// Computes Reed-Solomon error correction codewords for given data codewords.
+final class ReedSolomonGenerator {
+	
+	// Use this memoizer to get instances of this class.
+	public static final Memoizer<Integer,ReedSolomonGenerator> MEMOIZER
+		= new Memoizer<>(ReedSolomonGenerator::new);
+	
+	
+	// A table of size 256 * degree, where polynomialMultiply[i][j] = multiply(i, coefficients[j]).
+	// 'coefficients' is the temporary array computed in the constructor.
+	private byte[][] polynomialMultiply;
+	
+	
+	// Creates a Reed-Solomon ECC generator polynomial for the given degree.
+	private ReedSolomonGenerator(int degree) {
+		if (degree < 1 || degree > 255)
+			throw new IllegalArgumentException("Degree out of range");
+		
+		// The divisor polynomial, whose coefficients are stored from highest to lowest power.
+		// For example, x^3 + 255x^2 + 8x + 93 is stored as the uint8 array {255, 8, 93}.
+		byte[] coefficients = new byte[degree];
+		coefficients[degree - 1] = 1;  // Start off with the monomial x^0
+		
+		// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
+		// and drop the highest monomial term which is always 1x^degree.
+		// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
+		int root = 1;
+		for (int i = 0; i < degree; i++) {
+			// Multiply the current product by (x - r^i)
+			for (int j = 0; j < coefficients.length; j++) {
+				coefficients[j] = (byte)multiply(coefficients[j] & 0xFF, root);
+				if (j + 1 < coefficients.length)
+					coefficients[j] ^= coefficients[j + 1];
+			}
+			root = multiply(root, 0x02);
+		}
+		
+		polynomialMultiply = new byte[256][degree];
+		for (int i = 0; i < polynomialMultiply.length; i++) {
+			for (int j = 0; j < degree; j++)
+				polynomialMultiply[i][j] = (byte)multiply(i, coefficients[j] & 0xFF);
+		}
+	}
+	
+	
+	// Returns the error correction codeword for the given data polynomial and this divisor polynomial.
+	public void getRemainder(byte[] data, int dataOff, int dataLen, byte[] result) {
+		Objects.requireNonNull(data);
+		Objects.requireNonNull(result);
+		int degree = polynomialMultiply[0].length;
+		assert result.length == degree;
+		
+		Arrays.fill(result, (byte)0);
+		for (int i = dataOff, dataEnd = dataOff + dataLen; i < dataEnd; i++) {  // Polynomial division
+			byte[] table = polynomialMultiply[(data[i] ^ result[0]) & 0xFF];
+			for (int j = 0; j < degree - 1; j++)
+				result[j] = (byte)(result[j + 1] ^ table[j]);
+			result[degree - 1] = table[degree - 1];
+		}
+	}
+	
+	
+	// Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
+	// are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
+	private static int multiply(int x, int y) {
+		assert x >> 8 == 0 && y >> 8 == 0;
+		// Russian peasant multiplication
+		int z = 0;
+		for (int i = 7; i >= 0; i--) {
+			z = (z << 1) ^ ((z >>> 7) * 0x11D);
+			z ^= ((y >>> i) & 1) * x;
+		}
+		assert z >>> 8 == 0;
+		return z;
+	}
+	
+}

Telegram/ThirdParty/QR/java-fast/io/nayuki/fastqrcodegen/package-info.java

@@ -0,0 +1,52 @@
+/**
+ * Generates QR Codes from text strings and byte arrays.
+ * 
+ * <p>This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.</p>
+ * <p>Home page for this fast library with design explanation and benchmarks: <a href="https://www.nayuki.io/page/fast-qr-code-generator-library">https://www.nayuki.io/page/fast-qr-code-generator-library</a></p>
+ * <p>Home page for the main project with live JavaScript demo, extensive descriptions, and competitor comparisons: <a href="https://www.nayuki.io/page/qr-code-generator-library">https://www.nayuki.io/page/qr-code-generator-library</a></p>
+ * 
+ * <h2>Features</h2>
+ * <p>Core features:</p>
+ * <ul>
+ *   <li><p>Approximately 1.5× to 10× faster than other Java implementation</p></li>
+ *   <li><p>Shorter code but more documentation comments compared to competing libraries</p></li>
+ *   <li><p>Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard</p></li>
+ *   <li><p>Output format: Raw modules/pixels of the QR symbol</p></li>
+ *   <li><p>Detects finder-like penalty patterns more accurately than other implementations</p></li>
+ *   <li><p>Encodes numeric and special-alphanumeric text in less space than general text</p></li>
+ *   <li><p>Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes</p></li>
+ *   <li><p>Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts</p></li>
+ *   <li><p>Open-source code under the permissive MIT License</p></li>
+ * </ul>
+ * <p>Manual parameters:</p>
+ * <ul>
+ *   <li><p>User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data</p></li>
+ *   <li><p>User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one</p></li>
+ *   <li><p>User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number</p></li>
+ *   <li><p>User can create a list of data segments manually and add ECI segments</p></li>
+ * </ul>
+ * <p>More information about QR Code technology and this library's design can be found on the project home page.</p>
+ * 
+ * <h2>Examples</h2>
+ * <p>Simple operation:</p>
+ * <pre style="margin-left:2em">import java.awt.image.BufferedImage;
+ *import java.io.File;
+ *import javax.imageio.ImageIO;
+ *import io.nayuki.fastqrcodegen.*;
+ *
+ *QrCode qr = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
+ *BufferedImage img = toImage(qr, 4, 10);  // See QrCodeGeneratorDemo
+ *ImageIO.write(img, "png", new File("qr-code.png"));</pre>
+ * <p>Manual operation:</p>
+ * <pre style="margin-left:2em">import java.util.List;
+ *import io.nayuki.fastqrcodegen.*;
+ *
+ *List&lt;QrSegment&gt; segs = QrSegment.makeSegments("3141592653589793238462643383");
+ *QrCode qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
+ *for (int y = 0; y &lt; qr.size; y++) {
+ *    for (int x = 0; x &lt; qr.size; x++) {
+ *        (... paint qr.getModule(x, y) ...)
+ *    }
+ *}</pre>
+ */
+package io.nayuki.fastqrcodegen;

Telegram/ThirdParty/QR/java/QrCodeGeneratorDemo.java

@@ -0,0 +1,256 @@
+/* 
+ * QR Code generator demo (Java)
+ * 
+ * Run this command-line program with no arguments. The program creates/overwrites a bunch of
+ * PNG and SVG files in the current working directory to demonstrate the creation of QR Codes.
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import javax.imageio.ImageIO;
+import io.nayuki.qrcodegen.QrCode;
+import io.nayuki.qrcodegen.QrSegment;
+import io.nayuki.qrcodegen.QrSegmentAdvanced;
+
+
+public final class QrCodeGeneratorDemo {
+	
+	// The main application program.
+	public static void main(String[] args) throws IOException {
+		doBasicDemo();
+		doVarietyDemo();
+		doSegmentDemo();
+		doMaskDemo();
+	}
+	
+	
+	
+	/*---- Demo suite ----*/
+	
+	// Creates a single QR Code, then writes it to a PNG file and an SVG file.
+	private static void doBasicDemo() throws IOException {
+		String text = "Hello, world!";          // User-supplied Unicode text
+		QrCode.Ecc errCorLvl = QrCode.Ecc.LOW;  // Error correction level
+		
+		QrCode qr = QrCode.encodeText(text, errCorLvl);  // Make the QR Code symbol
+		
+		BufferedImage img = toImage(qr, 10, 4);          // Convert to bitmap image
+		File imgFile = new File("hello-world-QR.png");   // File path for output
+		ImageIO.write(img, "png", imgFile);              // Write image to file
+		
+		String svg = toSvgString(qr, 4, "#FFFFFF", "#000000");  // Convert to SVG XML code
+		File svgFile = new File("hello-world-QR.svg");          // File path for output
+		Files.write(svgFile.toPath(),                           // Write image to file
+			svg.getBytes(StandardCharsets.UTF_8));
+	}
+	
+	
+	// Creates a variety of QR Codes that exercise different features of the library, and writes each one to file.
+	private static void doVarietyDemo() throws IOException {
+		QrCode qr;
+		
+		// Numeric mode encoding (3.33 bits per digit)
+		qr = QrCode.encodeText("314159265358979323846264338327950288419716939937510", QrCode.Ecc.MEDIUM);
+		writePng(toImage(qr, 13, 1), "pi-digits-QR.png");
+		
+		// Alphanumeric mode encoding (5.5 bits per character)
+		qr = QrCode.encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCode.Ecc.HIGH);
+		writePng(toImage(qr, 10, 2), "alphanumeric-QR.png");
+		
+		// Unicode text as UTF-8
+		qr = QrCode.encodeText("こんにちwa、世界！ αβγδ", QrCode.Ecc.QUARTILE);
+		writePng(toImage(qr, 10, 3), "unicode-QR.png");
+		
+		// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+		qr = QrCode.encodeText(
+			"Alice was beginning to get very tired of sitting by her sister on the bank, "
+			+ "and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
+			+ "but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
+			+ "'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
+			+ "for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
+			+ "daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
+			+ "a White Rabbit with pink eyes ran close by her.", QrCode.Ecc.HIGH);
+		writePng(toImage(qr, 6, 10), "alice-wonderland-QR.png");
+	}
+	
+	
+	// Creates QR Codes with manually specified segments for better compactness.
+	private static void doSegmentDemo() throws IOException {
+		QrCode qr;
+		List<QrSegment> segs;
+		
+		// Illustration "silver"
+		String silver0 = "THE SQUARE ROOT OF 2 IS 1.";
+		String silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
+		qr = QrCode.encodeText(silver0 + silver1, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 10, 3), "sqrt2-monolithic-QR.png");
+		
+		segs = Arrays.asList(
+			QrSegment.makeAlphanumeric(silver0),
+			QrSegment.makeNumeric(silver1));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 10, 3), "sqrt2-segmented-QR.png");
+		
+		// Illustration "golden"
+		String golden0 = "Golden ratio φ = 1.";
+		String golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+		String golden2 = "......";
+		qr = QrCode.encodeText(golden0 + golden1 + golden2, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 8, 5), "phi-monolithic-QR.png");
+		
+		segs = Arrays.asList(
+			QrSegment.makeBytes(golden0.getBytes(StandardCharsets.UTF_8)),
+			QrSegment.makeNumeric(golden1),
+			QrSegment.makeAlphanumeric(golden2));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 8, 5), "phi-segmented-QR.png");
+		
+		// Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+		String madoka = "「魔法少女まどか☆マギカ」って、　ИАИ　ｄｅｓｕ　κα？";
+		qr = QrCode.encodeText(madoka, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 9, 4, 0xFFFFE0, 0x303080), "madoka-utf8-QR.png");
+		
+		segs = Arrays.asList(QrSegmentAdvanced.makeKanji(madoka));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		writePng(toImage(qr, 9, 4, 0xE0F0FF, 0x404040), "madoka-kanji-QR.png");
+	}
+	
+	
+	// Creates QR Codes with the same size and contents but different mask patterns.
+	private static void doMaskDemo() throws IOException {
+		QrCode qr;
+		List<QrSegment> segs;
+		
+		// Project Nayuki URL
+		segs = QrSegment.makeSegments("https://www.nayuki.io/");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -1, true);  // Automatic mask
+		writePng(toImage(qr, 8, 6, 0xE0FFE0, 0x206020), "project-nayuki-automask-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 3, true);  // Force mask 3
+		writePng(toImage(qr, 8, 6, 0xFFE0E0, 0x602020), "project-nayuki-mask3-QR.png");
+		
+		// Chinese text as UTF-8
+		segs = QrSegment.makeSegments("維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 0, true);  // Force mask 0
+		writePng(toImage(qr, 10, 3), "unicode-mask0-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 1, true);  // Force mask 1
+		writePng(toImage(qr, 10, 3), "unicode-mask1-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 5, true);  // Force mask 5
+		writePng(toImage(qr, 10, 3), "unicode-mask5-QR.png");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 7, true);  // Force mask 7
+		writePng(toImage(qr, 10, 3), "unicode-mask7-QR.png");
+	}
+	
+	
+	
+	/*---- Utilities ----*/
+	
+	private static BufferedImage toImage(QrCode qr, int scale, int border) {
+		return toImage(qr, scale, border, 0xFFFFFF, 0x000000);
+	}
+	
+	
+	/**
+	 * Returns a raster image depicting the specified QR Code, with
+	 * the specified module scale, border modules, and module colors.
+	 * <p>For example, scale=10 and border=4 means to pad the QR Code with 4 light border
+	 * modules on all four sides, and use 10&#xD7;10 pixels to represent each module.
+	 * @param qr the QR Code to render (not {@code null})
+	 * @param scale the side length (measured in pixels, must be positive) of each module
+	 * @param border the number of border modules to add, which must be non-negative
+	 * @param lightColor the color to use for light modules, in 0xRRGGBB format
+	 * @param darkColor the color to use for dark modules, in 0xRRGGBB format
+	 * @return a new image representing the QR Code, with padding and scaling
+	 * @throws NullPointerException if the QR Code is {@code null}
+	 * @throws IllegalArgumentException if the scale or border is out of range, or if
+	 * {scale, border, size} cause the image dimensions to exceed Integer.MAX_VALUE
+	 */
+	private static BufferedImage toImage(QrCode qr, int scale, int border, int lightColor, int darkColor) {
+		Objects.requireNonNull(qr);
+		if (scale <= 0 || border < 0)
+			throw new IllegalArgumentException("Value out of range");
+		if (border > Integer.MAX_VALUE / 2 || qr.size + border * 2L > Integer.MAX_VALUE / scale)
+			throw new IllegalArgumentException("Scale or border too large");
+		
+		BufferedImage result = new BufferedImage((qr.size + border * 2) * scale, (qr.size + border * 2) * scale, BufferedImage.TYPE_INT_RGB);
+		for (int y = 0; y < result.getHeight(); y++) {
+			for (int x = 0; x < result.getWidth(); x++) {
+				boolean color = qr.getModule(x / scale - border, y / scale - border);
+				result.setRGB(x, y, color ? darkColor : lightColor);
+			}
+		}
+		return result;
+	}
+	
+	
+	// Helper function to reduce code duplication.
+	private static void writePng(BufferedImage img, String filepath) throws IOException {
+		ImageIO.write(img, "png", new File(filepath));
+	}
+	
+	
+	/**
+	 * Returns a string of SVG code for an image depicting the specified QR Code, with the specified
+	 * number of border modules. The string always uses Unix newlines (\n), regardless of the platform.
+	 * @param qr the QR Code to render (not {@code null})
+	 * @param border the number of border modules to add, which must be non-negative
+	 * @param lightColor the color to use for light modules, in any format supported by CSS, not {@code null}
+	 * @param darkColor the color to use for dark modules, in any format supported by CSS, not {@code null}
+	 * @return a string representing the QR Code as an SVG XML document
+	 * @throws NullPointerException if any object is {@code null}
+	 * @throws IllegalArgumentException if the border is negative
+	 */
+	private static String toSvgString(QrCode qr, int border, String lightColor, String darkColor) {
+		Objects.requireNonNull(qr);
+		Objects.requireNonNull(lightColor);
+		Objects.requireNonNull(darkColor);
+		if (border < 0)
+			throw new IllegalArgumentException("Border must be non-negative");
+		long brd = border;
+		StringBuilder sb = new StringBuilder()
+			.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+			.append("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
+			.append(String.format("<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 %1$d %1$d\" stroke=\"none\">\n",
+				qr.size + brd * 2))
+			.append("\t<rect width=\"100%\" height=\"100%\" fill=\"" + lightColor + "\"/>\n")
+			.append("\t<path d=\"");
+		for (int y = 0; y < qr.size; y++) {
+			for (int x = 0; x < qr.size; x++) {
+				if (qr.getModule(x, y)) {
+					if (x != 0 || y != 0)
+						sb.append(" ");
+					sb.append(String.format("M%d,%dh1v1h-1z", x + brd, y + brd));
+				}
+			}
+		}
+		return sb
+			.append("\" fill=\"" + darkColor + "\"/>\n")
+			.append("</svg>\n")
+			.toString();
+	}
+	
+}

Telegram/ThirdParty/QR/java/Readme.markdown

@@ -0,0 +1,65 @@
+QR Code generator library - Java
+================================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+Optional advanced features:
+
+* Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes
+* Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```java
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.List;
+import javax.imageio.ImageIO;
+import io.nayuki.qrcodegen.*;
+
+// Simple operation
+QrCode qr0 = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
+BufferedImage img = toImage(qr0, 4, 10);  // See QrCodeGeneratorDemo
+ImageIO.write(img, "png", new File("qr-code.png"));
+
+// Manual operation
+List<QrSegment> segs = QrSegment.makeSegments("3141592653589793238462643383");
+QrCode qr1 = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
+for (int y = 0; y < qr1.size; y++) {
+    for (int x = 0; x < qr1.size; x++) {
+        (... paint qr1.getModule(x, y) ...)
+    }
+}
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/java/QrCodeGeneratorDemo.java .

Telegram/ThirdParty/QR/java/pom.xml

@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	
+	<groupId>io.nayuki</groupId>
+	<artifactId>qrcodegen</artifactId>
+	<version>1.8.0</version>
+	<packaging>jar</packaging>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+	</properties>
+	
+	
+	<build>
+		<plugins>
+			
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.8.1</version>
+				<executions>
+					<execution>
+						<id>default-compile</id>
+						<configuration>
+							<release>9</release>
+						</configuration>
+					</execution>
+					<execution>
+						<id>java8-compile</id>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+						<configuration>
+							<source>1.8</source>
+							<target>1.8</target>
+							<excludes>
+								<exclude>module-info.java</exclude>
+							</excludes>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+			
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-release-plugin</artifactId>
+				<configuration>
+					<checkModificationExcludes>
+						<checkModificationExclude>java/pom.xml</checkModificationExclude>
+					</checkModificationExcludes>
+				</configuration>
+			</plugin>
+			
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-source-plugin</artifactId>
+				<version>2.2.1</version>
+				<executions>
+					<execution>
+						<id>attach-sources</id>
+						<goals>
+							<goal>jar-no-fork</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>3.1.1</version>
+				<executions>
+					<execution>
+						<id>attach-javadocs</id>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-gpg-plugin</artifactId>
+				<version>1.5</version>
+				<executions>
+					<execution>
+						<id>sign-artifacts</id>
+						<phase>verify</phase>
+						<goals>
+							<goal>sign</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			
+		</plugins>
+	</build>
+	
+	
+	<name>QR Code generator library</name>
+	<description>High quality QR Code generator library</description>
+	<url>https://www.nayuki.io/page/qr-code-generator-library</url>
+	<inceptionYear>2016</inceptionYear>
+	<licenses>
+		<license>
+			<name>The MIT License</name>
+			<url>https://opensource.org/licenses/MIT</url>
+			<distribution>repo</distribution>
+		</license>
+	</licenses>
+	<developers>
+		<developer>
+			<name>Project Nayuki</name>
+			<email>me@nayuki.io</email>
+			<url>https://www.nayuki.io/</url>
+		</developer>
+	</developers>
+	
+	<scm>
+		<connection>scm:git:git://github.com/nayuki/QR-Code-generator.git</connection>
+		<developerConnection>scm:git:ssh://github.com:nayuki/QR-Code-generator.git</developerConnection>
+		<url>https://github.com/nayuki/QR-Code-generator/tree/master/java</url>
+	</scm>
+	<distributionManagement>
+		<snapshotRepository>
+			<id>ossrh</id>
+			<url>https://oss.sonatype.org/content/repositories/snapshots</url>
+		</snapshotRepository>
+		<repository>
+			<id>ossrh</id>
+			<url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
+		</repository>
+	</distributionManagement>
+</project>

Telegram/ThirdParty/QR/java/src/main/java/io/nayuki/qrcodegen/BitBuffer.java

@@ -0,0 +1,129 @@
+/* 
+ * QR Code generator library (Java)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.qrcodegen;
+
+import java.util.BitSet;
+import java.util.Objects;
+
+
+/**
+ * An appendable sequence of bits (0s and 1s). Mainly used by {@link QrSegment}.
+ */
+public final class BitBuffer implements Cloneable {
+	
+	/*---- Fields ----*/
+	
+	private BitSet data;
+	
+	private int bitLength;  // Non-negative
+	
+	
+	
+	/*---- Constructor ----*/
+	
+	/**
+	 * Constructs an empty bit buffer (length 0).
+	 */
+	public BitBuffer() {
+		data = new BitSet();
+		bitLength = 0;
+	}
+	
+	
+	
+	/*---- Methods ----*/
+	
+	/**
+	 * Returns the length of this sequence, which is a non-negative value.
+	 * @return the length of this sequence
+	 */
+	public int bitLength() {
+		assert bitLength >= 0;
+		return bitLength;
+	}
+	
+	
+	/**
+	 * Returns the bit at the specified index, yielding 0 or 1.
+	 * @param index the index to get the bit at
+	 * @return the bit at the specified index
+	 * @throws IndexOutOfBoundsException if index < 0 or index ≥ bitLength
+	 */
+	public int getBit(int index) {
+		if (index < 0 || index >= bitLength)
+			throw new IndexOutOfBoundsException();
+		return data.get(index) ? 1 : 0;
+	}
+	
+	
+	/**
+	 * Appends the specified number of low-order bits of the specified value to this
+	 * buffer. Requires 0 &#x2264; len &#x2264; 31 and 0 &#x2264; val &lt; 2<sup>len</sup>.
+	 * @param val the value to append
+	 * @param len the number of low-order bits in the value to take
+	 * @throws IllegalArgumentException if the value or number of bits is out of range
+	 * @throws IllegalStateException if appending the data
+	 * would make bitLength exceed Integer.MAX_VALUE
+	 */
+	public void appendBits(int val, int len) {
+		if (len < 0 || len > 31 || val >>> len != 0)
+			throw new IllegalArgumentException("Value out of range");
+		if (Integer.MAX_VALUE - bitLength < len)
+			throw new IllegalStateException("Maximum length reached");
+		for (int i = len - 1; i >= 0; i--, bitLength++)  // Append bit by bit
+			data.set(bitLength, QrCode.getBit(val, i));
+	}
+	
+	
+	/**
+	 * Appends the content of the specified bit buffer to this buffer.
+	 * @param bb the bit buffer whose data to append (not {@code null})
+	 * @throws NullPointerException if the bit buffer is {@code null}
+	 * @throws IllegalStateException if appending the data
+	 * would make bitLength exceed Integer.MAX_VALUE
+	 */
+	public void appendData(BitBuffer bb) {
+		Objects.requireNonNull(bb);
+		if (Integer.MAX_VALUE - bitLength < bb.bitLength)
+			throw new IllegalStateException("Maximum length reached");
+		for (int i = 0; i < bb.bitLength; i++, bitLength++)  // Append bit by bit
+			data.set(bitLength, bb.data.get(i));
+	}
+	
+	
+	/**
+	 * Returns a new copy of this buffer.
+	 * @return a new copy of this buffer (not {@code null})
+	 */
+	public BitBuffer clone() {
+		try {
+			BitBuffer result = (BitBuffer)super.clone();
+			result.data = (BitSet)result.data.clone();
+			return result;
+		} catch (CloneNotSupportedException e) {
+			throw new AssertionError(e);
+		}
+	}
+	
+}

Telegram/ThirdParty/QR/java/src/main/java/io/nayuki/qrcodegen/DataTooLongException.java

@@ -0,0 +1,57 @@
+/* 
+ * QR Code generator library (Java)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.qrcodegen;
+
+
+/**
+ * Thrown when the supplied data does not fit any QR Code version. Ways to handle this exception include:
+ * <ul>
+ *   <li><p>Decrease the error correction level if it was greater than {@code Ecc.LOW}.</p></li>
+ *   <li><p>If the advanced {@code encodeSegments()} function with 6 arguments or the
+ *     {@code makeSegmentsOptimally()} function was called, then increase the maxVersion argument
+ *     if it was less than {@link QrCode#MAX_VERSION}. (This advice does not apply to the other
+ *     factory functions because they search all versions up to {@code QrCode.MAX_VERSION}.)</p></li>
+ *   <li><p>Split the text data into better or optimal segments in order to reduce the number of
+ *     bits required. (See {@link QrSegmentAdvanced#makeSegmentsOptimally(CharSequence,QrCode.Ecc,int,int)
+ *     QrSegmentAdvanced.makeSegmentsOptimally()}.)</p></li>
+ *   <li><p>Change the text or binary data to be shorter.</p></li>
+ *   <li><p>Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).</p></li>
+ *   <li><p>Propagate the error upward to the caller/user.</p></li>
+ * </ul>
+ * @see QrCode#encodeText(CharSequence, QrCode.Ecc)
+ * @see QrCode#encodeBinary(byte[], QrCode.Ecc)
+ * @see QrCode#encodeSegments(java.util.List, QrCode.Ecc)
+ * @see QrCode#encodeSegments(java.util.List, QrCode.Ecc, int, int, int, boolean)
+ * @see QrSegmentAdvanced#makeSegmentsOptimally(CharSequence, QrCode.Ecc, int, int)
+ */
+public class DataTooLongException extends IllegalArgumentException {
+	
+	public DataTooLongException() {}
+	
+	
+	public DataTooLongException(String msg) {
+		super(msg);
+	}
+	
+}

Telegram/ThirdParty/QR/java/src/main/java/io/nayuki/qrcodegen/QrCode.java

@@ -0,0 +1,819 @@
+/* 
+ * QR Code generator library (Java)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.qrcodegen;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+
+/**
+ * A QR Code symbol, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * <p>Instances of this class represent an immutable square grid of dark and light cells.
+ * The class provides static factory functions to create a QR Code from text or binary data.
+ * The class covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.</p>
+ * <p>Ways to create a QR Code object:</p>
+ * <ul>
+ *   <li><p>High level: Take the payload data and call {@link QrCode#encodeText(CharSequence,Ecc)}
+ *     or {@link QrCode#encodeBinary(byte[],Ecc)}.</p></li>
+ *   <li><p>Mid level: Custom-make the list of {@link QrSegment segments}
+ *     and call {@link QrCode#encodeSegments(List,Ecc)} or
+ *     {@link QrCode#encodeSegments(List,Ecc,int,int,int,boolean)}</p></li>
+ *   <li><p>Low level: Custom-make the array of data codeword bytes (including segment headers and
+ *     final padding, excluding error correction codewords), supply the appropriate version number,
+ *     and call the {@link QrCode#QrCode(int,Ecc,byte[],int) constructor}.</p></li>
+ * </ul>
+ * <p>(Note that all ways require supplying the desired error correction level.)</p>
+ * @see QrSegment
+ */
+public final class QrCode {
+	
+	/*---- Static factory functions (high level) ----*/
+	
+	/**
+	 * Returns a QR Code representing the specified Unicode text string at the specified error correction level.
+	 * As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
+	 * Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
+	 * QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
+	 * ecl argument if it can be done without increasing the version.
+	 * @param text the text to be encoded (not {@code null}), which can be any Unicode string
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @return a QR Code (not {@code null}) representing the text
+	 * @throws NullPointerException if the text or error correction level is {@code null}
+	 * @throws DataTooLongException if the text fails to fit in the
+	 * largest version QR Code at the ECL, which means it is too long
+	 */
+	public static QrCode encodeText(CharSequence text, Ecc ecl) {
+		Objects.requireNonNull(text);
+		Objects.requireNonNull(ecl);
+		List<QrSegment> segs = QrSegment.makeSegments(text);
+		return encodeSegments(segs, ecl);
+	}
+	
+	
+	/**
+	 * Returns a QR Code representing the specified binary data at the specified error correction level.
+	 * This function always encodes using the binary segment mode, not any text mode. The maximum number of
+	 * bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+	 * The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
+	 * @param data the binary data to encode (not {@code null})
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @return a QR Code (not {@code null}) representing the data
+	 * @throws NullPointerException if the data or error correction level is {@code null}
+	 * @throws DataTooLongException if the data fails to fit in the
+	 * largest version QR Code at the ECL, which means it is too long
+	 */
+	public static QrCode encodeBinary(byte[] data, Ecc ecl) {
+		Objects.requireNonNull(data);
+		Objects.requireNonNull(ecl);
+		QrSegment seg = QrSegment.makeBytes(data);
+		return encodeSegments(Arrays.asList(seg), ecl);
+	}
+	
+	
+	/*---- Static factory functions (mid level) ----*/
+	
+	/**
+	 * Returns a QR Code representing the specified segments at the specified error correction
+	 * level. The smallest possible QR Code version is automatically chosen for the output. The ECC level
+	 * of the result may be higher than the ecl argument if it can be done without increasing the version.
+	 * <p>This function allows the user to create a custom sequence of segments that switches
+	 * between modes (such as alphanumeric and byte) to encode text in less space.
+	 * This is a mid-level API; the high-level API is {@link #encodeText(CharSequence,Ecc)}
+	 * and {@link #encodeBinary(byte[],Ecc)}.</p>
+	 * @param segs the segments to encode
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @return a QR Code (not {@code null}) representing the segments
+	 * @throws NullPointerException if the list of segments, any segment, or the error correction level is {@code null}
+	 * @throws DataTooLongException if the segments fail to fit in the
+	 * largest version QR Code at the ECL, which means they are too long
+	 */
+	public static QrCode encodeSegments(List<QrSegment> segs, Ecc ecl) {
+		return encodeSegments(segs, ecl, MIN_VERSION, MAX_VERSION, -1, true);
+	}
+	
+	
+	/**
+	 * Returns a QR Code representing the specified segments with the specified encoding parameters.
+	 * The smallest possible QR Code version within the specified range is automatically
+	 * chosen for the output. Iff boostEcl is {@code true}, then the ECC level of the
+	 * result may be higher than the ecl argument if it can be done without increasing
+	 * the version. The mask number is either between 0 to 7 (inclusive) to force that
+	 * mask, or &#x2212;1 to automatically choose an appropriate mask (which may be slow).
+	 * <p>This function allows the user to create a custom sequence of segments that switches
+	 * between modes (such as alphanumeric and byte) to encode text in less space.
+	 * This is a mid-level API; the high-level API is {@link #encodeText(CharSequence,Ecc)}
+	 * and {@link #encodeBinary(byte[],Ecc)}.</p>
+	 * @param segs the segments to encode
+	 * @param ecl the error correction level to use (not {@code null}) (boostable)
+	 * @param minVersion the minimum allowed version of the QR Code (at least 1)
+	 * @param maxVersion the maximum allowed version of the QR Code (at most 40)
+	 * @param mask the mask number to use (between 0 and 7 (inclusive)), or &#x2212;1 for automatic mask
+	 * @param boostEcl increases the ECC level as long as it doesn't increase the version number
+	 * @return a QR Code (not {@code null}) representing the segments
+	 * @throws NullPointerException if the list of segments, any segment, or the error correction level is {@code null}
+	 * @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40
+	 * or &#x2212;1 &#x2264; mask &#x2264; 7 is violated
+	 * @throws DataTooLongException if the segments fail to fit in
+	 * the maxVersion QR Code at the ECL, which means they are too long
+	 */
+	public static QrCode encodeSegments(List<QrSegment> segs, Ecc ecl, int minVersion, int maxVersion, int mask, boolean boostEcl) {
+		Objects.requireNonNull(segs);
+		Objects.requireNonNull(ecl);
+		if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7)
+			throw new IllegalArgumentException("Invalid value");
+		
+		// Find the minimal version number to use
+		int version, dataUsedBits;
+		for (version = minVersion; ; version++) {
+			int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;  // Number of data bits available
+			dataUsedBits = QrSegment.getTotalBits(segs, version);
+			if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
+				break;  // This version number is found to be suitable
+			if (version >= maxVersion) {  // All versions in the range could not fit the given data
+				String msg = "Segment too long";
+				if (dataUsedBits != -1)
+					msg = String.format("Data length = %d bits, Max capacity = %d bits", dataUsedBits, dataCapacityBits);
+				throw new DataTooLongException(msg);
+			}
+		}
+		assert dataUsedBits != -1;
+		
+		// Increase the error correction level while the data still fits in the current version number
+		for (Ecc newEcl : Ecc.values()) {  // From low to high
+			if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8)
+				ecl = newEcl;
+		}
+		
+		// Concatenate all segments to create the data bit string
+		BitBuffer bb = new BitBuffer();
+		for (QrSegment seg : segs) {
+			bb.appendBits(seg.mode.modeBits, 4);
+			bb.appendBits(seg.numChars, seg.mode.numCharCountBits(version));
+			bb.appendData(seg.data);
+		}
+		assert bb.bitLength() == dataUsedBits;
+		
+		// Add terminator and pad up to a byte if applicable
+		int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
+		assert bb.bitLength() <= dataCapacityBits;
+		bb.appendBits(0, Math.min(4, dataCapacityBits - bb.bitLength()));
+		bb.appendBits(0, (8 - bb.bitLength() % 8) % 8);
+		assert bb.bitLength() % 8 == 0;
+		
+		// Pad with alternating bytes until data capacity is reached
+		for (int padByte = 0xEC; bb.bitLength() < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
+			bb.appendBits(padByte, 8);
+		
+		// Pack bits into bytes in big endian
+		byte[] dataCodewords = new byte[bb.bitLength() / 8];
+		for (int i = 0; i < bb.bitLength(); i++)
+			dataCodewords[i >>> 3] |= bb.getBit(i) << (7 - (i & 7));
+		
+		// Create the QR Code object
+		return new QrCode(version, ecl, dataCodewords, mask);
+	}
+	
+	
+	
+	/*---- Instance fields ----*/
+	
+	// Public immutable scalar parameters:
+	
+	/** The version number of this QR Code, which is between 1 and 40 (inclusive).
+	 * This determines the size of this barcode. */
+	public final int version;
+	
+	/** The width and height of this QR Code, measured in modules, between
+	 * 21 and 177 (inclusive). This is equal to version &#xD7; 4 + 17. */
+	public final int size;
+	
+	/** The error correction level used in this QR Code, which is not {@code null}. */
+	public final Ecc errorCorrectionLevel;
+	
+	/** The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+	 * <p>Even if a QR Code is created with automatic masking requested (mask =
+	 * &#x2212;1), the resulting object still has a mask value between 0 and 7. */
+	public final int mask;
+	
+	// Private grids of modules/pixels, with dimensions of size*size:
+	
+	// The modules of this QR Code (false = light, true = dark).
+	// Immutable after constructor finishes. Accessed through getModule().
+	private boolean[][] modules;
+	
+	// Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+	private boolean[][] isFunction;
+	
+	
+	
+	/*---- Constructor (low level) ----*/
+	
+	/**
+	 * Constructs a QR Code with the specified version number,
+	 * error correction level, data codeword bytes, and mask number.
+	 * <p>This is a low-level API that most users should not use directly. A mid-level
+	 * API is the {@link #encodeSegments(List,Ecc,int,int,int,boolean)} function.</p>
+	 * @param ver the version number to use, which must be in the range 1 to 40 (inclusive)
+	 * @param ecl the error correction level to use
+	 * @param dataCodewords the bytes representing segments to encode (without ECC)
+	 * @param msk the mask pattern to use, which is either &#x2212;1 for automatic choice or from 0 to 7 for fixed choice
+	 * @throws NullPointerException if the byte array or error correction level is {@code null}
+	 * @throws IllegalArgumentException if the version or mask value is out of range,
+	 * or if the data is the wrong length for the specified version and error correction level
+	 */
+	public QrCode(int ver, Ecc ecl, byte[] dataCodewords, int msk) {
+		// Check arguments and initialize fields
+		if (ver < MIN_VERSION || ver > MAX_VERSION)
+			throw new IllegalArgumentException("Version value out of range");
+		if (msk < -1 || msk > 7)
+			throw new IllegalArgumentException("Mask value out of range");
+		version = ver;
+		size = ver * 4 + 17;
+		errorCorrectionLevel = Objects.requireNonNull(ecl);
+		Objects.requireNonNull(dataCodewords);
+		modules    = new boolean[size][size];  // Initially all light
+		isFunction = new boolean[size][size];
+		
+		// Compute ECC, draw modules, do masking
+		drawFunctionPatterns();
+		byte[] allCodewords = addEccAndInterleave(dataCodewords);
+		drawCodewords(allCodewords);
+		
+		// Do masking
+		if (msk == -1) {  // Automatically choose best mask
+			int minPenalty = Integer.MAX_VALUE;
+			for (int i = 0; i < 8; i++) {
+				applyMask(i);
+				drawFormatBits(i);
+				int penalty = getPenaltyScore();
+				if (penalty < minPenalty) {
+					msk = i;
+					minPenalty = penalty;
+				}
+				applyMask(i);  // Undoes the mask due to XOR
+			}
+		}
+		assert 0 <= msk && msk <= 7;
+		mask = msk;
+		applyMask(msk);  // Apply the final choice of mask
+		drawFormatBits(msk);  // Overwrite old format bits
+		
+		isFunction = null;
+	}
+	
+	
+	
+	/*---- Public instance methods ----*/
+	
+	/**
+	 * Returns the color of the module (pixel) at the specified coordinates, which is {@code false}
+	 * for light or {@code true} for dark. The top left corner has the coordinates (x=0, y=0).
+	 * If the specified coordinates are out of bounds, then {@code false} (light) is returned.
+	 * @param x the x coordinate, where 0 is the left edge and size&#x2212;1 is the right edge
+	 * @param y the y coordinate, where 0 is the top edge and size&#x2212;1 is the bottom edge
+	 * @return {@code true} if the coordinates are in bounds and the module
+	 * at that location is dark, or {@code false} (light) otherwise
+	 */
+	public boolean getModule(int x, int y) {
+		return 0 <= x && x < size && 0 <= y && y < size && modules[y][x];
+	}
+	
+	
+	
+	/*---- Private helper methods for constructor: Drawing function modules ----*/
+	
+	// Reads this object's version field, and draws and marks all function modules.
+	private void drawFunctionPatterns() {
+		// Draw horizontal and vertical timing patterns
+		for (int i = 0; i < size; i++) {
+			setFunctionModule(6, i, i % 2 == 0);
+			setFunctionModule(i, 6, i % 2 == 0);
+		}
+		
+		// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
+		drawFinderPattern(3, 3);
+		drawFinderPattern(size - 4, 3);
+		drawFinderPattern(3, size - 4);
+		
+		// Draw numerous alignment patterns
+		int[] alignPatPos = getAlignmentPatternPositions();
+		int numAlign = alignPatPos.length;
+		for (int i = 0; i < numAlign; i++) {
+			for (int j = 0; j < numAlign; j++) {
+				// Don't draw on the three finder corners
+				if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0))
+					drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+			}
+		}
+		
+		// Draw configuration data
+		drawFormatBits(0);  // Dummy mask value; overwritten later in the constructor
+		drawVersion();
+	}
+	
+	
+	// Draws two copies of the format bits (with its own error correction code)
+	// based on the given mask and this object's error correction level field.
+	private void drawFormatBits(int msk) {
+		// Calculate error correction code and pack bits
+		int data = errorCorrectionLevel.formatBits << 3 | msk;  // errCorrLvl is uint2, mask is uint3
+		int rem = data;
+		for (int i = 0; i < 10; i++)
+			rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+		int bits = (data << 10 | rem) ^ 0x5412;  // uint15
+		assert bits >>> 15 == 0;
+		
+		// Draw first copy
+		for (int i = 0; i <= 5; i++)
+			setFunctionModule(8, i, getBit(bits, i));
+		setFunctionModule(8, 7, getBit(bits, 6));
+		setFunctionModule(8, 8, getBit(bits, 7));
+		setFunctionModule(7, 8, getBit(bits, 8));
+		for (int i = 9; i < 15; i++)
+			setFunctionModule(14 - i, 8, getBit(bits, i));
+		
+		// Draw second copy
+		for (int i = 0; i < 8; i++)
+			setFunctionModule(size - 1 - i, 8, getBit(bits, i));
+		for (int i = 8; i < 15; i++)
+			setFunctionModule(8, size - 15 + i, getBit(bits, i));
+		setFunctionModule(8, size - 8, true);  // Always dark
+	}
+	
+	
+	// Draws two copies of the version bits (with its own error correction code),
+	// based on this object's version field, iff 7 <= version <= 40.
+	private void drawVersion() {
+		if (version < 7)
+			return;
+		
+		// Calculate error correction code and pack bits
+		int rem = version;  // version is uint6, in the range [7, 40]
+		for (int i = 0; i < 12; i++)
+			rem = (rem << 1) ^ ((rem >>> 11) * 0x1F25);
+		int bits = version << 12 | rem;  // uint18
+		assert bits >>> 18 == 0;
+		
+		// Draw two copies
+		for (int i = 0; i < 18; i++) {
+			boolean bit = getBit(bits, i);
+			int a = size - 11 + i % 3;
+			int b = i / 3;
+			setFunctionModule(a, b, bit);
+			setFunctionModule(b, a, bit);
+		}
+	}
+	
+	
+	// Draws a 9*9 finder pattern including the border separator,
+	// with the center module at (x, y). Modules can be out of bounds.
+	private void drawFinderPattern(int x, int y) {
+		for (int dy = -4; dy <= 4; dy++) {
+			for (int dx = -4; dx <= 4; dx++) {
+				int dist = Math.max(Math.abs(dx), Math.abs(dy));  // Chebyshev/infinity norm
+				int xx = x + dx, yy = y + dy;
+				if (0 <= xx && xx < size && 0 <= yy && yy < size)
+					setFunctionModule(xx, yy, dist != 2 && dist != 4);
+			}
+		}
+	}
+	
+	
+	// Draws a 5*5 alignment pattern, with the center module
+	// at (x, y). All modules must be in bounds.
+	private void drawAlignmentPattern(int x, int y) {
+		for (int dy = -2; dy <= 2; dy++) {
+			for (int dx = -2; dx <= 2; dx++)
+				setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) != 1);
+		}
+	}
+	
+	
+	// Sets the color of a module and marks it as a function module.
+	// Only used by the constructor. Coordinates must be in bounds.
+	private void setFunctionModule(int x, int y, boolean isDark) {
+		modules[y][x] = isDark;
+		isFunction[y][x] = true;
+	}
+	
+	
+	/*---- Private helper methods for constructor: Codewords and masking ----*/
+	
+	// Returns a new byte string representing the given data with the appropriate error correction
+	// codewords appended to it, based on this object's version and error correction level.
+	private byte[] addEccAndInterleave(byte[] data) {
+		Objects.requireNonNull(data);
+		if (data.length != getNumDataCodewords(version, errorCorrectionLevel))
+			throw new IllegalArgumentException();
+		
+		// Calculate parameter numbers
+		int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[errorCorrectionLevel.ordinal()][version];
+		int blockEccLen = ECC_CODEWORDS_PER_BLOCK  [errorCorrectionLevel.ordinal()][version];
+		int rawCodewords = getNumRawDataModules(version) / 8;
+		int numShortBlocks = numBlocks - rawCodewords % numBlocks;
+		int shortBlockLen = rawCodewords / numBlocks;
+		
+		// Split data into blocks and append ECC to each block
+		byte[][] blocks = new byte[numBlocks][];
+		byte[] rsDiv = reedSolomonComputeDivisor(blockEccLen);
+		for (int i = 0, k = 0; i < numBlocks; i++) {
+			byte[] dat = Arrays.copyOfRange(data, k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+			k += dat.length;
+			byte[] block = Arrays.copyOf(dat, shortBlockLen + 1);
+			byte[] ecc = reedSolomonComputeRemainder(dat, rsDiv);
+			System.arraycopy(ecc, 0, block, block.length - blockEccLen, ecc.length);
+			blocks[i] = block;
+		}
+		
+		// Interleave (not concatenate) the bytes from every block into a single sequence
+		byte[] result = new byte[rawCodewords];
+		for (int i = 0, k = 0; i < blocks[0].length; i++) {
+			for (int j = 0; j < blocks.length; j++) {
+				// Skip the padding byte in short blocks
+				if (i != shortBlockLen - blockEccLen || j >= numShortBlocks) {
+					result[k] = blocks[j][i];
+					k++;
+				}
+			}
+		}
+		return result;
+	}
+	
+	
+	// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+	// data area of this QR Code. Function modules need to be marked off before this is called.
+	private void drawCodewords(byte[] data) {
+		Objects.requireNonNull(data);
+		if (data.length != getNumRawDataModules(version) / 8)
+			throw new IllegalArgumentException();
+		
+		int i = 0;  // Bit index into the data
+		// Do the funny zigzag scan
+		for (int right = size - 1; right >= 1; right -= 2) {  // Index of right column in each column pair
+			if (right == 6)
+				right = 5;
+			for (int vert = 0; vert < size; vert++) {  // Vertical counter
+				for (int j = 0; j < 2; j++) {
+					int x = right - j;  // Actual x coordinate
+					boolean upward = ((right + 1) & 2) == 0;
+					int y = upward ? size - 1 - vert : vert;  // Actual y coordinate
+					if (!isFunction[y][x] && i < data.length * 8) {
+						modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
+						i++;
+					}
+					// If this QR Code has any remainder bits (0 to 7), they were assigned as
+					// 0/false/light by the constructor and are left unchanged by this method
+				}
+			}
+		}
+		assert i == data.length * 8;
+	}
+	
+	
+	// XORs the codeword modules in this QR Code with the given mask pattern.
+	// The function modules must be marked and the codeword bits must be drawn
+	// before masking. Due to the arithmetic of XOR, calling applyMask() with
+	// the same mask value a second time will undo the mask. A final well-formed
+	// QR Code needs exactly one (not zero, two, etc.) mask applied.
+	private void applyMask(int msk) {
+		if (msk < 0 || msk > 7)
+			throw new IllegalArgumentException("Mask value out of range");
+		for (int y = 0; y < size; y++) {
+			for (int x = 0; x < size; x++) {
+				boolean invert;
+				switch (msk) {
+					case 0:  invert = (x + y) % 2 == 0;                    break;
+					case 1:  invert = y % 2 == 0;                          break;
+					case 2:  invert = x % 3 == 0;                          break;
+					case 3:  invert = (x + y) % 3 == 0;                    break;
+					case 4:  invert = (x / 3 + y / 2) % 2 == 0;            break;
+					case 5:  invert = x * y % 2 + x * y % 3 == 0;          break;
+					case 6:  invert = (x * y % 2 + x * y % 3) % 2 == 0;    break;
+					case 7:  invert = ((x + y) % 2 + x * y % 3) % 2 == 0;  break;
+					default:  throw new AssertionError();
+				}
+				modules[y][x] ^= invert & !isFunction[y][x];
+			}
+		}
+	}
+	
+	
+	// Calculates and returns the penalty score based on state of this QR Code's current modules.
+	// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+	private int getPenaltyScore() {
+		int result = 0;
+		
+		// Adjacent modules in row having same color, and finder-like patterns
+		for (int y = 0; y < size; y++) {
+			boolean runColor = false;
+			int runX = 0;
+			int[] runHistory = new int[7];
+			for (int x = 0; x < size; x++) {
+				if (modules[y][x] == runColor) {
+					runX++;
+					if (runX == 5)
+						result += PENALTY_N1;
+					else if (runX > 5)
+						result++;
+				} else {
+					finderPenaltyAddHistory(runX, runHistory);
+					if (!runColor)
+						result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+					runColor = modules[y][x];
+					runX = 1;
+				}
+			}
+			result += finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
+		}
+		// Adjacent modules in column having same color, and finder-like patterns
+		for (int x = 0; x < size; x++) {
+			boolean runColor = false;
+			int runY = 0;
+			int[] runHistory = new int[7];
+			for (int y = 0; y < size; y++) {
+				if (modules[y][x] == runColor) {
+					runY++;
+					if (runY == 5)
+						result += PENALTY_N1;
+					else if (runY > 5)
+						result++;
+				} else {
+					finderPenaltyAddHistory(runY, runHistory);
+					if (!runColor)
+						result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
+					runColor = modules[y][x];
+					runY = 1;
+				}
+			}
+			result += finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
+		}
+		
+		// 2*2 blocks of modules having same color
+		for (int y = 0; y < size - 1; y++) {
+			for (int x = 0; x < size - 1; x++) {
+				boolean color = modules[y][x];
+				if (  color == modules[y][x + 1] &&
+				      color == modules[y + 1][x] &&
+				      color == modules[y + 1][x + 1])
+					result += PENALTY_N2;
+			}
+		}
+		
+		// Balance of dark and light modules
+		int dark = 0;
+		for (boolean[] row : modules) {
+			for (boolean color : row) {
+				if (color)
+					dark++;
+			}
+		}
+		int total = size * size;  // Note that size is odd, so dark/total != 1/2
+		// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+		int k = (Math.abs(dark * 20 - total * 10) + total - 1) / total - 1;
+		assert 0 <= k && k <= 9;
+		result += k * PENALTY_N4;
+		assert 0 <= result && result <= 2568888;  // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
+		return result;
+	}
+	
+	
+	
+	/*---- Private helper functions ----*/
+	
+	// Returns an ascending list of positions of alignment patterns for this version number.
+	// Each position is in the range [0,177), and are used on both the x and y axes.
+	// This could be implemented as lookup table of 40 variable-length lists of unsigned bytes.
+	private int[] getAlignmentPatternPositions() {
+		if (version == 1)
+			return new int[]{};
+		else {
+			int numAlign = version / 7 + 2;
+			int step;
+			if (version == 32)  // Special snowflake
+				step = 26;
+			else  // step = ceil[(size - 13) / (numAlign * 2 - 2)] * 2
+				step = (version * 4 + numAlign * 2 + 1) / (numAlign * 2 - 2) * 2;
+			int[] result = new int[numAlign];
+			result[0] = 6;
+			for (int i = result.length - 1, pos = size - 7; i >= 1; i--, pos -= step)
+				result[i] = pos;
+			return result;
+		}
+	}
+	
+	
+	// Returns the number of data bits that can be stored in a QR Code of the given version number, after
+	// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+	// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
+	private static int getNumRawDataModules(int ver) {
+		if (ver < MIN_VERSION || ver > MAX_VERSION)
+			throw new IllegalArgumentException("Version number out of range");
+		
+		int size = ver * 4 + 17;
+		int result = size * size;   // Number of modules in the whole QR Code square
+		result -= 8 * 8 * 3;        // Subtract the three finders with separators
+		result -= 15 * 2 + 1;       // Subtract the format information and dark module
+		result -= (size - 16) * 2;  // Subtract the timing patterns (excluding finders)
+		// The five lines above are equivalent to: int result = (16 * ver + 128) * ver + 64;
+		if (ver >= 2) {
+			int numAlign = ver / 7 + 2;
+			result -= (numAlign - 1) * (numAlign - 1) * 25;  // Subtract alignment patterns not overlapping with timing patterns
+			result -= (numAlign - 2) * 2 * 20;  // Subtract alignment patterns that overlap with timing patterns
+			// The two lines above are equivalent to: result -= (25 * numAlign - 10) * numAlign - 55;
+			if (ver >= 7)
+				result -= 6 * 3 * 2;  // Subtract version information
+		}
+		assert 208 <= result && result <= 29648;
+		return result;
+	}
+	
+	
+	// Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
+	// implemented as a lookup table over all possible parameter values, instead of as an algorithm.
+	private static byte[] reedSolomonComputeDivisor(int degree) {
+		if (degree < 1 || degree > 255)
+			throw new IllegalArgumentException("Degree out of range");
+		// Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
+		// For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array {255, 8, 93}.
+		byte[] result = new byte[degree];
+		result[degree - 1] = 1;  // Start off with the monomial x^0
+		
+		// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
+		// and drop the highest monomial term which is always 1x^degree.
+		// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
+		int root = 1;
+		for (int i = 0; i < degree; i++) {
+			// Multiply the current product by (x - r^i)
+			for (int j = 0; j < result.length; j++) {
+				result[j] = (byte)reedSolomonMultiply(result[j] & 0xFF, root);
+				if (j + 1 < result.length)
+					result[j] ^= result[j + 1];
+			}
+			root = reedSolomonMultiply(root, 0x02);
+		}
+		return result;
+	}
+	
+	
+	// Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
+	private static byte[] reedSolomonComputeRemainder(byte[] data, byte[] divisor) {
+		Objects.requireNonNull(data);
+		Objects.requireNonNull(divisor);
+		byte[] result = new byte[divisor.length];
+		for (byte b : data) {  // Polynomial division
+			int factor = (b ^ result[0]) & 0xFF;
+			System.arraycopy(result, 1, result, 0, result.length - 1);
+			result[result.length - 1] = 0;
+			for (int i = 0; i < result.length; i++)
+				result[i] ^= reedSolomonMultiply(divisor[i] & 0xFF, factor);
+		}
+		return result;
+	}
+	
+	
+	// Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
+	// are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
+	private static int reedSolomonMultiply(int x, int y) {
+		assert x >> 8 == 0 && y >> 8 == 0;
+		// Russian peasant multiplication
+		int z = 0;
+		for (int i = 7; i >= 0; i--) {
+			z = (z << 1) ^ ((z >>> 7) * 0x11D);
+			z ^= ((y >>> i) & 1) * x;
+		}
+		assert z >>> 8 == 0;
+		return z;
+	}
+	
+	
+	// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+	// QR Code of the given version number and error correction level, with remainder bits discarded.
+	// This stateless pure function could be implemented as a (40*4)-cell lookup table.
+	static int getNumDataCodewords(int ver, Ecc ecl) {
+		return getNumRawDataModules(ver) / 8
+			- ECC_CODEWORDS_PER_BLOCK    [ecl.ordinal()][ver]
+			* NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal()][ver];
+	}
+	
+	
+	// Can only be called immediately after a light run is added, and
+	// returns either 0, 1, or 2. A helper function for getPenaltyScore().
+	private int finderPenaltyCountPatterns(int[] runHistory) {
+		int n = runHistory[1];
+		assert n <= size * 3;
+		boolean core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
+		return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)
+		     + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
+	}
+	
+	
+	// Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+	private int finderPenaltyTerminateAndCount(boolean currentRunColor, int currentRunLength, int[] runHistory) {
+		if (currentRunColor) {  // Terminate dark run
+			finderPenaltyAddHistory(currentRunLength, runHistory);
+			currentRunLength = 0;
+		}
+		currentRunLength += size;  // Add light border to final run
+		finderPenaltyAddHistory(currentRunLength, runHistory);
+		return finderPenaltyCountPatterns(runHistory);
+	}
+	
+	
+	// Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+	private void finderPenaltyAddHistory(int currentRunLength, int[] runHistory) {
+		if (runHistory[0] == 0)
+			currentRunLength += size;  // Add light border to initial run
+		System.arraycopy(runHistory, 0, runHistory, 1, runHistory.length - 1);
+		runHistory[0] = currentRunLength;
+	}
+	
+	
+	// Returns true iff the i'th bit of x is set to 1.
+	static boolean getBit(int x, int i) {
+		return ((x >>> i) & 1) != 0;
+	}
+	
+	
+	/*---- Constants and tables ----*/
+	
+	/** The minimum version number  (1) supported in the QR Code Model 2 standard. */
+	public static final int MIN_VERSION =  1;
+	
+	/** The maximum version number (40) supported in the QR Code Model 2 standard. */
+	public static final int MAX_VERSION = 40;
+	
+	
+	// For use in getPenaltyScore(), when evaluating which mask is best.
+	private static final int PENALTY_N1 =  3;
+	private static final int PENALTY_N2 =  3;
+	private static final int PENALTY_N3 = 40;
+	private static final int PENALTY_N4 = 10;
+	
+	
+	private static final byte[][] ECC_CODEWORDS_PER_BLOCK = {
+		// Version: (note that index 0 is for padding, and is set to an illegal value)
+		//0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+		{-1,  7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // Low
+		{-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28},  // Medium
+		{-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // Quartile
+		{-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30},  // High
+	};
+	
+	private static final byte[][] NUM_ERROR_CORRECTION_BLOCKS = {
+		// Version: (note that index 0 is for padding, and is set to an illegal value)
+		//0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+		{-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4,  4,  4,  4,  4,  6,  6,  6,  6,  7,  8,  8,  9,  9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25},  // Low
+		{-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5,  5,  8,  9,  9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49},  // Medium
+		{-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8,  8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68},  // Quartile
+		{-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81},  // High
+	};
+	
+	
+	
+	/*---- Public helper enumeration ----*/
+	
+	/**
+	 * The error correction level in a QR Code symbol.
+	 */
+	public enum Ecc {
+		// Must be declared in ascending order of error protection
+		// so that the implicit ordinal() and values() work properly
+		/** The QR Code can tolerate about  7% erroneous codewords. */ LOW(1),
+		/** The QR Code can tolerate about 15% erroneous codewords. */ MEDIUM(0),
+		/** The QR Code can tolerate about 25% erroneous codewords. */ QUARTILE(3),
+		/** The QR Code can tolerate about 30% erroneous codewords. */ HIGH(2);
+		
+		// In the range 0 to 3 (unsigned 2-bit integer).
+		final int formatBits;
+		
+		// Constructor.
+		private Ecc(int fb) {
+			formatBits = fb;
+		}
+	}
+	
+}

Telegram/ThirdParty/QR/java/src/main/java/io/nayuki/qrcodegen/QrSegment.java

@@ -0,0 +1,317 @@
+/* 
+ * QR Code generator library (Java)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.qrcodegen;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+
+/**
+ * A segment of character/binary/control data in a QR Code symbol.
+ * Instances of this class are immutable.
+ * <p>The mid-level way to create a segment is to take the payload data and call a
+ * static factory function such as {@link QrSegment#makeNumeric(CharSequence)}. The low-level
+ * way to create a segment is to custom-make the bit buffer and call the {@link
+ * QrSegment#QrSegment(Mode,int,BitBuffer) constructor} with appropriate values.</p>
+ * <p>This segment class imposes no length restrictions, but QR Codes have restrictions.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * This class can represent kanji mode segments, but provides no help in encoding them
+ * - see {@link QrSegmentAdvanced} for full kanji support.</p>
+ */
+public final class QrSegment {
+	
+	/*---- Static factory functions (mid level) ----*/
+	
+	/**
+	 * Returns a segment representing the specified binary data
+	 * encoded in byte mode. All input byte arrays are acceptable.
+	 * <p>Any text string can be converted to UTF-8 bytes ({@code
+	 * s.getBytes(StandardCharsets.UTF_8)}) and encoded as a byte mode segment.</p>
+	 * @param data the binary data (not {@code null})
+	 * @return a segment (not {@code null}) containing the data
+	 * @throws NullPointerException if the array is {@code null}
+	 */
+	public static QrSegment makeBytes(byte[] data) {
+		Objects.requireNonNull(data);
+		BitBuffer bb = new BitBuffer();
+		for (byte b : data)
+			bb.appendBits(b & 0xFF, 8);
+		return new QrSegment(Mode.BYTE, data.length, bb);
+	}
+	
+	
+	/**
+	 * Returns a segment representing the specified string of decimal digits encoded in numeric mode.
+	 * @param digits the text (not {@code null}), with only digits from 0 to 9 allowed
+	 * @return a segment (not {@code null}) containing the text
+	 * @throws NullPointerException if the string is {@code null}
+	 * @throws IllegalArgumentException if the string contains non-digit characters
+	 */
+	public static QrSegment makeNumeric(CharSequence digits) {
+		Objects.requireNonNull(digits);
+		if (!isNumeric(digits))
+			throw new IllegalArgumentException("String contains non-numeric characters");
+		
+		BitBuffer bb = new BitBuffer();
+		for (int i = 0; i < digits.length(); ) {  // Consume up to 3 digits per iteration
+			int n = Math.min(digits.length() - i, 3);
+			bb.appendBits(Integer.parseInt(digits.subSequence(i, i + n).toString()), n * 3 + 1);
+			i += n;
+		}
+		return new QrSegment(Mode.NUMERIC, digits.length(), bb);
+	}
+	
+	
+	/**
+	 * Returns a segment representing the specified text string encoded in alphanumeric mode.
+	 * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+	 * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	 * @param text the text (not {@code null}), with only certain characters allowed
+	 * @return a segment (not {@code null}) containing the text
+	 * @throws NullPointerException if the string is {@code null}
+	 * @throws IllegalArgumentException if the string contains non-encodable characters
+	 */
+	public static QrSegment makeAlphanumeric(CharSequence text) {
+		Objects.requireNonNull(text);
+		if (!isAlphanumeric(text))
+			throw new IllegalArgumentException("String contains unencodable characters in alphanumeric mode");
+		
+		BitBuffer bb = new BitBuffer();
+		int i;
+		for (i = 0; i <= text.length() - 2; i += 2) {  // Process groups of 2
+			int temp = ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
+			temp += ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+			bb.appendBits(temp, 11);
+		}
+		if (i < text.length())  // 1 character remaining
+			bb.appendBits(ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6);
+		return new QrSegment(Mode.ALPHANUMERIC, text.length(), bb);
+	}
+	
+	
+	/**
+	 * Returns a list of zero or more segments to represent the specified Unicode text string.
+	 * The result may use various segment modes and switch modes to optimize the length of the bit stream.
+	 * @param text the text to be encoded, which can be any Unicode string
+	 * @return a new mutable list (not {@code null}) of segments (not {@code null}) containing the text
+	 * @throws NullPointerException if the text is {@code null}
+	 */
+	public static List<QrSegment> makeSegments(CharSequence text) {
+		Objects.requireNonNull(text);
+		
+		// Select the most efficient segment encoding automatically
+		List<QrSegment> result = new ArrayList<>();
+		if (text.equals(""));  // Leave result empty
+		else if (isNumeric(text))
+			result.add(makeNumeric(text));
+		else if (isAlphanumeric(text))
+			result.add(makeAlphanumeric(text));
+		else
+			result.add(makeBytes(text.toString().getBytes(StandardCharsets.UTF_8)));
+		return result;
+	}
+	
+	
+	/**
+	 * Returns a segment representing an Extended Channel Interpretation
+	 * (ECI) designator with the specified assignment value.
+	 * @param assignVal the ECI assignment number (see the AIM ECI specification)
+	 * @return a segment (not {@code null}) containing the data
+	 * @throws IllegalArgumentException if the value is outside the range [0, 10<sup>6</sup>)
+	 */
+	public static QrSegment makeEci(int assignVal) {
+		BitBuffer bb = new BitBuffer();
+		if (assignVal < 0)
+			throw new IllegalArgumentException("ECI assignment value out of range");
+		else if (assignVal < (1 << 7))
+			bb.appendBits(assignVal, 8);
+		else if (assignVal < (1 << 14)) {
+			bb.appendBits(0b10, 2);
+			bb.appendBits(assignVal, 14);
+		} else if (assignVal < 1_000_000) {
+			bb.appendBits(0b110, 3);
+			bb.appendBits(assignVal, 21);
+		} else
+			throw new IllegalArgumentException("ECI assignment value out of range");
+		return new QrSegment(Mode.ECI, 0, bb);
+	}
+	
+	
+	/**
+	 * Tests whether the specified string can be encoded as a segment in numeric mode.
+	 * A string is encodable iff each character is in the range 0 to 9.
+	 * @param text the string to test for encodability (not {@code null})
+	 * @return {@code true} iff each character is in the range 0 to 9.
+	 * @throws NullPointerException if the string is {@code null}
+	 * @see #makeNumeric(CharSequence)
+	 */
+	public static boolean isNumeric(CharSequence text) {
+		return NUMERIC_REGEX.matcher(text).matches();
+	}
+	
+	
+	/**
+	 * Tests whether the specified string can be encoded as a segment in alphanumeric mode.
+	 * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+	 * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	 * @param text the string to test for encodability (not {@code null})
+	 * @return {@code true} iff each character is in the alphanumeric mode character set
+	 * @throws NullPointerException if the string is {@code null}
+	 * @see #makeAlphanumeric(CharSequence)
+	 */
+	public static boolean isAlphanumeric(CharSequence text) {
+		return ALPHANUMERIC_REGEX.matcher(text).matches();
+	}
+	
+	
+	
+	/*---- Instance fields ----*/
+	
+	/** The mode indicator of this segment. Not {@code null}. */
+	public final Mode mode;
+	
+	/** The length of this segment's unencoded data. Measured in characters for
+	 * numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	 * Always zero or positive. Not the same as the data's bit length. */
+	public final int numChars;
+	
+	// The data bits of this segment. Not null. Accessed through getData().
+	final BitBuffer data;
+	
+	
+	/*---- Constructor (low level) ----*/
+	
+	/**
+	 * Constructs a QR Code segment with the specified attributes and data.
+	 * The character count (numCh) must agree with the mode and the bit buffer length,
+	 * but the constraint isn't checked. The specified bit buffer is cloned and stored.
+	 * @param md the mode (not {@code null})
+	 * @param numCh the data length in characters or bytes, which is non-negative
+	 * @param data the data bits (not {@code null})
+	 * @throws NullPointerException if the mode or data is {@code null}
+	 * @throws IllegalArgumentException if the character count is negative
+	 */
+	public QrSegment(Mode md, int numCh, BitBuffer data) {
+		mode = Objects.requireNonNull(md);
+		Objects.requireNonNull(data);
+		if (numCh < 0)
+			throw new IllegalArgumentException("Invalid value");
+		numChars = numCh;
+		this.data = data.clone();  // Make defensive copy
+	}
+	
+	
+	/*---- Methods ----*/
+	
+	/**
+	 * Returns the data bits of this segment.
+	 * @return a new copy of the data bits (not {@code null})
+	 */
+	public BitBuffer getData() {
+		return data.clone();  // Make defensive copy
+	}
+	
+	
+	// Calculates the number of bits needed to encode the given segments at the given version.
+	// Returns a non-negative number if successful. Otherwise returns -1 if a segment has too
+	// many characters to fit its length field, or the total bits exceeds Integer.MAX_VALUE.
+	static int getTotalBits(List<QrSegment> segs, int version) {
+		Objects.requireNonNull(segs);
+		long result = 0;
+		for (QrSegment seg : segs) {
+			Objects.requireNonNull(seg);
+			int ccbits = seg.mode.numCharCountBits(version);
+			if (seg.numChars >= (1 << ccbits))
+				return -1;  // The segment's length doesn't fit the field's bit width
+			result += 4L + ccbits + seg.data.bitLength();
+			if (result > Integer.MAX_VALUE)
+				return -1;  // The sum will overflow an int type
+		}
+		return (int)result;
+	}
+	
+	
+	/*---- Constants ----*/
+	
+	// Describes precisely all strings that are encodable in numeric mode.
+	private static final Pattern NUMERIC_REGEX = Pattern.compile("[0-9]*");
+	
+	// Describes precisely all strings that are encodable in alphanumeric mode.
+	private static final Pattern ALPHANUMERIC_REGEX = Pattern.compile("[A-Z0-9 $%*+./:-]*");
+	
+	// The set of all legal characters in alphanumeric mode, where
+	// each character value maps to the index in the string.
+	static final String ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+	
+	
+	
+	/*---- Public helper enumeration ----*/
+	
+	/**
+	 * Describes how a segment's data bits are interpreted.
+	 */
+	public enum Mode {
+		
+		/*-- Constants --*/
+		
+		NUMERIC     (0x1, 10, 12, 14),
+		ALPHANUMERIC(0x2,  9, 11, 13),
+		BYTE        (0x4,  8, 16, 16),
+		KANJI       (0x8,  8, 10, 12),
+		ECI         (0x7,  0,  0,  0);
+		
+		
+		/*-- Fields --*/
+		
+		// The mode indicator bits, which is a uint4 value (range 0 to 15).
+		final int modeBits;
+		
+		// Number of character count bits for three different version ranges.
+		private final int[] numBitsCharCount;
+		
+		
+		/*-- Constructor --*/
+		
+		private Mode(int mode, int... ccbits) {
+			modeBits = mode;
+			numBitsCharCount = ccbits;
+		}
+		
+		
+		/*-- Method --*/
+		
+		// Returns the bit width of the character count field for a segment in this mode
+		// in a QR Code at the given version number. The result is in the range [0, 16].
+		int numCharCountBits(int ver) {
+			assert QrCode.MIN_VERSION <= ver && ver <= QrCode.MAX_VERSION;
+			return numBitsCharCount[(ver + 7) / 17];
+		}
+		
+	}
+	
+}

Telegram/ThirdParty/QR/java/src/main/java/io/nayuki/qrcodegen/QrSegmentAdvanced.java

@@ -0,0 +1,432 @@
+/* 
+ * QR Code generator library - Optional advanced logic (Java)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+package io.nayuki.qrcodegen;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.List;
+import java.util.Objects;
+import io.nayuki.qrcodegen.QrSegment.Mode;
+
+
+/**
+ * Splits text into optimal segments and encodes kanji segments.
+ * Provides static functions only; not instantiable.
+ * @see QrSegment
+ * @see QrCode
+ */
+public final class QrSegmentAdvanced {
+	
+	/*---- Optimal list of segments encoder ----*/
+	
+	/**
+	 * Returns a list of zero or more segments to represent the specified Unicode text string.
+	 * The resulting list optimally minimizes the total encoded bit length, subjected to the constraints
+	 * in the specified {error correction level, minimum version number, maximum version number}.
+	 * <p>This function can utilize all four text encoding modes: numeric, alphanumeric, byte (UTF-8),
+	 * and kanji. This can be considered as a sophisticated but slower replacement for {@link
+	 * QrSegment#makeSegments(CharSequence)}. This requires more input parameters because it searches a
+	 * range of versions, like {@link QrCode#encodeSegments(List,QrCode.Ecc,int,int,int,boolean)}.</p>
+	 * @param text the text to be encoded (not {@code null}), which can be any Unicode string
+	 * @param ecl the error correction level to use (not {@code null})
+	 * @param minVersion the minimum allowed version of the QR Code (at least 1)
+	 * @param maxVersion the maximum allowed version of the QR Code (at most 40)
+	 * @return a new mutable list (not {@code null}) of segments (not {@code null})
+	 * containing the text, minimizing the bit length with respect to the constraints
+	 * @throws NullPointerException if the text or error correction level is {@code null}
+	 * @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40 is violated
+	 * @throws DataTooLongException if the text fails to fit in the maxVersion QR Code at the ECL
+	 */
+	public static List<QrSegment> makeSegmentsOptimally(CharSequence text, QrCode.Ecc ecl, int minVersion, int maxVersion) {
+		// Check arguments
+		Objects.requireNonNull(text);
+		Objects.requireNonNull(ecl);
+		if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION))
+			throw new IllegalArgumentException("Invalid value");
+		
+		// Iterate through version numbers, and make tentative segments
+		List<QrSegment> segs = null;
+		int[] codePoints = toCodePoints(text);
+		for (int version = minVersion; ; version++) {
+			if (version == minVersion || version == 10 || version == 27)
+				segs = makeSegmentsOptimally(codePoints, version);
+			assert segs != null;
+			
+			// Check if the segments fit
+			int dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8;  // Number of data bits available
+			int dataUsedBits = QrSegment.getTotalBits(segs, version);
+			if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
+				return segs;  // This version number is found to be suitable
+			if (version >= maxVersion) {  // All versions in the range could not fit the given text
+				String msg = "Segment too long";
+				if (dataUsedBits != -1)
+					msg = String.format("Data length = %d bits, Max capacity = %d bits", dataUsedBits, dataCapacityBits);
+				throw new DataTooLongException(msg);
+			}
+		}
+	}
+	
+	
+	// Returns a new list of segments that is optimal for the given text at the given version number.
+	private static List<QrSegment> makeSegmentsOptimally(int[] codePoints, int version) {
+		if (codePoints.length == 0)
+			return new ArrayList<>();
+		Mode[] charModes = computeCharacterModes(codePoints, version);
+		return splitIntoSegments(codePoints, charModes);
+	}
+	
+	
+	// Returns a new array representing the optimal mode per code point based on the given text and version.
+	private static Mode[] computeCharacterModes(int[] codePoints, int version) {
+		if (codePoints.length == 0)
+			throw new IllegalArgumentException();
+		if (codePoints.length > 7089)  // Upper bound is the number of characters that fit in QR Code version 40, low error correction, numeric mode
+			throw new DataTooLongException("String too long");
+		final Mode[] modeTypes = {Mode.BYTE, Mode.ALPHANUMERIC, Mode.NUMERIC, Mode.KANJI};  // Do not modify
+		final int numModes = modeTypes.length;
+		
+		// Segment header sizes, measured in 1/6 bits
+		final int[] headCosts = new int[numModes];
+		for (int i = 0; i < numModes; i++) {
+			headCosts[i] = (4 + modeTypes[i].numCharCountBits(version)) * 6;
+			assert 0 <= headCosts[i] && headCosts[i] <= (4 + 16) * 6;
+		}
+		
+		// charModes[i][j] represents the mode to encode the code point at
+		// index i such that the final segment ends in modeTypes[j] and the
+		// total number of bits is minimized over all possible choices
+		Mode[][] charModes = new Mode[codePoints.length][numModes];
+		
+		// At the beginning of each iteration of the loop below,
+		// prevCosts[j] is the exact minimum number of 1/6 bits needed to
+		// encode the entire string prefix of length i, and end in modeTypes[j]
+		int[] prevCosts = headCosts.clone();
+		
+		// Calculate costs using dynamic programming
+		for (int i = 0; i < codePoints.length; i++) {
+			int c = codePoints[i];
+			int[] curCosts = new int[numModes];
+			{  // Always extend a byte mode segment
+				curCosts[0] = prevCosts[0] + countUtf8Bytes(c) * 8 * 6;
+				charModes[i][0] = modeTypes[0];
+			}
+			// Extend a segment if possible
+			if (QrSegment.ALPHANUMERIC_CHARSET.indexOf(c) != -1) {  // Is alphanumeric
+				curCosts[1] = prevCosts[1] + 33;  // 5.5 bits per alphanumeric char
+				charModes[i][1] = modeTypes[1];
+			}
+			if ('0' <= c && c <= '9') {  // Is numeric
+				curCosts[2] = prevCosts[2] + 20;  // 3.33 bits per digit
+				charModes[i][2] = modeTypes[2];
+			}
+			if (isKanji(c)) {
+				curCosts[3] = prevCosts[3] + 78;  // 13 bits per Shift JIS char
+				charModes[i][3] = modeTypes[3];
+			}
+			
+			// Start new segment at the end to switch modes
+			for (int j = 0; j < numModes; j++) {  // To mode
+				for (int k = 0; k < numModes; k++) {  // From mode
+					int newCost = (curCosts[k] + 5) / 6 * 6 + headCosts[j];
+					if (charModes[i][k] != null && (charModes[i][j] == null || newCost < curCosts[j])) {
+						curCosts[j] = newCost;
+						charModes[i][j] = modeTypes[k];
+					}
+				}
+			}
+			
+			// A non-tight upper bound is when each of 7089 characters switches to
+			// byte mode (4-bit header + 16-bit count) and requires 4 bytes in UTF-8
+			for (int cost : curCosts)
+				assert 0 <= cost && cost <= (4 + 16 + 32) * 6 * 7089;
+			prevCosts = curCosts;
+		}
+		
+		// Find optimal ending mode
+		Mode curMode = null;
+		for (int i = 0, minCost = 0; i < numModes; i++) {
+			if (curMode == null || prevCosts[i] < minCost) {
+				minCost = prevCosts[i];
+				curMode = modeTypes[i];
+			}
+		}
+		
+		// Get optimal mode for each code point by tracing backwards
+		Mode[] result = new Mode[charModes.length];
+		for (int i = result.length - 1; i >= 0; i--) {
+			for (int j = 0; j < numModes; j++) {
+				if (modeTypes[j] == curMode) {
+					curMode = charModes[i][j];
+					result[i] = curMode;
+					break;
+				}
+			}
+		}
+		return result;
+	}
+	
+	
+	// Returns a new list of segments based on the given text and modes, such that
+	// consecutive code points in the same mode are put into the same segment.
+	private static List<QrSegment> splitIntoSegments(int[] codePoints, Mode[] charModes) {
+		if (codePoints.length == 0)
+			throw new IllegalArgumentException();
+		List<QrSegment> result = new ArrayList<>();
+		
+		// Accumulate run of modes
+		Mode curMode = charModes[0];
+		int start = 0;
+		for (int i = 1; ; i++) {
+			if (i < codePoints.length && charModes[i] == curMode)
+				continue;
+			String s = new String(codePoints, start, i - start);
+			if (curMode == Mode.BYTE)
+				result.add(QrSegment.makeBytes(s.getBytes(StandardCharsets.UTF_8)));
+			else if (curMode == Mode.NUMERIC)
+				result.add(QrSegment.makeNumeric(s));
+			else if (curMode == Mode.ALPHANUMERIC)
+				result.add(QrSegment.makeAlphanumeric(s));
+			else if (curMode == Mode.KANJI)
+				result.add(makeKanji(s));
+			else
+				throw new AssertionError();
+			if (i >= codePoints.length)
+				return result;
+			curMode = charModes[i];
+			start = i;
+		}
+	}
+	
+	
+	// Returns a new array of Unicode code points (effectively
+	// UTF-32 / UCS-4) representing the given UTF-16 string.
+	private static int[] toCodePoints(CharSequence s) {
+		int[] result = s.codePoints().toArray();
+		for (int c : result) {
+			if (Character.isSurrogate((char)c))
+				throw new IllegalArgumentException("Invalid UTF-16 string");
+		}
+		return result;
+	}
+	
+	
+	// Returns the number of UTF-8 bytes needed to encode the given Unicode code point.
+	private static int countUtf8Bytes(int cp) {
+		if      (cp <        0) throw new IllegalArgumentException("Invalid code point");
+		else if (cp <     0x80) return 1;
+		else if (cp <    0x800) return 2;
+		else if (cp <  0x10000) return 3;
+		else if (cp < 0x110000) return 4;
+		else                    throw new IllegalArgumentException("Invalid code point");
+	}
+	
+	
+	
+	/*---- Kanji mode segment encoder ----*/
+	
+	/**
+	 * Returns a segment representing the specified text string encoded in kanji mode.
+	 * Broadly speaking, the set of encodable characters are {kanji used in Japan,
+	 * hiragana, katakana, East Asian punctuation, full-width ASCII, Greek, Cyrillic}.
+	 * Examples of non-encodable characters include {ordinary ASCII, half-width katakana,
+	 * more extensive Chinese hanzi}.
+	 * @param text the text (not {@code null}), with only certain characters allowed
+	 * @return a segment (not {@code null}) containing the text
+	 * @throws NullPointerException if the string is {@code null}
+	 * @throws IllegalArgumentException if the string contains non-encodable characters
+	 * @see #isEncodableAsKanji(CharSequence)
+	 */
+	public static QrSegment makeKanji(CharSequence text) {
+		Objects.requireNonNull(text);
+		BitBuffer bb = new BitBuffer();
+		text.chars().forEachOrdered(c -> {
+			int val = UNICODE_TO_QR_KANJI[c];
+			if (val == -1)
+				throw new IllegalArgumentException("String contains non-kanji-mode characters");
+			bb.appendBits(val, 13);
+		});
+		return new QrSegment(Mode.KANJI, text.length(), bb);
+	}
+	
+	
+	/**
+	 * Tests whether the specified string can be encoded as a segment in kanji mode.
+	 * Broadly speaking, the set of encodable characters are {kanji used in Japan,
+	 * hiragana, katakana, East Asian punctuation, full-width ASCII, Greek, Cyrillic}.
+	 * Examples of non-encodable characters include {ordinary ASCII, half-width katakana,
+	 * more extensive Chinese hanzi}.
+	 * @param text the string to test for encodability (not {@code null})
+	 * @return {@code true} iff each character is in the kanji mode character set
+	 * @throws NullPointerException if the string is {@code null}
+	 * @see #makeKanji(CharSequence)
+	 */
+	public static boolean isEncodableAsKanji(CharSequence text) {
+		Objects.requireNonNull(text);
+		return text.chars().allMatch(
+			c -> isKanji((char)c));
+	}
+	
+	
+	private static boolean isKanji(int c) {
+		return c < UNICODE_TO_QR_KANJI.length && UNICODE_TO_QR_KANJI[c] != -1;
+	}
+	
+	
+	// Data derived from ftp://ftp.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/SHIFTJIS.TXT
+	private static final String PACKED_QR_KANJI_TO_UNICODE =
+		"MAAwATAC/wz/DjD7/xr/G/8f/wEwmzCcALT/QACo/z7/4/8/MP0w/jCdMJ4wA07dMAUwBjAHMPwgFSAQ/w8AXDAcIBb/XCAmICUgGCAZIBwgHf8I/wkwFDAV/zv/Pf9b/10wCDAJMAowCzAMMA0wDjAPMBAwEf8LIhIAsQDX//8A9/8dImD/HP8eImYiZyIeIjQmQiZA" +
+		"ALAgMiAzIQP/5f8EAKIAo/8F/wP/Bv8K/yAApyYGJgUlyyXPJc4lxyXGJaEloCWzJbIlvSW8IDswEiGSIZAhkSGTMBP/////////////////////////////IggiCyKGIocigiKDIioiKf////////////////////8iJyIoAKwh0iHUIgAiA///////////////////" +
+		"//////////8iICKlIxIiAiIHImEiUiJqImsiGiI9Ih0iNSIrIiz//////////////////yErIDAmbyZtJmogICAhALb//////////yXv/////////////////////////////////////////////////xD/Ef8S/xP/FP8V/xb/F/8Y/xn///////////////////8h" +
+		"/yL/I/8k/yX/Jv8n/yj/Kf8q/yv/LP8t/y7/L/8w/zH/Mv8z/zT/Nf82/zf/OP85/zr///////////////////9B/0L/Q/9E/0X/Rv9H/0j/Sf9K/0v/TP9N/07/T/9Q/1H/Uv9T/1T/Vf9W/1f/WP9Z/1r//////////zBBMEIwQzBEMEUwRjBHMEgwSTBKMEswTDBN" +
+		"ME4wTzBQMFEwUjBTMFQwVTBWMFcwWDBZMFowWzBcMF0wXjBfMGAwYTBiMGMwZDBlMGYwZzBoMGkwajBrMGwwbTBuMG8wcDBxMHIwczB0MHUwdjB3MHgweTB6MHswfDB9MH4wfzCAMIEwgjCDMIQwhTCGMIcwiDCJMIowizCMMI0wjjCPMJAwkTCSMJP/////////////" +
+		"////////////////////////MKEwojCjMKQwpTCmMKcwqDCpMKowqzCsMK0wrjCvMLAwsTCyMLMwtDC1MLYwtzC4MLkwujC7MLwwvTC+ML8wwDDBMMIwwzDEMMUwxjDHMMgwyTDKMMswzDDNMM4wzzDQMNEw0jDTMNQw1TDWMNcw2DDZMNow2zDcMN0w3jDf//8w4DDh" +
+		"MOIw4zDkMOUw5jDnMOgw6TDqMOsw7DDtMO4w7zDwMPEw8jDzMPQw9TD2/////////////////////wORA5IDkwOUA5UDlgOXA5gDmQOaA5sDnAOdA54DnwOgA6EDowOkA6UDpgOnA6gDqf////////////////////8DsQOyA7MDtAO1A7YDtwO4A7kDugO7A7wDvQO+" +
+		"A78DwAPBA8MDxAPFA8YDxwPIA8n/////////////////////////////////////////////////////////////////////////////////////////////////////////////BBAEEQQSBBMEFAQVBAEEFgQXBBgEGQQaBBsEHAQdBB4EHwQgBCEEIgQjBCQEJQQm" +
+		"BCcEKAQpBCoEKwQsBC0ELgQv////////////////////////////////////////BDAEMQQyBDMENAQ1BFEENgQ3BDgEOQQ6BDsEPAQ9//8EPgQ/BEAEQQRCBEMERARFBEYERwRIBEkESgRLBEwETQROBE///////////////////////////////////yUAJQIlDCUQ" +
+		"JRglFCUcJSwlJCU0JTwlASUDJQ8lEyUbJRclIyUzJSslOyVLJSAlLyUoJTclPyUdJTAlJSU4JUL/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"/////////////////////////////////////06cVRZaA5Y/VMBhG2MoWfaQIoR1gxx6UGCqY+FuJWXthGaCppv1aJNXJ2WhYnFbm1nQhnuY9H1ifb6bjmIWfJ+It1uJXrVjCWaXaEiVx5eNZ09O5U8KT01PnVBJVvJZN1nUWgFcCWDfYQ9hcGYTaQVwunVPdXB5+32t" +
+		"fe+Aw4QOiGOLApBVkHpTO06VTqVX34CykMF4704AWPFuopA4ejKDKIKLnC9RQVNwVL1U4VbgWftfFZjybeuA5IUt////////lmKWcJagl/tUC1PzW4dwz3+9j8KW6FNvnVx6uk4ReJOB/G4mVhhVBGsdhRqcO1nlU6ltZnTclY9WQk6RkEuW8oNPmQxT4VW2WzBfcWYg" +
+		"ZvNoBGw4bPNtKXRbdsh6Tpg0gvGIW4pgku1tsnWrdsqZxWCmiwGNipWyaY5TrVGG//9XElgwWURbtF72YChjqWP0bL9vFHCOcRRxWXHVcz9+AYJ2gtGFl5BgkludG1hpZbxsWnUlUflZLlllX4Bf3GK8ZfpqKmsna7Rzi3/BiVadLJ0OnsRcoWyWg3tRBFxLYbaBxmh2" +
+		"cmFOWU/6U3hgaW4pek+X804LUxZO7k9VTz1PoU9zUqBT71YJWQ9awVu2W+F50WaHZ5xntmtMbLNwa3PCeY15vno8e4eCsYLbgwSDd4Pvg9OHZoqyVimMqI/mkE6XHoaKT8Rc6GIRcll1O4Hlgr2G/ozAlsWZE5nVTstPGonjVt5YSljKXvtf62AqYJRgYmHQYhJi0GU5" +
+		"////////m0FmZmiwbXdwcHVMdoZ9dYKlh/mVi5aOjJ1R8VK+WRZUs1uzXRZhaGmCba94jYTLiFeKcpOnmrhtbJmohtlXo2f/hs6SDlKDVodUBF7TYuFkuWg8aDhru3NyeLp6a4maidKNa48DkO2Vo5aUl2lbZlyzaX2YTZhOY5t7IGor//9qf2i2nA1vX1JyVZ1gcGLs" +
+		"bTtuB27RhFuJEI9EThScOVP2aRtqOpeEaCpRXHrDhLKR3JOMVludKGgigwWEMXylUgiCxXTmTn5Pg1GgW9JSClLYUudd+1WaWCpZ5luMW5hb215yXnlgo2EfYWNhvmPbZWJn0WhTaPprPmtTbFdvIm+Xb0V0sHUYduN3C3r/e6F8IX3pfzZ/8ICdgmaDnomzisyMq5CE" +
+		"lFGVk5WRlaKWZZfTmSiCGE44VCtcuF3Mc6l2THc8XKl/640LlsGYEZhUmFhPAU8OU3FVnFZoV/pZR1sJW8RckF4MXn5fzGPuZzpl12XiZx9oy2jE////////al9eMGvFbBdsfXV/eUhbY3oAfQBfvYmPihiMtI13jsyPHZjimg6bPE6AUH1RAFmTW5xiL2KAZOxrOnKg" +
+		"dZF5R3+ph/uKvItwY6yDypegVAlUA1WraFRqWIpweCdndZ7NU3RbooEahlCQBk4YTkVOx08RU8pUOFuuXxNgJWVR//9nPWxCbHJs43B4dAN6dnquewh9Gnz+fWZl53JbU7tcRV3oYtJi4GMZbiCGWooxjd2S+G8BeaabWk6oTqtOrE+bT6BQ0VFHevZRcVH2U1RTIVN/" +
+		"U+tVrFiDXOFfN19KYC9gUGBtYx9lWWpLbMFywnLtd++A+IEFggiFTpD3k+GX/5lXmlpO8FHdXC1mgWltXEBm8ml1c4loUHyBUMVS5FdHXf6TJmWkayNrPXQ0eYF5vXtLfcqCuYPMiH+JX4s5j9GR0VQfkoBOXVA2U+VTOnLXc5Z36YLmjq+ZxpnImdJRd2Eahl5VsHp6" +
+		"UHZb05BHloVOMmrbkedcUVxI////////Y5h6n2yTl3SPYXqqcYqWiHyCaBd+cGhRk2xS8lQbhauKE3+kjs2Q4VNmiIh5QU/CUL5SEVFEVVNXLXPqV4tZUV9iX4RgdWF2YWdhqWOyZDplbGZvaEJuE3Vmej18+31MfZl+S39rgw6DSobNigiKY4tmjv2YGp2PgriPzpvo" +
+		"//9Sh2IfZINvwJaZaEFQkWsgbHpvVHp0fVCIQIojZwhO9lA5UCZQZVF8UjhSY1WnVw9YBVrMXvphsmH4YvNjcmkcailyfXKscy54FHhvfXl3DICpiYuLGYzijtKQY5N1lnqYVZoTnnhRQ1OfU7Nee18mbhtukHOEc/59Q4I3igCK+pZQTk5QC1PkVHxW+lnRW2Rd8V6r" +
+		"XydiOGVFZ69uVnLQfMqItIChgOGD8IZOioeN6JI3lseYZ58TTpROkk8NU0hUSVQ+Wi9fjF+hYJ9op2qOdFp4gYqeiqSLd5GQTl6byU6kT3xPr1AZUBZRSVFsUp9SuVL+U5pT41QR////////VA5ViVdRV6JZfVtUW11bj13lXedd9154XoNeml63XxhgUmFMYpdi2GOn" +
+		"ZTtmAmZDZvRnbWghaJdpy2xfbSptaW4vbp11MnaHeGx6P3zgfQV9GH1efbGAFYADgK+AsYFUgY+CKoNSiEyIYYsbjKKM/JDKkXWScXg/kvyVpJZN//+YBZmZmtidO1JbUqtT91QIWNVi92/gjGqPX565UUtSO1RKVv16QJF3nWCe0nNEbwmBcHURX/1g2pqoctuPvGtk" +
+		"mANOylbwV2RYvlpaYGhhx2YPZgZoOWixbfd11X06gm6bQk6bT1BTyVUGXW9d5l3uZ/tsmXRzeAKKUJOWiN9XUF6nYytQtVCsUY1nAFTJWF5Zu1uwX2liTWOhaD1rc24IcH2Rx3KAeBV4JnltZY59MIPciMGPCZabUmRXKGdQf2qMoVG0V0KWKlg6aYqAtFSyXQ5X/HiV" +
+		"nfpPXFJKVItkPmYoZxRn9XqEe1Z9IpMvaFybrXs5UxlRilI3////////W99i9mSuZOZnLWu6hamW0XaQm9ZjTJMGm6t2v2ZSTglQmFPCXHFg6GSSZWNoX3Hmc8p1I3uXfoKGlYuDjNuReJkQZaxmq2uLTtVO1E86T39SOlP4U/JV41bbWOtZy1nJWf9bUFxNXgJeK1/X" +
+		"YB1jB2UvW1xlr2W9ZehnnWti//9re2wPc0V5SXnBfPh9GX0rgKKBAoHziZaKXoppimaKjIrujMeM3JbMmPxrb06LTzxPjVFQW1db+mFIYwFmQmshbstsu3I+dL111HjBeTqADIAzgeqElI+ebFCef18Pi1idK3r6jvhbjZbrTgNT8Vf3WTFayVukYIluf28Gdb6M6luf" +
+		"hQB74FByZ/SCnVxhhUp+HoIOUZlcBGNojWZlnHFueT59F4AFix2OypBuhseQqlAfUvpcOmdTcHxyNZFMkciTK4LlW8JfMWD5TjtT1luIYktnMWuKculz4HougWuNo5FSmZZRElPXVGpb/2OIajl9rJcAVtpTzlRo////////W5dcMV3eT+5hAWL+bTJ5wHnLfUJ+TX/S" +
+		"ge2CH4SQiEaJcouQjnSPL5AxkUuRbJbGkZxOwE9PUUVTQV+TYg5n1GxBbgtzY34mkc2Sg1PUWRlbv23ReV1+LnybWH5xn1H6iFOP8E/KXPtmJXeseuOCHJn/UcZfqmXsaW9riW3z//9ulm9kdv59FF3hkHWRh5gGUeZSHWJAZpFm2W4aXrZ90n9yZviFr4X3ivhSqVPZ" +
+		"WXNej1+QYFWS5JZkULdRH1LdUyBTR1PsVOhVRlUxVhdZaFm+WjxbtVwGXA9cEVwaXoReil7gX3Bif2KEYttjjGN3ZgdmDGYtZnZnfmiiah9qNWy8bYhuCW5YcTxxJnFndcd3AXhdeQF5ZXnweuB7EXynfTmAloPWhIuFSYhdiPOKH4o8ilSKc4xhjN6RpJJmk36UGJac" +
+		"l5hOCk4ITh5OV1GXUnBXzlg0WMxbIl44YMVk/mdhZ1ZtRHK2dXN6Y4S4i3KRuJMgVjFX9Jj+////////Yu1pDWuWce1+VIB3gnKJ5pjfh1WPsVw7TzhP4U+1VQdaIFvdW+lfw2FOYy9lsGZLaO5pm214bfF1M3W5dx95XnnmfTOB44KvhaqJqoo6jquPm5Aykd2XB066" +
+		"TsFSA1h1WOxcC3UaXD2BTooKj8WWY5dteyWKz5gIkWJW81Oo//+QF1Q5V4JeJWOobDRwindhfIt/4IhwkEKRVJMQkxiWj3RemsRdB11pZXBnoo2olttjbmdJaRmDxZgXlsCI/m+EZHpb+E4WcCx1XWYvUcRSNlLiWdNfgWAnYhBlP2V0Zh9mdGjyaBZrY24FcnJ1H3bb" +
+		"fL6AVljwiP2Jf4qgipOKy5AdkZKXUpdZZYl6DoEGlrteLWDcYhplpWYUZ5B383pNfE1+PoEKjKyNZI3hjl94qVIHYtljpWRCYpiKLXqDe8CKrJbqfXaCDIdJTtlRSFNDU2Bbo1wCXBZd3WImYkdksGgTaDRsyW1FbRdn029ccU5xfWXLen97rX3a////////fkp/qIF6" +
+		"ghuCOYWmim6Mzo31kHiQd5KtkpGVg5uuUk1VhG84cTZRaHmFflWBs3zOVkxYUVyoY6pm/mb9aVpy2XWPdY55DnlWed98l30gfUSGB4o0ljuQYZ8gUOdSdVPMU+JQCVWqWO5ZT3I9W4tcZFMdYONg82NcY4NjP2O7//9kzWXpZvld42nNaf1vFXHlTol16Xb4epN8333P" +
+		"fZyAYYNJg1iEbIS8hfuIxY1wkAGQbZOXlxyaElDPWJdhjoHThTWNCJAgT8NQdFJHU3Ngb2NJZ19uLI2zkB9P11xejMplz32aU1KIllF2Y8NbWFtrXApkDWdRkFxO1lkaWSpscIpRVT5YFVmlYPBiU2fBgjVpVZZAmcSaKE9TWAZb/oAQXLFeL1+FYCBhS2I0Zv9s8G7e" +
+		"gM6Bf4LUiIuMuJAAkC6Wip7bm9tO41PwWSd7LJGNmEyd+W7dcCdTU1VEW4ViWGKeYtNsom/vdCKKF5Q4b8GK/oM4UeeG+FPq////////U+lPRpBUj7BZaoExXf166o+/aNqMN3L4nEhqPYqwTjlTWFYGV2ZixWOiZeZrTm3hbltwrXfteu97qn27gD2AxobLipWTW1bj" +
+		"WMdfPmWtZpZqgGu1dTeKx1Akd+VXMF8bYGVmemxgdfR6Gn9ugfSHGJBFmbN7yXVcevl7UYTE//+QEHnpepKDNlrhd0BOLU7yW5lf4GK9Zjxn8WzohmuId4o7kU6S85nQahdwJnMqgueEV4yvTgFRRlHLVYtb9V4WXjNegV8UXzVfa1+0YfJjEWaiZx1vbnJSdTp3OoB0" +
+		"gTmBeId2ir+K3I2FjfOSmpV3mAKc5VLFY1d29GcVbIhzzYzDk66Wc20lWJxpDmnMj/2TmnXbkBpYWmgCY7Rp+09Dbyxn2I+7hSZ9tJNUaT9vcFdqWPdbLH0scipUCpHjnbROrU9OUFxQdVJDjJ5USFgkW5peHV6VXq1e918fYIxitWM6Y9Bor2xAeId5jnoLfeCCR4oC" +
+		"iuaORJAT////////kLiRLZHYnw5s5WRYZOJldW70doR7G5Bpk9FuulTyX7lkpI9Nj+2SRFF4WGtZKVxVXpdt+36PdRyMvI7imFtwuU8da79vsXUwlvtRTlQQWDVYV1msXGBfkmWXZ1xuIXZ7g9+M7ZAUkP2TTXgleDpSql6mVx9ZdGASUBJRWlGs//9RzVIAVRBYVFhY" +
+		"WVdblVz2XYtgvGKVZC1ncWhDaLxo33bXbdhub22bcG9xyF9Tddh5d3tJe1R7UnzWfXFSMIRjhWmF5IoOiwSMRo4PkAOQD5QZlnaYLZowldhQzVLVVAxYAlwOYadknm0ed7N65YD0hASQU5KFXOCdB1M/X5dfs22ccnl3Y3m/e+Rr0nLsiq1oA2phUfh6gWk0XEqc9oLr" +
+		"W8WRSXAeVnhcb2DHZWZsjIxakEGYE1RRZseSDVlIkKNRhU5NUeqFmYsOcFhjepNLaWKZtH4EdXdTV2lgjt+W42xdToxcPF8Qj+lTAozRgImGeV7/ZeVOc1Fl////////WYJcP5fuTvtZil/Nio1v4XmweWJb54RxcytxsV50X/Vje2SaccN8mE5DXvxOS1fcVqJgqW/D" +
+		"fQ2A/YEzgb+PsomXhqRd9GKKZK2Jh2d3bOJtPnQ2eDRaRn91gq2ZrE/zXsNi3WOSZVdnb3bDckyAzIC6jymRTVANV/lakmiF//9pc3Fkcv2Mt1jyjOCWapAZh3955HfnhClPL1JlU1pizWfPbMp2fXuUfJWCNoWEj+tm3W8gcgZ+G4OrmcGeplH9e7F4cnu4gId7SGro" +
+		"XmGAjHVRdWBRa5Jibox2epGXmupPEH9wYpx7T5WlnOlWelhZhuSWvE80UiRTSlPNU9teBmQsZZFnf2w+bE5ySHKvc+11VH5BgiyF6Yype8SRxnFpmBKY72M9Zml1anbkeNCFQ4buUypTUVQmWYNeh198YLJiSWJ5YqtlkGvUbMx1snaueJF52H3Lf3eApYirirmMu5B/" +
+		"l16Y22oLfDhQmVw+X65nh2vYdDV3CX+O////////nztnynoXUzl1i5rtX2aBnYPxgJhfPF/FdWJ7RpA8aGdZ61qbfRB2fossT/VfamoZbDdvAnTieWiIaIpVjHle32PPdcV50oLXkyiS8oSchu2cLVTBX2xljG1ccBWMp4zTmDtlT3T2Tg1O2FfgWStaZlvMUaheA16c" +
+		"YBZidmV3//9lp2ZubW5yNnsmgVCBmoKZi1yMoIzmjXSWHJZET65kq2tmgh6EYYVqkOhcAWlTmKiEeoVXTw9Sb1+pXkVnDXmPgXmJB4mGbfVfF2JVbLhOz3Jpm5JSBlQ7VnRYs2GkYm5xGllufIl83n0blvBlh4BeThlPdVF1WEBeY15zXwpnxE4mhT2ViZZbfHOYAVD7" +
+		"WMF2VninUiV3pYURe4ZQT1kJckd7x33oj7qP1JBNT79SyVopXwGXrU/dgheS6lcDY1VraXUriNyPFHpCUt9Yk2FVYgpmrmvNfD+D6VAjT/hTBVRGWDFZSVudXPBc710pXpZisWNnZT5luWcL////////bNVs4XD5eDJ+K4DegrOEDITshwKJEooqjEqQppLSmP2c851s" +
+		"Tk9OoVCNUlZXSlmoXj1f2F/ZYj9mtGcbZ9Bo0lGSfSGAqoGoiwCMjIy/kn6WMlQgmCxTF1DVU1xYqGSyZzRyZ3dmekaR5lLDbKFrhlgAXkxZVGcsf/tR4XbG//9kaXjom1Seu1fLWblmJ2eaa85U6WnZXlWBnGeVm6pn/pxSaF1Opk/jU8hiuWcrbKuPxE+tfm2ev04H" +
+		"YWJugG8rhRNUc2cqm0Vd83uVXKxbxoccbkqE0XoUgQhZmXyNbBF3IFLZWSJxIXJfd9uXJ51haQtaf1oYUaVUDVR9Zg5234/3kpic9Fnqcl1uxVFNaMl9v33sl2KeumR4aiGDAlmEW19r23MbdvJ9soAXhJlRMmcontl27mdiUv+ZBVwkYjt8foywVU9gtn0LlYBTAU5f" +
+		"UbZZHHI6gDaRzl8ld+JThF95fQSFrIozjo2XVmfzha6UU2EJYQhsuXZS////////iu2POFUvT1FRKlLHU8tbpV59YKBhgmPWZwln2m5nbYxzNnM3dTF5UIjVipiQSpCRkPWWxIeNWRVOiE9ZTg6KiY8/mBBQrV58WZZbuV64Y9pj+mTBZtxpSmnYbQtutnGUdSh6r3+K" +
+		"gACESYTJiYGLIY4KkGWWfZkKYX5ikWsy//9sg210f8x//G3Af4WHuoj4Z2WDsZg8lvdtG31hhD2Rak5xU3VdUGsEb+uFzYYtiadSKVQPXGVnTmiodAZ0g3XiiM+I4ZHMluKWeF+Lc4d6y4ROY6B1ZVKJbUFunHQJdVl4a3ySloZ63J+NT7ZhbmXFhlxOhk6uUNpOIVHM" +
+		"W+5lmWiBbbxzH3ZCd616HHzngm+K0pB8kc+WdZgYUpt90VArU5hnl23LcdB0M4HojyqWo5xXnp90YFhBbZl9L5heTuRPNk+LUbdSsV26YBxzsnk8gtOSNJa3lvaXCp6Xn2Jmpmt0UhdSo3DIiMJeyWBLYZBvI3FJfD599IBv////////hO6QI5MsVEKbb2rTcImMwo3v" +
+		"lzJStFpBXspfBGcXaXxplG1qbw9yYnL8e+2AAYB+h0uQzlFtnpN5hICLkzKK1lAtVIyKcWtqjMSBB2DRZ6Cd8k6ZTpicEIprhcGFaGkAbn54l4FV////////////////////////////////////////////////////////////////////////////////////////" +
+		"/////////////////////////////18MThBOFU4qTjFONk48Tj9OQk5WTlhOgk6FjGtOioISXw1Ojk6eTp9OoE6iTrBOs062Ts5OzU7ETsZOwk7XTt5O7U7fTvdPCU9aTzBPW09dT1dPR092T4hPj0+YT3tPaU9wT5FPb0+GT5ZRGE/UT99Pzk/YT9tP0U/aT9BP5E/l" +
+		"UBpQKFAUUCpQJVAFTxxP9lAhUClQLE/+T+9QEVAGUENQR2cDUFVQUFBIUFpQVlBsUHhQgFCaUIVQtFCy////////UMlQylCzUMJQ1lDeUOVQ7VDjUO5Q+VD1UQlRAVECURZRFVEUURpRIVE6UTdRPFE7UT9RQFFSUUxRVFFievhRaVFqUW5RgFGCVthRjFGJUY9RkVGT" +
+		"UZVRllGkUaZRolGpUapRq1GzUbFRslGwUbVRvVHFUclR21HghlVR6VHt//9R8FH1Uf5SBFILUhRSDlInUipSLlIzUjlST1JEUktSTFJeUlRSalJ0UmlSc1J/Un1SjVKUUpJScVKIUpGPqI+nUqxSrVK8UrVSwVLNUtdS3lLjUuaY7VLgUvNS9VL4UvlTBlMIdThTDVMQ" +
+		"Uw9TFVMaUyNTL1MxUzNTOFNAU0ZTRU4XU0lTTVHWU15TaVNuWRhTe1N3U4JTllOgU6ZTpVOuU7BTtlPDfBKW2VPfZvxx7lPuU+hT7VP6VAFUPVRAVCxULVQ8VC5UNlQpVB1UTlSPVHVUjlRfVHFUd1RwVJJUe1SAVHZUhFSQVIZUx1SiVLhUpVSsVMRUyFSo////////" +
+		"VKtUwlSkVL5UvFTYVOVU5lUPVRRU/VTuVO1U+lTiVTlVQFVjVUxVLlVcVUVVVlVXVThVM1VdVZlVgFSvVYpVn1V7VX5VmFWeVa5VfFWDValVh1WoVdpVxVXfVcRV3FXkVdRWFFX3VhZV/lX9VhtV+VZOVlBx31Y0VjZWMlY4//9Wa1ZkVi9WbFZqVoZWgFaKVqBWlFaP" +
+		"VqVWrla2VrRWwla8VsFWw1bAVshWzlbRVtNW11buVvlXAFb/VwRXCVcIVwtXDVcTVxhXFlXHVxxXJlc3VzhXTlc7V0BXT1dpV8BXiFdhV39XiVeTV6BXs1ekV6pXsFfDV8ZX1FfSV9NYClfWV+NYC1gZWB1YclghWGJYS1hwa8BYUlg9WHlYhVi5WJ9Yq1i6WN5Yu1i4" +
+		"WK5YxVjTWNFY11jZWNhY5VjcWORY31jvWPpY+Vj7WPxY/VkCWQpZEFkbaKZZJVksWS1ZMlk4WT560llVWVBZTllaWVhZYllgWWdZbFlp////////WXhZgVmdT15Pq1mjWbJZxlnoWdxZjVnZWdpaJVofWhFaHFoJWhpaQFpsWklaNVo2WmJaalqaWrxavlrLWsJavVrj" +
+		"Wtda5lrpWtZa+lr7WwxbC1sWWzJa0FsqWzZbPltDW0VbQFtRW1VbWltbW2VbaVtwW3NbdVt4ZYhbeluA//9bg1umW7hbw1vHW8lb1FvQW+Rb5lviW95b5VvrW/Bb9lvzXAVcB1wIXA1cE1wgXCJcKFw4XDlcQVxGXE5cU1xQXE9bcVxsXG5OYlx2XHlcjFyRXJRZm1yr" +
+		"XLtctly8XLdcxVy+XMdc2VzpXP1c+lztXYxc6l0LXRVdF11cXR9dG10RXRRdIl0aXRldGF1MXVJdTl1LXWxdc112XYddhF2CXaJdnV2sXa5dvV2QXbddvF3JXc1d013SXdZd213rXfJd9V4LXhpeGV4RXhteNl43XkReQ15AXk5eV15UXl9eYl5kXkdedV52XnqevF5/" +
+		"XqBewV7CXshe0F7P////////XtZe417dXtpe217iXuFe6F7pXuxe8V7zXvBe9F74Xv5fA18JX11fXF8LXxFfFl8pXy1fOF9BX0hfTF9OXy9fUV9WX1dfWV9hX21fc193X4Nfgl9/X4pfiF+RX4dfnl+ZX5hfoF+oX61fvF/WX/tf5F/4X/Ff3WCzX/9gIWBg//9gGWAQ" +
+		"YClgDmAxYBtgFWArYCZgD2A6YFpgQWBqYHdgX2BKYEZgTWBjYENgZGBCYGxga2BZYIFgjWDnYINgmmCEYJtglmCXYJJgp2CLYOFguGDgYNNgtF/wYL1gxmC1YNhhTWEVYQZg9mD3YQBg9GD6YQNhIWD7YPFhDWEOYUdhPmEoYSdhSmE/YTxhLGE0YT1hQmFEYXNhd2FY" +
+		"YVlhWmFrYXRhb2FlYXFhX2FdYVNhdWGZYZZhh2GsYZRhmmGKYZFhq2GuYcxhymHJYfdhyGHDYcZhumHLf3lhzWHmYeNh9mH6YfRh/2H9Yfxh/mIAYghiCWINYgxiFGIb////////Yh5iIWIqYi5iMGIyYjNiQWJOYl5iY2JbYmBiaGJ8YoJiiWJ+YpJik2KWYtRig2KU" +
+		"Ytdi0WK7Ys9i/2LGZNRiyGLcYsxiymLCYsdim2LJYwxi7mLxYydjAmMIYu9i9WNQYz5jTWQcY09jlmOOY4Bjq2N2Y6Njj2OJY59jtWNr//9jaWO+Y+ljwGPGY+NjyWPSY/ZjxGQWZDRkBmQTZCZkNmUdZBdkKGQPZGdkb2R2ZE5lKmSVZJNkpWSpZIhkvGTaZNJkxWTH" +
+		"ZLtk2GTCZPFk54IJZOBk4WKsZONk72UsZPZk9GTyZPplAGT9ZRhlHGUFZSRlI2UrZTRlNWU3ZTZlOHVLZUhlVmVVZU1lWGVeZV1lcmV4ZYJlg4uKZZtln2WrZbdlw2XGZcFlxGXMZdJl22XZZeBl4WXxZ3JmCmYDZftnc2Y1ZjZmNGYcZk9mRGZJZkFmXmZdZmRmZ2Zo" +
+		"Zl9mYmZwZoNmiGaOZolmhGaYZp1mwWa5Zslmvma8////////ZsRmuGbWZtpm4GY/ZuZm6WbwZvVm92cPZxZnHmcmZyeXOGcuZz9nNmdBZzhnN2dGZ15nYGdZZ2NnZGeJZ3BnqWd8Z2pnjGeLZ6ZnoWeFZ7dn72e0Z+xns2fpZ7hn5GfeZ91n4mfuZ7lnzmfGZ+dqnGge" +
+		"aEZoKWhAaE1oMmhO//9os2graFloY2h3aH9on2iPaK1olGidaJtog2quaLlodGi1aKBoumkPaI1ofmkBaMppCGjYaSJpJmjhaQxozWjUaOdo1Wk2aRJpBGjXaONpJWj5aOBo72koaSppGmkjaSFoxml5aXdpXGl4aWtpVGl+aW5pOWl0aT1pWWkwaWFpXmldaYFpammy" +
+		"aa5p0Gm/acFp02m+ac5b6GnKad1pu2nDaadqLmmRaaBpnGmVabRp3mnoagJqG2n/awpp+WnyaedqBWmxah5p7WoUaetqCmoSasFqI2oTakRqDGpyajZqeGpHamJqWWpmakhqOGoiapBqjWqgaoRqomqj////////apeGF2q7asNqwmq4arNqrGreatFq32qqatpq6mr7" +
+		"awWGFmr6axJrFpsxax9rOGs3dtxrOZjua0drQ2tJa1BrWWtUa1trX2tha3hreWt/a4BrhGuDa41rmGuVa55rpGuqa6trr2uya7Frs2u3a7xrxmvLa9Nr32vsa+tr82vv//+evmwIbBNsFGwbbCRsI2xebFVsYmxqbIJsjWyabIFsm2x+bGhsc2ySbJBsxGzxbNNsvWzX" +
+		"bMVs3WyubLFsvmy6bNts72zZbOptH4hNbTZtK209bThtGW01bTNtEm0MbWNtk21kbVpteW1ZbY5tlW/kbYVt+W4VbgpttW3HbeZtuG3Gbext3m3Mbeht0m3Fbfpt2W3kbdVt6m3ubi1ubm4ubhlucm5fbj5uI25rbitudm5Nbh9uQ246bk5uJG7/bh1uOG6CbqpumG7J" +
+		"brdu0269bq9uxG6ybtRu1W6PbqVuwm6fb0FvEXBMbuxu+G7+bz9u8m8xbu9vMm7M////////bz5vE273b4Zvem94b4FvgG9vb1tv829tb4JvfG9Yb45vkW/Cb2Zvs2+jb6FvpG+5b8Zvqm/fb9Vv7G/Ub9hv8W/ub9twCXALb/pwEXABcA9v/nAbcBpvdHAdcBhwH3Aw" +
+		"cD5wMnBRcGNwmXCScK9w8XCscLhws3CucN9wy3Dd//9w2XEJcP1xHHEZcWVxVXGIcWZxYnFMcVZxbHGPcftxhHGVcahxrHHXcblxvnHScclx1HHOceBx7HHncfVx/HH5cf9yDXIQchtyKHItcixyMHIycjtyPHI/ckByRnJLclhydHJ+coJygXKHcpJylnKicqdyuXKy" +
+		"csNyxnLEcs5y0nLicuBy4XL5cvdQD3MXcwpzHHMWcx1zNHMvcylzJXM+c05zT57Yc1dzanNoc3BzeHN1c3tzenPIc7NzznO7c8Bz5XPuc950onQFdG90JXP4dDJ0OnRVdD90X3RZdEF0XHRpdHB0Y3RqdHZ0fnSLdJ50p3TKdM901HPx////////dOB043TndOl07nTy" +
+		"dPB08XT4dPd1BHUDdQV1DHUOdQ11FXUTdR51JnUsdTx1RHVNdUp1SXVbdUZ1WnVpdWR1Z3VrdW11eHV2dYZ1h3V0dYp1iXWCdZR1mnWddaV1o3XCdbN1w3W1db11uHW8dbF1zXXKddJ12XXjdd51/nX///91/HYBdfB1+nXydfN2C3YNdgl2H3YndiB2IXYidiR2NHYw" +
+		"djt2R3ZIdkZ2XHZYdmF2YnZodml2anZndmx2cHZydnZ2eHZ8doB2g3aIdot2jnaWdpN2mXaadrB2tHa4drl2unbCds121nbSdt524Xbldud26oYvdvt3CHcHdwR3KXckdx53JXcmdxt3N3c4d0d3Wndod2t3W3dld393fnd5d453i3eRd6B3nnewd7Z3uXe/d7x3vXe7" +
+		"d8d3zXfXd9p33Hfjd+53/HgMeBJ5JnggeSp4RXiOeHR4hnh8eJp4jHijeLV4qniveNF4xnjLeNR4vni8eMV4ynjs////////eOd42nj9ePR5B3kSeRF5GXkseSt5QHlgeVd5X3laeVV5U3l6eX95inmdeaefS3mqea55s3m5ebp5yXnVeed57HnheeN6CHoNehh6GXog" +
+		"eh95gHoxejt6Pno3ekN6V3pJemF6Ynppn516cHp5en16iHqXepV6mHqWeql6yHqw//96tnrFesR6v5CDesd6ynrNes961XrTetl62nrdeuF64nrmeu168HsCew97CnsGezN7GHsZex57NXsoezZ7UHt6ewR7TXsLe0x7RXt1e2V7dHtne3B7cXtse257nXuYe597jXuc" +
+		"e5p7i3uSe497XXuZe8t7wXvMe897tHvGe9176XwRfBR75nvlfGB8AHwHfBN783v3fBd8DXv2fCN8J3wqfB98N3wrfD18THxDfFR8T3xAfFB8WHxffGR8VnxlfGx8dXyDfJB8pHytfKJ8q3yhfKh8s3yyfLF8rny5fL18wHzFfMJ82HzSfNx84ps7fO988nz0fPZ8+n0G" +
+		"////////fQJ9HH0VfQp9RX1LfS59Mn0/fTV9Rn1zfVZ9Tn1yfWh9bn1PfWN9k32JfVt9j319fZt9un2ufaN9tX3Hfb19q349faJ9r33cfbh9n32wfdh93X3kfd59+33yfeF+BX4KfiN+IX4SfjF+H34Jfgt+In5GfmZ+O341fjl+Q343//9+Mn46fmd+XX5Wfl5+WX5a" +
+		"fnl+an5pfnx+e36DfdV+fY+ufn9+iH6Jfox+kn6QfpN+lH6Wfo5+m36cfzh/On9Ff0x/TX9Of1B/UX9Vf1R/WH9ff2B/aH9pf2d/eH+Cf4Z/g3+If4d/jH+Uf55/nX+af6N/r3+yf7l/rn+2f7iLcX/Ff8Z/yn/Vf9R/4X/mf+l/83/5mNyABoAEgAuAEoAYgBmAHIAh" +
+		"gCiAP4A7gEqARoBSgFiAWoBfgGKAaIBzgHKAcIB2gHmAfYB/gISAhoCFgJuAk4CagK1RkICsgNuA5YDZgN2AxIDagNaBCYDvgPGBG4EpgSOBL4FL////////louBRoE+gVOBUYD8gXGBboFlgWaBdIGDgYiBioGAgYKBoIGVgaSBo4FfgZOBqYGwgbWBvoG4gb2BwIHC" +
+		"gbqByYHNgdGB2YHYgciB2oHfgeCB54H6gfuB/oIBggKCBYIHggqCDYIQghaCKYIrgjiCM4JAglmCWIJdglqCX4Jk//+CYoJogmqCa4IugnGCd4J4gn6CjYKSgquCn4K7gqyC4YLjgt+C0oL0gvOC+oOTgwOC+4L5gt6DBoLcgwmC2YM1gzSDFoMygzGDQIM5g1CDRYMv" +
+		"gyuDF4MYg4WDmoOqg5+DooOWgyODjoOHg4qDfIO1g3ODdYOgg4mDqIP0hBOD64POg/2EA4PYhAuDwYP3hAeD4IPyhA2EIoQgg72EOIUGg/uEbYQqhDyFWoSEhHeEa4SthG6EgoRphEaELIRvhHmENYTKhGKEuYS/hJ+E2YTNhLuE2oTQhMGExoTWhKGFIYT/hPSFF4UY" +
+		"hSyFH4UVhRSE/IVAhWOFWIVI////////hUGGAoVLhVWFgIWkhYiFkYWKhaiFbYWUhZuF6oWHhZyFd4V+hZCFyYW6hc+FuYXQhdWF3YXlhdyF+YYKhhOGC4X+hfqGBoYihhqGMIY/hk1OVYZUhl+GZ4ZxhpOGo4aphqqGi4aMhraGr4bEhsaGsIbJiCOGq4bUht6G6Ybs" +
+		"//+G34bbhu+HEocGhwiHAIcDhvuHEYcJhw2G+YcKhzSHP4c3hzuHJYcphxqHYIdfh3iHTIdOh3SHV4doh26HWYdTh2OHaogFh6KHn4eCh6+Hy4e9h8CH0JbWh6uHxIezh8eHxoe7h++H8ofgiA+IDYf+h/aH94gOh9KIEYgWiBWIIoghiDGINog5iCeIO4hEiEKIUohZ" +
+		"iF6IYohriIGIfoieiHWIfYi1iHKIgoiXiJKIroiZiKKIjYikiLCIv4ixiMOIxIjUiNiI2YjdiPmJAoj8iPSI6IjyiQSJDIkKiROJQ4keiSWJKokriUGJRIk7iTaJOIlMiR2JYIle////////iWaJZIltiWqJb4l0iXeJfomDiYiJiomTiZiJoYmpiaaJrImvibKJuom9" +
+		"ib+JwInaidyJ3YnnifSJ+IoDihaKEIoMihuKHYolijaKQYpbilKKRopIinyKbYpsimKKhYqCioSKqIqhipGKpYqmipqKo4rEis2KworaiuuK84rn//+K5IrxixSK4IriiveK3orbiwyLB4saiuGLFosQixeLIIszl6uLJosriz6LKItBi0yLT4tOi0mLVotbi1qLa4tf" +
+		"i2yLb4t0i32LgIuMi46LkouTi5aLmYuajDqMQYw/jEiMTIxOjFCMVYxijGyMeIx6jIKMiYyFjIqMjYyOjJSMfIyYYh2MrYyqjL2MsoyzjK6MtozIjMGM5IzjjNqM/Yz6jPuNBI0FjQqNB40PjQ2NEJ9OjROMzY0UjRaNZ41tjXGNc42BjZmNwo2+jbqNz43ajdaNzI3b" +
+		"jcuN6o3rjd+N4438jgiOCY3/jh2OHo4Qjh+OQo41jjCONI5K////////jkeOSY5MjlCOSI5ZjmSOYI4qjmOOVY52jnKOfI6BjoeOhY6EjouOio6TjpGOlI6ZjqqOoY6sjrCOxo6xjr6OxY7IjsuO247jjvyO+47rjv6PCo8FjxWPEo8ZjxOPHI8fjxuPDI8mjzOPO485" +
+		"j0WPQo8+j0yPSY9Gj06PV49c//+PYo9jj2SPnI+fj6OPrY+vj7eP2o/lj+KP6o/vkIeP9JAFj/mP+pARkBWQIZANkB6QFpALkCeQNpA1kDmP+JBPkFCQUZBSkA6QSZA+kFaQWJBekGiQb5B2lqiQcpCCkH2QgZCAkIqQiZCPkKiQr5CxkLWQ4pDkYkiQ25ECkRKRGZEy" +
+		"kTCRSpFWkViRY5FlkWmRc5FykYuRiZGCkaKRq5GvkaqRtZG0kbqRwJHBkcmRy5HQkdaR35HhkduR/JH1kfaSHpH/khSSLJIVkhGSXpJXkkWSSZJkkkiSlZI/kkuSUJKckpaSk5KbklqSz5K5kreS6ZMPkvqTRJMu////////kxmTIpMakyOTOpM1kzuTXJNgk3yTbpNW" +
+		"k7CTrJOtk5STuZPWk9eT6JPlk9iTw5Pdk9CTyJPklBqUFJQTlAOUB5QQlDaUK5Q1lCGUOpRBlFKURJRblGCUYpRelGqSKZRwlHWUd5R9lFqUfJR+lIGUf5WClYeVipWUlZaVmJWZ//+VoJWolaeVrZW8lbuVuZW+lcpv9pXDlc2VzJXVldSV1pXcleGV5ZXiliGWKJYu" +
+		"li+WQpZMlk+WS5Z3llyWXpZdll+WZpZylmyWjZaYlpWWl5aqlqeWsZaylrCWtJa2lriWuZbOlsuWyZbNiU2W3JcNltWW+ZcElwaXCJcTlw6XEZcPlxaXGZcklyqXMJc5lz2XPpdEl0aXSJdCl0mXXJdgl2SXZpdoUtKXa5dxl3mXhZd8l4GXepeGl4uXj5eQl5yXqJem" +
+		"l6OXs5e0l8OXxpfIl8uX3Jftn0+X8nrfl/aX9ZgPmAyYOJgkmCGYN5g9mEaYT5hLmGuYb5hw////////mHGYdJhzmKqYr5ixmLaYxJjDmMaY6ZjrmQOZCZkSmRSZGJkhmR2ZHpkkmSCZLJkumT2ZPplCmUmZRZlQmUuZUZlSmUyZVZmXmZiZpZmtma6ZvJnfmduZ3ZnY" +
+		"mdGZ7ZnumfGZ8pn7mfiaAZoPmgWZ4poZmiuaN5pFmkKaQJpD//+aPppVmk2aW5pXml+aYpplmmSaaZprmmqarZqwmryawJrPmtGa05rUmt6a35rimuOa5prvmuua7pr0mvGa95r7mwabGJsamx+bIpsjmyWbJ5somymbKpsumy+bMptEm0ObT5tNm06bUZtYm3Sbk5uD" +
+		"m5GblpuXm5+boJuom7SbwJvKm7mbxpvPm9Gb0pvjm+Kb5JvUm+GcOpvym/Gb8JwVnBScCZwTnAycBpwInBKcCpwEnC6cG5wlnCScIZwwnEecMpxGnD6cWpxgnGecdpx4nOec7JzwnQmdCJzrnQOdBp0qnSadr50jnR+dRJ0VnRKdQZ0/nT6dRp1I////////nV2dXp1k" +
+		"nVGdUJ1ZnXKdiZ2Hnaudb516nZqdpJ2pnbKdxJ3BnbuduJ26ncadz53Cndmd0534nead7Z3vnf2eGp4bnh6edZ55nn2egZ6InouejJ6SnpWekZ6dnqWeqZ64nqqerZdhnsyezp7PntCe1J7cnt6e3Z7gnuWe6J7v//+e9J72nvee+Z77nvye/Z8Hnwh2t58VnyGfLJ8+" +
+		"n0qfUp9Un2OfX59gn2GfZp9nn2yfap93n3Kfdp+Vn5yfoFgvaceQWXRkUdxxmf//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
+		"/////////////////////////////////////////////w==";
+	
+	
+	private static short[] UNICODE_TO_QR_KANJI = new short[1 << 16];
+	
+	static {  // Unpack the Shift JIS table into a more computation-friendly form
+		Arrays.fill(UNICODE_TO_QR_KANJI, (short)-1);
+		byte[] bytes = Base64.getDecoder().decode(PACKED_QR_KANJI_TO_UNICODE);
+		for (int i = 0; i < bytes.length; i += 2) {
+			char c = (char)(((bytes[i] & 0xFF) << 8) | (bytes[i + 1] & 0xFF));
+			if (c == 0xFFFF)
+				continue;
+			assert UNICODE_TO_QR_KANJI[c] == -1;
+			UNICODE_TO_QR_KANJI[c] = (short)(i / 2);
+		}
+	}
+	
+	
+	
+	/*---- Miscellaneous ----*/
+	
+	private QrSegmentAdvanced() {}  // Not instantiable
+	
+}

Telegram/ThirdParty/QR/java/src/main/java/io/nayuki/qrcodegen/package-info.java

@@ -0,0 +1,53 @@
+/**
+ * Generates QR Codes from text strings and byte arrays.
+ * 
+ * <p>This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.</p>
+ * <p>Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: <a href="https://www.nayuki.io/page/qr-code-generator-library">https://www.nayuki.io/page/qr-code-generator-library</a></p>
+ * 
+ * <h2>Features</h2>
+ * <p>Core features:</p>
+ * <ul>
+ *   <li><p>Significantly shorter code but more documentation comments compared to competing libraries</p></li>
+ *   <li><p>Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard</p></li>
+ *   <li><p>Output format: Raw modules/pixels of the QR symbol</p></li>
+ *   <li><p>Detects finder-like penalty patterns more accurately than other implementations</p></li>
+ *   <li><p>Encodes numeric and special-alphanumeric text in less space than general text</p></li>
+ *   <li><p>Open-source code under the permissive MIT License</p></li>
+ * </ul>
+ * <p>Manual parameters:</p>
+ * <ul>
+ *   <li><p>User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data</p></li>
+ *   <li><p>User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one</p></li>
+ *   <li><p>User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number</p></li>
+ *   <li><p>User can create a list of data segments manually and add ECI segments</p></li>
+ * </ul>
+ * <p>Optional advanced features:</p>
+ * <ul>
+ *   <li><p>Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes</p></li>
+ *   <li><p>Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts</p></li>
+ * </ul>
+ * <p>More information about QR Code technology and this library's design can be found on the project home page.</p>
+ * 
+ * <h2>Examples</h2>
+ * <p>Simple operation:</p>
+ * <pre style="margin-left:2em">import java.awt.image.BufferedImage;
+ *import java.io.File;
+ *import javax.imageio.ImageIO;
+ *import io.nayuki.qrcodegen.*;
+ *
+ *QrCode qr = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
+ *BufferedImage img = toImage(qr, 4, 10);  // See QrCodeGeneratorDemo
+ *ImageIO.write(img, "png", new File("qr-code.png"));</pre>
+ * <p>Manual operation:</p>
+ * <pre style="margin-left:2em">import java.util.List;
+ *import io.nayuki.qrcodegen.*;
+ *
+ *List&lt;QrSegment&gt; segs = QrSegment.makeSegments("3141592653589793238462643383");
+ *QrCode qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
+ *for (int y = 0; y &lt; qr.size; y++) {
+ *    for (int x = 0; x &lt; qr.size; x++) {
+ *        (... paint qr.getModule(x, y) ...)
+ *    }
+ *}</pre>
+ */
+package io.nayuki.qrcodegen;

Telegram/ThirdParty/QR/java/src/main/java/module-info.java

@@ -0,0 +1,29 @@
+/* 
+ * QR Code generator library (Java)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+
+module io.nayuki.qrcodegen {
+	
+	exports io.nayuki.qrcodegen;
+	
+}

Telegram/ThirdParty/QR/python/Readme.markdown

@@ -0,0 +1,53 @@
+QR Code generator library - Python
+==================================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```python
+from qrcodegen import *
+
+# Simple operation
+qr0 = QrCode.encode_text("Hello, world!", QrCode.Ecc.MEDIUM)
+svg = to_svg_str(qr0, 4)  # See qrcodegen-demo
+
+# Manual operation
+segs = QrSegment.make_segments("3141592653589793238462643383")
+qr1 = QrCode.encode_segments(segs, QrCode.Ecc.HIGH, 5, 5, 2, False)
+for y in range(qr1.get_size()):
+    for x in range(qr1.get_size()):
+        (... paint qr1.get_module(x, y) ...)
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/python/qrcodegen-demo.py .

Telegram/ThirdParty/QR/python/qrcodegen-demo.py

@@ -0,0 +1,205 @@
+# 
+# QR Code generator demo (Python)
+# 
+# Run this command-line program with no arguments. The program computes a bunch of demonstration
+# QR Codes and prints them to the console. Also, the SVG code for one QR Code is printed as a sample.
+# 
+# Copyright (c) Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/qr-code-generator-library
+# 
+# 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.
+# 
+
+from typing import List
+from qrcodegen import QrCode, QrSegment
+
+
+def main() -> None:
+	"""The main application program."""
+	do_basic_demo()
+	do_variety_demo()
+	do_segment_demo()
+	do_mask_demo()
+
+
+
+# ---- Demo suite ----
+
+def do_basic_demo() -> None:
+	"""Creates a single QR Code, then prints it to the console."""
+	text = "Hello, world!"      # User-supplied Unicode text
+	errcorlvl = QrCode.Ecc.LOW  # Error correction level
+	
+	# Make and print the QR Code symbol
+	qr = QrCode.encode_text(text, errcorlvl)
+	print_qr(qr)
+	print(to_svg_str(qr, 4))
+
+
+def do_variety_demo() -> None:
+	"""Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console."""
+	
+	# Numeric mode encoding (3.33 bits per digit)
+	qr = QrCode.encode_text("314159265358979323846264338327950288419716939937510", QrCode.Ecc.MEDIUM)
+	print_qr(qr)
+	
+	# Alphanumeric mode encoding (5.5 bits per character)
+	qr = QrCode.encode_text("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCode.Ecc.HIGH)
+	print_qr(qr)
+	
+	# Unicode text as UTF-8
+	qr = QrCode.encode_text("\u3053\u3093\u306B\u3061\u0077\u0061\u3001\u4E16\u754C\uFF01\u0020\u03B1\u03B2\u03B3\u03B4", QrCode.Ecc.QUARTILE)
+	print_qr(qr)
+	
+	# Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+	qr = QrCode.encode_text(
+		"Alice was beginning to get very tired of sitting by her sister on the bank, "
+		"and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
+		"but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
+		"'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
+		"for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
+		"daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
+		"a White Rabbit with pink eyes ran close by her.", QrCode.Ecc.HIGH)
+	print_qr(qr)
+
+
+def do_segment_demo() -> None:
+	"""Creates QR Codes with manually specified segments for better compactness."""
+	
+	# Illustration "silver"
+	silver0 = "THE SQUARE ROOT OF 2 IS 1."
+	silver1 = "41421356237309504880168872420969807856967187537694807317667973799"
+	qr = QrCode.encode_text(silver0 + silver1, QrCode.Ecc.LOW)
+	print_qr(qr)
+	
+	segs = [
+		QrSegment.make_alphanumeric(silver0),
+		QrSegment.make_numeric(silver1)]
+	qr = QrCode.encode_segments(segs, QrCode.Ecc.LOW)
+	print_qr(qr)
+	
+	# Illustration "golden"
+	golden0 = "Golden ratio \u03C6 = 1."
+	golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374"
+	golden2 = "......"
+	qr = QrCode.encode_text(golden0 + golden1 + golden2, QrCode.Ecc.LOW)
+	print_qr(qr)
+	
+	segs = [
+		QrSegment.make_bytes(golden0.encode("UTF-8")),
+		QrSegment.make_numeric(golden1),
+		QrSegment.make_alphanumeric(golden2)]
+	qr = QrCode.encode_segments(segs, QrCode.Ecc.LOW)
+	print_qr(qr)
+	
+	# Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+	madoka = "\u300C\u9B54\u6CD5\u5C11\u5973\u307E\u3069\u304B\u2606\u30DE\u30AE\u30AB\u300D\u3063\u3066\u3001\u3000\u0418\u0410\u0418\u3000\uFF44\uFF45\uFF53\uFF55\u3000\u03BA\u03B1\uFF1F"
+	qr = QrCode.encode_text(madoka, QrCode.Ecc.LOW)
+	print_qr(qr)
+	
+	kanjicharbits = [  # Kanji mode encoding (13 bits per character)
+		0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1,
+		1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+		0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+		0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,
+		0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,
+		0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0,
+		0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,
+		0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1,
+		0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1,
+		0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,
+		0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1,
+		0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0,
+		0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0,
+		0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1,
+		0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+		0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
+		0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,
+		0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1,
+		0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+		0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+	]
+	segs = [QrSegment(QrSegment.Mode.KANJI, len(kanjicharbits) // 13, kanjicharbits)]
+	qr = QrCode.encode_segments(segs, QrCode.Ecc.LOW)
+	print_qr(qr)
+
+
+def do_mask_demo() -> None:
+	"""Creates QR Codes with the same size and contents but different mask patterns."""
+	
+	# Project Nayuki URL
+	segs = QrSegment.make_segments("https://www.nayuki.io/")
+	print_qr(QrCode.encode_segments(segs, QrCode.Ecc.HIGH, mask=-1))  # Automatic mask
+	print_qr(QrCode.encode_segments(segs, QrCode.Ecc.HIGH, mask=3))  # Force mask 3
+	
+	# Chinese text as UTF-8
+	segs = QrSegment.make_segments(
+		"\u7DAD\u57FA\u767E\u79D1\uFF08\u0057\u0069\u006B\u0069\u0070\u0065\u0064\u0069\u0061\uFF0C"
+		"\u8046\u807D\u0069\u002F\u02CC\u0077\u026A\u006B\u1D7B\u02C8\u0070\u0069\u02D0\u0064\u0069"
+		"\u002E\u0259\u002F\uFF09\u662F\u4E00\u500B\u81EA\u7531\u5167\u5BB9\u3001\u516C\u958B\u7DE8"
+		"\u8F2F\u4E14\u591A\u8A9E\u8A00\u7684\u7DB2\u8DEF\u767E\u79D1\u5168\u66F8\u5354\u4F5C\u8A08"
+		"\u756B")
+	print_qr(QrCode.encode_segments(segs, QrCode.Ecc.MEDIUM, mask=0))  # Force mask 0
+	print_qr(QrCode.encode_segments(segs, QrCode.Ecc.MEDIUM, mask=1))  # Force mask 1
+	print_qr(QrCode.encode_segments(segs, QrCode.Ecc.MEDIUM, mask=5))  # Force mask 5
+	print_qr(QrCode.encode_segments(segs, QrCode.Ecc.MEDIUM, mask=7))  # Force mask 7
+
+
+
+# ---- Utilities ----
+
+def to_svg_str(qr: QrCode, border: int) -> str:
+	"""Returns a string of SVG code for an image depicting the given QR Code, with the given number
+	of border modules. The string always uses Unix newlines (\n), regardless of the platform."""
+	if border < 0:
+		raise ValueError("Border must be non-negative")
+	parts: List[str] = []
+	for y in range(qr.get_size()):
+		for x in range(qr.get_size()):
+			if qr.get_module(x, y):
+				parts.append(f"M{x+border},{y+border}h1v1h-1z")
+	return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 {qr.get_size()+border*2} {qr.get_size()+border*2}" stroke="none">
+	<rect width="100%" height="100%" fill="#FFFFFF"/>
+	<path d="{" ".join(parts)}" fill="#000000"/>
+</svg>
+"""
+
+
+def print_qr(qrcode: QrCode) -> None:
+	"""Prints the given QrCode object to the console."""
+	border = 4
+	for y in range(-border, qrcode.get_size() + border):
+		for x in range(-border, qrcode.get_size() + border):
+			print("\u2588 "[1 if qrcode.get_module(x,y) else 0] * 2, end="")
+		print()
+	print()
+
+
+# Run the main program
+if __name__ == "__main__":
+	main()

Telegram/ThirdParty/QR/python/qrcodegen.py

@@ -0,0 +1,909 @@
+# 
+# QR Code generator library (Python)
+# 
+# Copyright (c) Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/qr-code-generator-library
+# 
+# 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.
+# 
+
+from __future__ import annotations
+import collections, itertools, re
+from collections.abc import Sequence
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+
+# ---- QR Code symbol class ----
+
+class QrCode:
+	"""A QR Code symbol, which is a type of two-dimension barcode.
+	Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+	Instances of this class represent an immutable square grid of dark and light cells.
+	The class provides static factory functions to create a QR Code from text or binary data.
+	The class covers the QR Code Model 2 specification, supporting all versions (sizes)
+	from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+	
+	Ways to create a QR Code object:
+	- High level: Take the payload data and call QrCode.encode_text() or QrCode.encode_binary().
+	- Mid level: Custom-make the list of segments and call QrCode.encode_segments().
+	- Low level: Custom-make the array of data codeword bytes (including
+	  segment headers and final padding, excluding error correction codewords),
+	  supply the appropriate version number, and call the QrCode() constructor.
+	(Note that all ways require supplying the desired error correction level.)"""
+	
+	# ---- Static factory functions (high level) ----
+	
+	@staticmethod
+	def encode_text(text: str, ecl: QrCode.Ecc) -> QrCode:
+		"""Returns a QR Code representing the given Unicode text string at the given error correction level.
+		As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
+		Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
+		QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
+		ecl argument if it can be done without increasing the version."""
+		segs: List[QrSegment] = QrSegment.make_segments(text)
+		return QrCode.encode_segments(segs, ecl)
+	
+	
+	@staticmethod
+	def encode_binary(data: Union[bytes,Sequence[int]], ecl: QrCode.Ecc) -> QrCode:
+		"""Returns a QR Code representing the given binary data at the given error correction level.
+		This function always encodes using the binary segment mode, not any text mode. The maximum number of
+		bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+		The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version."""
+		return QrCode.encode_segments([QrSegment.make_bytes(data)], ecl)
+	
+	
+	# ---- Static factory functions (mid level) ----
+	
+	@staticmethod
+	def encode_segments(segs: Sequence[QrSegment], ecl: QrCode.Ecc, minversion: int = 1, maxversion: int = 40, mask: int = -1, boostecl: bool = True) -> QrCode:
+		"""Returns a QR Code representing the given segments with the given encoding parameters.
+		The smallest possible QR Code version within the given range is automatically
+		chosen for the output. Iff boostecl is true, then the ECC level of the result
+		may be higher than the ecl argument if it can be done without increasing the
+		version. The mask number is either between 0 to 7 (inclusive) to force that
+		mask, or -1 to automatically choose an appropriate mask (which may be slow).
+		This function allows the user to create a custom sequence of segments that switches
+		between modes (such as alphanumeric and byte) to encode text in less space.
+		This is a mid-level API; the high-level API is encode_text() and encode_binary()."""
+		
+		if not (QrCode.MIN_VERSION <= minversion <= maxversion <= QrCode.MAX_VERSION) or not (-1 <= mask <= 7):
+			raise ValueError("Invalid value")
+		
+		# Find the minimal version number to use
+		for version in range(minversion, maxversion + 1):
+			datacapacitybits: int = QrCode._get_num_data_codewords(version, ecl) * 8  # Number of data bits available
+			datausedbits: Optional[int] = QrSegment.get_total_bits(segs, version)
+			if (datausedbits is not None) and (datausedbits <= datacapacitybits):
+				break  # This version number is found to be suitable
+			if version >= maxversion:  # All versions in the range could not fit the given data
+				msg: str = "Segment too long"
+				if datausedbits is not None:
+					msg = f"Data length = {datausedbits} bits, Max capacity = {datacapacitybits} bits"
+				raise DataTooLongError(msg)
+		assert datausedbits is not None
+		
+		# Increase the error correction level while the data still fits in the current version number
+		for newecl in (QrCode.Ecc.MEDIUM, QrCode.Ecc.QUARTILE, QrCode.Ecc.HIGH):  # From low to high
+			if boostecl and (datausedbits <= QrCode._get_num_data_codewords(version, newecl) * 8):
+				ecl = newecl
+		
+		# Concatenate all segments to create the data bit string
+		bb = _BitBuffer()
+		for seg in segs:
+			bb.append_bits(seg.get_mode().get_mode_bits(), 4)
+			bb.append_bits(seg.get_num_chars(), seg.get_mode().num_char_count_bits(version))
+			bb.extend(seg._bitdata)
+		assert len(bb) == datausedbits
+		
+		# Add terminator and pad up to a byte if applicable
+		datacapacitybits = QrCode._get_num_data_codewords(version, ecl) * 8
+		assert len(bb) <= datacapacitybits
+		bb.append_bits(0, min(4, datacapacitybits - len(bb)))
+		bb.append_bits(0, -len(bb) % 8)  # Note: Python's modulo on negative numbers behaves better than C family languages
+		assert len(bb) % 8 == 0
+		
+		# Pad with alternating bytes until data capacity is reached
+		for padbyte in itertools.cycle((0xEC, 0x11)):
+			if len(bb) >= datacapacitybits:
+				break
+			bb.append_bits(padbyte, 8)
+		
+		# Pack bits into bytes in big endian
+		datacodewords = bytearray([0] * (len(bb) // 8))
+		for (i, bit) in enumerate(bb):
+			datacodewords[i >> 3] |= bit << (7 - (i & 7))
+		
+		# Create the QR Code object
+		return QrCode(version, ecl, datacodewords, mask)
+	
+	
+	# ---- Private fields ----
+	
+	# The version number of this QR Code, which is between 1 and 40 (inclusive).
+	# This determines the size of this barcode.
+	_version: int
+	
+	# The width and height of this QR Code, measured in modules, between
+	# 21 and 177 (inclusive). This is equal to version * 4 + 17.
+	_size: int
+	
+	# The error correction level used in this QR Code.
+	_errcorlvl: QrCode.Ecc
+	
+	# The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+	# Even if a QR Code is created with automatic masking requested (mask = -1),
+	# the resulting object still has a mask value between 0 and 7.
+	_mask: int
+	
+	# The modules of this QR Code (False = light, True = dark).
+	# Immutable after constructor finishes. Accessed through get_module().
+	_modules: List[List[bool]]
+	
+	# Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+	_isfunction: List[List[bool]]
+	
+	
+	# ---- Constructor (low level) ----
+	
+	def __init__(self, version: int, errcorlvl: QrCode.Ecc, datacodewords: Union[bytes,Sequence[int]], msk: int) -> None:
+		"""Creates a new QR Code with the given version number,
+		error correction level, data codeword bytes, and mask number.
+		This is a low-level API that most users should not use directly.
+		A mid-level API is the encode_segments() function."""
+		
+		# Check scalar arguments and set fields
+		if not (QrCode.MIN_VERSION <= version <= QrCode.MAX_VERSION):
+			raise ValueError("Version value out of range")
+		if not (-1 <= msk <= 7):
+			raise ValueError("Mask value out of range")
+		
+		self._version = version
+		self._size = version * 4 + 17
+		self._errcorlvl = errcorlvl
+		
+		# Initialize both grids to be size*size arrays of Boolean false
+		self._modules    = [[False] * self._size for _ in range(self._size)]  # Initially all light
+		self._isfunction = [[False] * self._size for _ in range(self._size)]
+		
+		# Compute ECC, draw modules
+		self._draw_function_patterns()
+		allcodewords: bytes = self._add_ecc_and_interleave(bytearray(datacodewords))
+		self._draw_codewords(allcodewords)
+		
+		# Do masking
+		if msk == -1:  # Automatically choose best mask
+			minpenalty: int = 1 << 32
+			for i in range(8):
+				self._apply_mask(i)
+				self._draw_format_bits(i)
+				penalty = self._get_penalty_score()
+				if penalty < minpenalty:
+					msk = i
+					minpenalty = penalty
+				self._apply_mask(i)  # Undoes the mask due to XOR
+		assert 0 <= msk <= 7
+		self._mask = msk
+		self._apply_mask(msk)  # Apply the final choice of mask
+		self._draw_format_bits(msk)  # Overwrite old format bits
+		
+		del self._isfunction
+	
+	
+	# ---- Accessor methods ----
+	
+	def get_version(self) -> int:
+		"""Returns this QR Code's version number, in the range [1, 40]."""
+		return self._version
+	
+	def get_size(self) -> int:
+		"""Returns this QR Code's size, in the range [21, 177]."""
+		return self._size
+	
+	def get_error_correction_level(self) -> QrCode.Ecc:
+		"""Returns this QR Code's error correction level."""
+		return self._errcorlvl
+	
+	def get_mask(self) -> int:
+		"""Returns this QR Code's mask, in the range [0, 7]."""
+		return self._mask
+	
+	def get_module(self, x: int, y: int) -> bool:
+		"""Returns the color of the module (pixel) at the given coordinates, which is False
+		for light or True for dark. The top left corner has the coordinates (x=0, y=0).
+		If the given coordinates are out of bounds, then False (light) is returned."""
+		return (0 <= x < self._size) and (0 <= y < self._size) and self._modules[y][x]
+	
+	
+	# ---- Private helper methods for constructor: Drawing function modules ----
+	
+	def _draw_function_patterns(self) -> None:
+		"""Reads this object's version field, and draws and marks all function modules."""
+		# Draw horizontal and vertical timing patterns
+		for i in range(self._size):
+			self._set_function_module(6, i, i % 2 == 0)
+			self._set_function_module(i, 6, i % 2 == 0)
+		
+		# Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
+		self._draw_finder_pattern(3, 3)
+		self._draw_finder_pattern(self._size - 4, 3)
+		self._draw_finder_pattern(3, self._size - 4)
+		
+		# Draw numerous alignment patterns
+		alignpatpos: List[int] = self._get_alignment_pattern_positions()
+		numalign: int = len(alignpatpos)
+		skips: Sequence[Tuple[int,int]] = ((0, 0), (0, numalign - 1), (numalign - 1, 0))
+		for i in range(numalign):
+			for j in range(numalign):
+				if (i, j) not in skips:  # Don't draw on the three finder corners
+					self._draw_alignment_pattern(alignpatpos[i], alignpatpos[j])
+		
+		# Draw configuration data
+		self._draw_format_bits(0)  # Dummy mask value; overwritten later in the constructor
+		self._draw_version()
+	
+	
+	def _draw_format_bits(self, mask: int) -> None:
+		"""Draws two copies of the format bits (with its own error correction code)
+		based on the given mask and this object's error correction level field."""
+		# Calculate error correction code and pack bits
+		data: int = self._errcorlvl.formatbits << 3 | mask  # errCorrLvl is uint2, mask is uint3
+		rem: int = data
+		for _ in range(10):
+			rem = (rem << 1) ^ ((rem >> 9) * 0x537)
+		bits: int = (data << 10 | rem) ^ 0x5412  # uint15
+		assert bits >> 15 == 0
+		
+		# Draw first copy
+		for i in range(0, 6):
+			self._set_function_module(8, i, _get_bit(bits, i))
+		self._set_function_module(8, 7, _get_bit(bits, 6))
+		self._set_function_module(8, 8, _get_bit(bits, 7))
+		self._set_function_module(7, 8, _get_bit(bits, 8))
+		for i in range(9, 15):
+			self._set_function_module(14 - i, 8, _get_bit(bits, i))
+		
+		# Draw second copy
+		for i in range(0, 8):
+			self._set_function_module(self._size - 1 - i, 8, _get_bit(bits, i))
+		for i in range(8, 15):
+			self._set_function_module(8, self._size - 15 + i, _get_bit(bits, i))
+		self._set_function_module(8, self._size - 8, True)  # Always dark
+	
+	
+	def _draw_version(self) -> None:
+		"""Draws two copies of the version bits (with its own error correction code),
+		based on this object's version field, iff 7 <= version <= 40."""
+		if self._version < 7:
+			return
+		
+		# Calculate error correction code and pack bits
+		rem: int = self._version  # version is uint6, in the range [7, 40]
+		for _ in range(12):
+			rem = (rem << 1) ^ ((rem >> 11) * 0x1F25)
+		bits: int = self._version << 12 | rem  # uint18
+		assert bits >> 18 == 0
+		
+		# Draw two copies
+		for i in range(18):
+			bit: bool = _get_bit(bits, i)
+			a: int = self._size - 11 + i % 3
+			b: int = i // 3
+			self._set_function_module(a, b, bit)
+			self._set_function_module(b, a, bit)
+	
+	
+	def _draw_finder_pattern(self, x: int, y: int) -> None:
+		"""Draws a 9*9 finder pattern including the border separator,
+		with the center module at (x, y). Modules can be out of bounds."""
+		for dy in range(-4, 5):
+			for dx in range(-4, 5):
+				xx, yy = x + dx, y + dy
+				if (0 <= xx < self._size) and (0 <= yy < self._size):
+					# Chebyshev/infinity norm
+					self._set_function_module(xx, yy, max(abs(dx), abs(dy)) not in (2, 4))
+	
+	
+	def _draw_alignment_pattern(self, x: int, y: int) -> None:
+		"""Draws a 5*5 alignment pattern, with the center module
+		at (x, y). All modules must be in bounds."""
+		for dy in range(-2, 3):
+			for dx in range(-2, 3):
+				self._set_function_module(x + dx, y + dy, max(abs(dx), abs(dy)) != 1)
+	
+	
+	def _set_function_module(self, x: int, y: int, isdark: bool) -> None:
+		"""Sets the color of a module and marks it as a function module.
+		Only used by the constructor. Coordinates must be in bounds."""
+		assert type(isdark) is bool
+		self._modules[y][x] = isdark
+		self._isfunction[y][x] = True
+	
+	
+	# ---- Private helper methods for constructor: Codewords and masking ----
+	
+	def _add_ecc_and_interleave(self, data: bytearray) -> bytes:
+		"""Returns a new byte string representing the given data with the appropriate error correction
+		codewords appended to it, based on this object's version and error correction level."""
+		version: int = self._version
+		assert len(data) == QrCode._get_num_data_codewords(version, self._errcorlvl)
+		
+		# Calculate parameter numbers
+		numblocks: int = QrCode._NUM_ERROR_CORRECTION_BLOCKS[self._errcorlvl.ordinal][version]
+		blockecclen: int = QrCode._ECC_CODEWORDS_PER_BLOCK  [self._errcorlvl.ordinal][version]
+		rawcodewords: int = QrCode._get_num_raw_data_modules(version) // 8
+		numshortblocks: int = numblocks - rawcodewords % numblocks
+		shortblocklen: int = rawcodewords // numblocks
+		
+		# Split data into blocks and append ECC to each block
+		blocks: List[bytes] = []
+		rsdiv: bytes = QrCode._reed_solomon_compute_divisor(blockecclen)
+		k: int = 0
+		for i in range(numblocks):
+			dat: bytearray = data[k : k + shortblocklen - blockecclen + (0 if i < numshortblocks else 1)]
+			k += len(dat)
+			ecc: bytes = QrCode._reed_solomon_compute_remainder(dat, rsdiv)
+			if i < numshortblocks:
+				dat.append(0)
+			blocks.append(dat + ecc)
+		assert k == len(data)
+		
+		# Interleave (not concatenate) the bytes from every block into a single sequence
+		result = bytearray()
+		for i in range(len(blocks[0])):
+			for (j, blk) in enumerate(blocks):
+				# Skip the padding byte in short blocks
+				if (i != shortblocklen - blockecclen) or (j >= numshortblocks):
+					result.append(blk[i])
+		assert len(result) == rawcodewords
+		return result
+	
+	
+	def _draw_codewords(self, data: bytes) -> None:
+		"""Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+		data area of this QR Code. Function modules need to be marked off before this is called."""
+		assert len(data) == QrCode._get_num_raw_data_modules(self._version) // 8
+		
+		i: int = 0  # Bit index into the data
+		# Do the funny zigzag scan
+		for right in range(self._size - 1, 0, -2):  # Index of right column in each column pair
+			if right <= 6:
+				right -= 1
+			for vert in range(self._size):  # Vertical counter
+				for j in range(2):
+					x: int = right - j  # Actual x coordinate
+					upward: bool = (right + 1) & 2 == 0
+					y: int = (self._size - 1 - vert) if upward else vert  # Actual y coordinate
+					if (not self._isfunction[y][x]) and (i < len(data) * 8):
+						self._modules[y][x] = _get_bit(data[i >> 3], 7 - (i & 7))
+						i += 1
+					# If this QR Code has any remainder bits (0 to 7), they were assigned as
+					# 0/false/light by the constructor and are left unchanged by this method
+		assert i == len(data) * 8
+	
+	
+	def _apply_mask(self, mask: int) -> None:
+		"""XORs the codeword modules in this QR Code with the given mask pattern.
+		The function modules must be marked and the codeword bits must be drawn
+		before masking. Due to the arithmetic of XOR, calling _apply_mask() with
+		the same mask value a second time will undo the mask. A final well-formed
+		QR Code needs exactly one (not zero, two, etc.) mask applied."""
+		if not (0 <= mask <= 7):
+			raise ValueError("Mask value out of range")
+		masker: Callable[[int,int],int] = QrCode._MASK_PATTERNS[mask]
+		for y in range(self._size):
+			for x in range(self._size):
+				self._modules[y][x] ^= (masker(x, y) == 0) and (not self._isfunction[y][x])
+	
+	
+	def _get_penalty_score(self) -> int:
+		"""Calculates and returns the penalty score based on state of this QR Code's current modules.
+		This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score."""
+		result: int = 0
+		size: int = self._size
+		modules: List[List[bool]] = self._modules
+		
+		# Adjacent modules in row having same color, and finder-like patterns
+		for y in range(size):
+			runcolor: bool = False
+			runx: int = 0
+			runhistory = collections.deque([0] * 7, 7)
+			for x in range(size):
+				if modules[y][x] == runcolor:
+					runx += 1
+					if runx == 5:
+						result += QrCode._PENALTY_N1
+					elif runx > 5:
+						result += 1
+				else:
+					self._finder_penalty_add_history(runx, runhistory)
+					if not runcolor:
+						result += self._finder_penalty_count_patterns(runhistory) * QrCode._PENALTY_N3
+					runcolor = modules[y][x]
+					runx = 1
+			result += self._finder_penalty_terminate_and_count(runcolor, runx, runhistory) * QrCode._PENALTY_N3
+		# Adjacent modules in column having same color, and finder-like patterns
+		for x in range(size):
+			runcolor = False
+			runy = 0
+			runhistory = collections.deque([0] * 7, 7)
+			for y in range(size):
+				if modules[y][x] == runcolor:
+					runy += 1
+					if runy == 5:
+						result += QrCode._PENALTY_N1
+					elif runy > 5:
+						result += 1
+				else:
+					self._finder_penalty_add_history(runy, runhistory)
+					if not runcolor:
+						result += self._finder_penalty_count_patterns(runhistory) * QrCode._PENALTY_N3
+					runcolor = modules[y][x]
+					runy = 1
+			result += self._finder_penalty_terminate_and_count(runcolor, runy, runhistory) * QrCode._PENALTY_N3
+		
+		# 2*2 blocks of modules having same color
+		for y in range(size - 1):
+			for x in range(size - 1):
+				if modules[y][x] == modules[y][x + 1] == modules[y + 1][x] == modules[y + 1][x + 1]:
+					result += QrCode._PENALTY_N2
+		
+		# Balance of dark and light modules
+		dark: int = sum((1 if cell else 0) for row in modules for cell in row)
+		total: int = size**2  # Note that size is odd, so dark/total != 1/2
+		# Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+		k: int = (abs(dark * 20 - total * 10) + total - 1) // total - 1
+		assert 0 <= k <= 9
+		result += k * QrCode._PENALTY_N4
+		assert 0 <= result <= 2568888  # Non-tight upper bound based on default values of PENALTY_N1, ..., N4
+		return result
+	
+	
+	# ---- Private helper functions ----
+	
+	def _get_alignment_pattern_positions(self) -> List[int]:
+		"""Returns an ascending list of positions of alignment patterns for this version number.
+		Each position is in the range [0,177), and are used on both the x and y axes.
+		This could be implemented as lookup table of 40 variable-length lists of integers."""
+		ver: int = self._version
+		if ver == 1:
+			return []
+		else:
+			numalign: int = ver // 7 + 2
+			step: int = 26 if (ver == 32) else \
+				(ver * 4 + numalign * 2 + 1) // (numalign * 2 - 2) * 2
+			result: List[int] = [(self._size - 7 - i * step) for i in range(numalign - 1)] + [6]
+			return list(reversed(result))
+	
+	
+	@staticmethod
+	def _get_num_raw_data_modules(ver: int) -> int:
+		"""Returns the number of data bits that can be stored in a QR Code of the given version number, after
+		all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+		The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table."""
+		if not (QrCode.MIN_VERSION <= ver <= QrCode.MAX_VERSION):
+			raise ValueError("Version number out of range")
+		result: int = (16 * ver + 128) * ver + 64
+		if ver >= 2:
+			numalign: int = ver // 7 + 2
+			result -= (25 * numalign - 10) * numalign - 55
+			if ver >= 7:
+				result -= 36
+		assert 208 <= result <= 29648
+		return result
+	
+	
+	@staticmethod
+	def _get_num_data_codewords(ver: int, ecl: QrCode.Ecc) -> int:
+		"""Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+		QR Code of the given version number and error correction level, with remainder bits discarded.
+		This stateless pure function could be implemented as a (40*4)-cell lookup table."""
+		return QrCode._get_num_raw_data_modules(ver) // 8 \
+			- QrCode._ECC_CODEWORDS_PER_BLOCK    [ecl.ordinal][ver] \
+			* QrCode._NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver]
+	
+	
+	@staticmethod
+	def _reed_solomon_compute_divisor(degree: int) -> bytes:
+		"""Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
+		implemented as a lookup table over all possible parameter values, instead of as an algorithm."""
+		if not (1 <= degree <= 255):
+			raise ValueError("Degree out of range")
+		# Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
+		# For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array [255, 8, 93].
+		result = bytearray([0] * (degree - 1) + [1])  # Start off with the monomial x^0
+		
+		# Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
+		# and drop the highest monomial term which is always 1x^degree.
+		# Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
+		root: int = 1
+		for _ in range(degree):  # Unused variable i
+			# Multiply the current product by (x - r^i)
+			for j in range(degree):
+				result[j] = QrCode._reed_solomon_multiply(result[j], root)
+				if j + 1 < degree:
+					result[j] ^= result[j + 1]
+			root = QrCode._reed_solomon_multiply(root, 0x02)
+		return result
+	
+	
+	@staticmethod
+	def _reed_solomon_compute_remainder(data: bytes, divisor: bytes) -> bytes:
+		"""Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials."""
+		result = bytearray([0] * len(divisor))
+		for b in data:  # Polynomial division
+			factor: int = b ^ result.pop(0)
+			result.append(0)
+			for (i, coef) in enumerate(divisor):
+				result[i] ^= QrCode._reed_solomon_multiply(coef, factor)
+		return result
+	
+	
+	@staticmethod
+	def _reed_solomon_multiply(x: int, y: int) -> int:
+		"""Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
+		are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8."""
+		if (x >> 8 != 0) or (y >> 8 != 0):
+			raise ValueError("Byte out of range")
+		# Russian peasant multiplication
+		z: int = 0
+		for i in reversed(range(8)):
+			z = (z << 1) ^ ((z >> 7) * 0x11D)
+			z ^= ((y >> i) & 1) * x
+		assert z >> 8 == 0
+		return z
+	
+	
+	def _finder_penalty_count_patterns(self, runhistory: collections.deque) -> int:
+		"""Can only be called immediately after a light run is added, and
+		returns either 0, 1, or 2. A helper function for _get_penalty_score()."""
+		n: int = runhistory[1]
+		assert n <= self._size * 3
+		core: bool = n > 0 and (runhistory[2] == runhistory[4] == runhistory[5] == n) and runhistory[3] == n * 3
+		return (1 if (core and runhistory[0] >= n * 4 and runhistory[6] >= n) else 0) \
+		     + (1 if (core and runhistory[6] >= n * 4 and runhistory[0] >= n) else 0)
+	
+	
+	def _finder_penalty_terminate_and_count(self, currentruncolor: bool, currentrunlength: int, runhistory: collections.deque) -> int:
+		"""Must be called at the end of a line (row or column) of modules. A helper function for _get_penalty_score()."""
+		if currentruncolor:  # Terminate dark run
+			self._finder_penalty_add_history(currentrunlength, runhistory)
+			currentrunlength = 0
+		currentrunlength += self._size  # Add light border to final run
+		self._finder_penalty_add_history(currentrunlength, runhistory)
+		return self._finder_penalty_count_patterns(runhistory)
+	
+	
+	def _finder_penalty_add_history(self, currentrunlength: int, runhistory: collections.deque) -> None:
+		if runhistory[0] == 0:
+			currentrunlength += self._size  # Add light border to initial run
+		runhistory.appendleft(currentrunlength)
+	
+	
+	# ---- Constants and tables ----
+	
+	MIN_VERSION: int =  1  # The minimum version number supported in the QR Code Model 2 standard
+	MAX_VERSION: int = 40  # The maximum version number supported in the QR Code Model 2 standard
+	
+	# For use in _get_penalty_score(), when evaluating which mask is best.
+	_PENALTY_N1: int =  3
+	_PENALTY_N2: int =  3
+	_PENALTY_N3: int = 40
+	_PENALTY_N4: int = 10
+	
+	_ECC_CODEWORDS_PER_BLOCK: Sequence[Sequence[int]] = (
+		# Version: (note that index 0 is for padding, and is set to an illegal value)
+		# 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+		(-1,  7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30),  # Low
+		(-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28),  # Medium
+		(-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30),  # Quartile
+		(-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30))  # High
+	
+	_NUM_ERROR_CORRECTION_BLOCKS: Sequence[Sequence[int]] = (
+		# Version: (note that index 0 is for padding, and is set to an illegal value)
+		# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+		(-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4,  4,  4,  4,  4,  6,  6,  6,  6,  7,  8,  8,  9,  9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25),  # Low
+		(-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5,  5,  8,  9,  9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49),  # Medium
+		(-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8,  8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68),  # Quartile
+		(-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81))  # High
+	
+	_MASK_PATTERNS: Sequence[Callable[[int,int],int]] = (
+		(lambda x, y:  (x + y) % 2                  ),
+		(lambda x, y:  y % 2                        ),
+		(lambda x, y:  x % 3                        ),
+		(lambda x, y:  (x + y) % 3                  ),
+		(lambda x, y:  (x // 3 + y // 2) % 2        ),
+		(lambda x, y:  x * y % 2 + x * y % 3        ),
+		(lambda x, y:  (x * y % 2 + x * y % 3) % 2  ),
+		(lambda x, y:  ((x + y) % 2 + x * y % 3) % 2),
+	)
+	
+	
+	# ---- Public helper enumeration ----
+	
+	class Ecc:
+		ordinal: int  # (Public) In the range 0 to 3 (unsigned 2-bit integer)
+		formatbits: int  # (Package-private) In the range 0 to 3 (unsigned 2-bit integer)
+		
+		"""The error correction level in a QR Code symbol. Immutable."""
+		# Private constructor
+		def __init__(self, i: int, fb: int) -> None:
+			self.ordinal = i
+			self.formatbits = fb
+		
+		# Placeholders
+		LOW     : QrCode.Ecc
+		MEDIUM  : QrCode.Ecc
+		QUARTILE: QrCode.Ecc
+		HIGH    : QrCode.Ecc
+	
+	# Public constants. Create them outside the class.
+	Ecc.LOW      = Ecc(0, 1)  # The QR Code can tolerate about  7% erroneous codewords
+	Ecc.MEDIUM   = Ecc(1, 0)  # The QR Code can tolerate about 15% erroneous codewords
+	Ecc.QUARTILE = Ecc(2, 3)  # The QR Code can tolerate about 25% erroneous codewords
+	Ecc.HIGH     = Ecc(3, 2)  # The QR Code can tolerate about 30% erroneous codewords
+
+
+
+# ---- Data segment class ----
+
+class QrSegment:
+	"""A segment of character/binary/control data in a QR Code symbol.
+	Instances of this class are immutable.
+	The mid-level way to create a segment is to take the payload data
+	and call a static factory function such as QrSegment.make_numeric().
+	The low-level way to create a segment is to custom-make the bit buffer
+	and call the QrSegment() constructor with appropriate values.
+	This segment class imposes no length restrictions, but QR Codes have restrictions.
+	Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+	Any segment longer than this is meaningless for the purpose of generating QR Codes."""
+	
+	# ---- Static factory functions (mid level) ----
+	
+	@staticmethod
+	def make_bytes(data: Union[bytes,Sequence[int]]) -> QrSegment:
+		"""Returns a segment representing the given binary data encoded in byte mode.
+		All input byte lists are acceptable. Any text string can be converted to
+		UTF-8 bytes (s.encode("UTF-8")) and encoded as a byte mode segment."""
+		bb = _BitBuffer()
+		for b in data:
+			bb.append_bits(b, 8)
+		return QrSegment(QrSegment.Mode.BYTE, len(data), bb)
+	
+	
+	@staticmethod
+	def make_numeric(digits: str) -> QrSegment:
+		"""Returns a segment representing the given string of decimal digits encoded in numeric mode."""
+		if not QrSegment.is_numeric(digits):
+			raise ValueError("String contains non-numeric characters")
+		bb = _BitBuffer()
+		i: int = 0
+		while i < len(digits):  # Consume up to 3 digits per iteration
+			n: int = min(len(digits) - i, 3)
+			bb.append_bits(int(digits[i : i + n]), n * 3 + 1)
+			i += n
+		return QrSegment(QrSegment.Mode.NUMERIC, len(digits), bb)
+	
+	
+	@staticmethod
+	def make_alphanumeric(text: str) -> QrSegment:
+		"""Returns a segment representing the given text string encoded in alphanumeric mode.
+		The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+		dollar, percent, asterisk, plus, hyphen, period, slash, colon."""
+		if not QrSegment.is_alphanumeric(text):
+			raise ValueError("String contains unencodable characters in alphanumeric mode")
+		bb = _BitBuffer()
+		for i in range(0, len(text) - 1, 2):  # Process groups of 2
+			temp: int = QrSegment._ALPHANUMERIC_ENCODING_TABLE[text[i]] * 45
+			temp += QrSegment._ALPHANUMERIC_ENCODING_TABLE[text[i + 1]]
+			bb.append_bits(temp, 11)
+		if len(text) % 2 > 0:  # 1 character remaining
+			bb.append_bits(QrSegment._ALPHANUMERIC_ENCODING_TABLE[text[-1]], 6)
+		return QrSegment(QrSegment.Mode.ALPHANUMERIC, len(text), bb)
+	
+	
+	@staticmethod
+	def make_segments(text: str) -> List[QrSegment]:
+		"""Returns a new mutable list of zero or more segments to represent the given Unicode text string.
+		The result may use various segment modes and switch modes to optimize the length of the bit stream."""
+		
+		# Select the most efficient segment encoding automatically
+		if text == "":
+			return []
+		elif QrSegment.is_numeric(text):
+			return [QrSegment.make_numeric(text)]
+		elif QrSegment.is_alphanumeric(text):
+			return [QrSegment.make_alphanumeric(text)]
+		else:
+			return [QrSegment.make_bytes(text.encode("UTF-8"))]
+	
+	
+	@staticmethod
+	def make_eci(assignval: int) -> QrSegment:
+		"""Returns a segment representing an Extended Channel Interpretation
+		(ECI) designator with the given assignment value."""
+		bb = _BitBuffer()
+		if assignval < 0:
+			raise ValueError("ECI assignment value out of range")
+		elif assignval < (1 << 7):
+			bb.append_bits(assignval, 8)
+		elif assignval < (1 << 14):
+			bb.append_bits(0b10, 2)
+			bb.append_bits(assignval, 14)
+		elif assignval < 1000000:
+			bb.append_bits(0b110, 3)
+			bb.append_bits(assignval, 21)
+		else:
+			raise ValueError("ECI assignment value out of range")
+		return QrSegment(QrSegment.Mode.ECI, 0, bb)
+	
+	
+	# Tests whether the given string can be encoded as a segment in numeric mode.
+	# A string is encodable iff each character is in the range 0 to 9.
+	@staticmethod
+	def is_numeric(text: str) -> bool:
+		return QrSegment._NUMERIC_REGEX.fullmatch(text) is not None
+	
+	
+	# Tests whether the given string can be encoded as a segment in alphanumeric mode.
+	# A string is encodable iff each character is in the following set: 0 to 9, A to Z
+	# (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+	@staticmethod
+	def is_alphanumeric(text: str) -> bool:
+		return QrSegment._ALPHANUMERIC_REGEX.fullmatch(text) is not None
+	
+	
+	# ---- Private fields ----
+	
+	# The mode indicator of this segment. Accessed through get_mode().
+	_mode: QrSegment.Mode
+	
+	# The length of this segment's unencoded data. Measured in characters for
+	# numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	# Always zero or positive. Not the same as the data's bit length.
+	# Accessed through get_num_chars().
+	_numchars: int
+	
+	# The data bits of this segment. Accessed through get_data().
+	_bitdata: List[int]
+	
+	
+	# ---- Constructor (low level) ----
+	
+	def __init__(self, mode: QrSegment.Mode, numch: int, bitdata: Sequence[int]) -> None:
+		"""Creates a new QR Code segment with the given attributes and data.
+		The character count (numch) must agree with the mode and the bit buffer length,
+		but the constraint isn't checked. The given bit buffer is cloned and stored."""
+		if numch < 0:
+			raise ValueError()
+		self._mode = mode
+		self._numchars = numch
+		self._bitdata = list(bitdata)  # Make defensive copy
+	
+	
+	# ---- Accessor methods ----
+	
+	def get_mode(self) -> QrSegment.Mode:
+		"""Returns the mode field of this segment."""
+		return self._mode
+	
+	def get_num_chars(self) -> int:
+		"""Returns the character count field of this segment."""
+		return self._numchars
+	
+	def get_data(self) -> List[int]:
+		"""Returns a new copy of the data bits of this segment."""
+		return list(self._bitdata)  # Make defensive copy
+	
+	
+	# Package-private function
+	@staticmethod
+	def get_total_bits(segs: Sequence[QrSegment], version: int) -> Optional[int]:
+		"""Calculates the number of bits needed to encode the given segments at
+		the given version. Returns a non-negative number if successful. Otherwise
+		returns None if a segment has too many characters to fit its length field."""
+		result = 0
+		for seg in segs:
+			ccbits: int = seg.get_mode().num_char_count_bits(version)
+			if seg.get_num_chars() >= (1 << ccbits):
+				return None  # The segment's length doesn't fit the field's bit width
+			result += 4 + ccbits + len(seg._bitdata)
+		return result
+	
+	
+	# ---- Constants ----
+	
+	# Describes precisely all strings that are encodable in numeric mode.
+	_NUMERIC_REGEX: re.Pattern = re.compile(r"[0-9]*")
+	
+	# Describes precisely all strings that are encodable in alphanumeric mode.
+	_ALPHANUMERIC_REGEX: re.Pattern = re.compile(r"[A-Z0-9 $%*+./:-]*")
+	
+	# Dictionary of "0"->0, "A"->10, "$"->37, etc.
+	_ALPHANUMERIC_ENCODING_TABLE: Dict[str,int] = {ch: i for (i, ch) in enumerate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")}
+	
+	
+	# ---- Public helper enumeration ----
+	
+	class Mode:
+		"""Describes how a segment's data bits are interpreted. Immutable."""
+		
+		_modebits: int  # The mode indicator bits, which is a uint4 value (range 0 to 15)
+		_charcounts: Tuple[int,int,int]  # Number of character count bits for three different version ranges
+		
+		# Private constructor
+		def __init__(self, modebits: int, charcounts: Tuple[int,int,int]):
+			self._modebits = modebits
+			self._charcounts = charcounts
+		
+		# Package-private method
+		def get_mode_bits(self) -> int:
+			"""Returns an unsigned 4-bit integer value (range 0 to 15) representing the mode indicator bits for this mode object."""
+			return self._modebits
+		
+		# Package-private method
+		def num_char_count_bits(self, ver: int) -> int:
+			"""Returns the bit width of the character count field for a segment in this mode
+			in a QR Code at the given version number. The result is in the range [0, 16]."""
+			return self._charcounts[(ver + 7) // 17]
+		
+		# Placeholders
+		NUMERIC     : QrSegment.Mode
+		ALPHANUMERIC: QrSegment.Mode
+		BYTE        : QrSegment.Mode
+		KANJI       : QrSegment.Mode
+		ECI         : QrSegment.Mode
+	
+	# Public constants. Create them outside the class.
+	Mode.NUMERIC      = Mode(0x1, (10, 12, 14))
+	Mode.ALPHANUMERIC = Mode(0x2, ( 9, 11, 13))
+	Mode.BYTE         = Mode(0x4, ( 8, 16, 16))
+	Mode.KANJI        = Mode(0x8, ( 8, 10, 12))
+	Mode.ECI          = Mode(0x7, ( 0,  0,  0))
+
+
+
+# ---- Private helper class ----
+
+class _BitBuffer(list):
+	"""An appendable sequence of bits (0s and 1s). Mainly used by QrSegment."""
+	
+	def append_bits(self, val: int, n: int) -> None:
+		"""Appends the given number of low-order bits of the given
+		value to this buffer. Requires n >= 0 and 0 <= val < 2^n."""
+		if (n < 0) or (val >> n != 0):
+			raise ValueError("Value out of range")
+		self.extend(((val >> i) & 1) for i in reversed(range(n)))
+
+
+def _get_bit(x: int, i: int) -> bool:
+	"""Returns true iff the i'th bit of x is set to 1."""
+	return (x >> i) & 1 != 0
+
+
+
+class DataTooLongError(ValueError):
+	"""Raised when the supplied data does not fit any QR Code version. Ways to handle this exception include:
+	- Decrease the error correction level if it was greater than Ecc.LOW.
+	- If the encode_segments() function was called with a maxversion argument, then increase
+	  it if it was less than QrCode.MAX_VERSION. (This advice does not apply to the other
+	  factory functions because they search all versions up to QrCode.MAX_VERSION.)
+	- Split the text data into better or optimal segments in order to reduce the number of bits required.
+	- Change the text or binary data to be shorter.
+	- Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).
+	- Propagate the error upward to the caller/user."""
+	pass

Telegram/ThirdParty/QR/python/setup.py

@@ -0,0 +1,107 @@
+# 
+# QR Code generator Distutils script (Python)
+# 
+# Copyright (c) Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/qr-code-generator-library
+# 
+# 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.
+# 
+
+import setuptools
+
+
+setuptools.setup(
+	name = "qrcodegen",
+	description = "High quality QR Code generator library for Python",
+	version = "1.8.0",
+	platforms = "OS Independent",
+	python_requires = '>=3',
+	license = "MIT License",
+	
+	author = "Project Nayuki",
+	author_email = "me@nayuki.io",
+	url = "https://www.nayuki.io/page/qr-code-generator-library",
+	
+	classifiers = [
+		"Development Status :: 5 - Production/Stable",
+		"Intended Audience :: Developers",
+		"Intended Audience :: Information Technology",
+		"License :: OSI Approved :: MIT License",
+		"Operating System :: OS Independent",
+		"Programming Language :: Python",
+		"Programming Language :: Python :: 3",
+		"Topic :: Multimedia :: Graphics",
+		"Topic :: Software Development :: Libraries :: Python Modules",
+	],
+	
+	long_description = """=========================
+QR Code generator library
+=========================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+::
+
+    from qrcodegen import *
+    
+    # Simple operation
+    qr0 = QrCode.encode_text("Hello, world!", QrCode.Ecc.MEDIUM)
+    svg = to_svg_str(qr0, 4)  # See qrcodegen-demo
+    
+    # Manual operation
+    segs = QrSegment.make_segments("3141592653589793238462643383")
+    qr1 = QrCode.encode_segments(segs, QrCode.Ecc.HIGH, 5, 5, 2, False)
+    for y in range(qr1.get_size()):
+        for x in range(qr1.get_size()):
+            (... paint qr1.get_module(x, y) ...)
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/python/qrcodegen-demo.py .""",
+	
+	py_modules = ["qrcodegen"],
+)

Telegram/ThirdParty/QR/rust-no-heap/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "qrcodegen"
+version = "1.8.0"
+authors = ["Project Nayuki"]
+description = "High-quality QR Code generator library"
+homepage = "https://www.nayuki.io/page/qr-code-generator-library"
+repository = "https://github.com/nayuki/QR-Code-generator"
+license = "MIT"

Telegram/ThirdParty/QR/rust-no-heap/Readme.markdown

@@ -0,0 +1,71 @@
+QR Code generator library - Rust, no heap
+=========================================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Completely avoids heap allocation (e.g. `std::vec::Vec`), instead relying on suitably sized buffers from the caller and fixed-size stack allocations
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```rust
+extern crate qrcodegen;
+use qrcodegen::Mask;
+use qrcodegen::QrCode;
+use qrcodegen::QrCodeEcc;
+use qrcodegen::Version;
+
+// Text data
+let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+let qr = QrCode::encode_text("Hello, world!",
+    &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
+    Version::MIN, Version::MAX, None, true).unwrap();
+let svg = to_svg_string(&qr, 4);  // See qrcodegen-demo
+
+// Binary data
+let mut outbuffer   = vec![0u8; Version::MAX.buffer_len()];
+let mut dataandtemp = vec![0u8; Version::MAX.buffer_len()];
+dataandtemp[0] = 0xE3;
+dataandtemp[1] = 0x81;
+dataandtemp[2] = 0x82;
+let qr = QrCode::encode_binary(&mut dataandtemp, 3,
+    &mut outbuffer, QrCodeEcc::High,
+    Version::new(2), Version::new(7),
+    Some(Mask::new(4)), false).unwrap();
+for y in 0 .. qr.size() {
+    for x in 0 .. qr.size() {
+        (... paint qr.get_module(x, y) ...)
+    }
+}
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/rust-no-heap/examples/qrcodegen-demo.rs .

Telegram/ThirdParty/QR/rust-no-heap/examples/qrcodegen-demo.rs

@@ -0,0 +1,267 @@
+/* 
+ * QR Code generator demo (Rust, no heap)
+ * 
+ * Run this command-line program with no arguments. The program computes a bunch of demonstration
+ * QR Codes and prints them to the console. Also, the SVG code for one QR Code is printed as a sample.
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+extern crate qrcodegen;
+use qrcodegen::Mask;
+use qrcodegen::QrCode;
+use qrcodegen::QrCodeEcc;
+use qrcodegen::QrSegment;
+use qrcodegen::QrSegmentMode;
+use qrcodegen::Version;
+
+
+// The main application program.
+fn main() {
+	do_basic_demo();
+	do_variety_demo();
+	do_segment_demo();
+	do_mask_demo();
+}
+
+
+
+/*---- Demo suite ----*/
+
+// Creates a single QR Code, then prints it to the console.
+fn do_basic_demo() {
+	let text: &'static str = "Hello, world!";   // User-supplied Unicode text
+	let errcorlvl: QrCodeEcc = QrCodeEcc::Low;  // Error correction level
+	
+	// Make and print the QR Code symbol
+	let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+	let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+	let qr: QrCode = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer,
+		errcorlvl, Version::MIN, Version::MAX, None, true).unwrap();
+	// Note: qr has a reference to outbuffer, so outbuffer needs to outlive qr
+	std::mem::drop(tempbuffer);  // Optional, because tempbuffer is only needed during encode_text()
+	print_qr(&qr);
+	println!("{}", to_svg_string(&qr, 4));
+}
+
+
+// Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console.
+fn do_variety_demo() {
+	{  // Numeric mode encoding (3.33 bits per digit)
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text("314159265358979323846264338327950288419716939937510",
+			&mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+	}
+	
+	{  // Alphanumeric mode encoding (5.5 bits per character)
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/",
+			&mut tempbuffer, &mut outbuffer, QrCodeEcc::High, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+	}
+	
+	{  // Unicode text as UTF-8
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text("こんにちwa、世界！ αβγδ",
+			&mut tempbuffer, &mut outbuffer, QrCodeEcc::Quartile, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+	}
+	
+	{  // Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+		let text = concat!(
+			"Alice was beginning to get very tired of sitting by her sister on the bank, ",
+			"and of having nothing to do: once or twice she had peeped into the book her sister was reading, ",
+			"but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice ",
+			"'without pictures or conversations?' So she was considering in her own mind (as well as she could, ",
+			"for the hot day made her feel very sleepy and stupid), whether the pleasure of making a ",
+			"daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly ",
+			"a White Rabbit with pink eyes ran close by her.");
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer,
+			QrCodeEcc::High, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+	}
+}
+
+
+// Creates QR Codes with manually specified segments for better compactness.
+fn do_segment_demo() {
+	{  // Illustration "silver"
+		let silver0 = "THE SQUARE ROOT OF 2 IS 1.";
+		let silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text(&[silver0, silver1].concat(), &mut tempbuffer, &mut outbuffer,
+			QrCodeEcc::Low, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+		
+		let (tempbuf0, tempbuf1) = tempbuffer.split_at_mut(QrSegment::calc_buffer_size(QrSegmentMode::Alphanumeric, silver0.len()).unwrap());
+		let segs = [
+			QrSegment::make_alphanumeric(silver0, tempbuf0),
+			QrSegment::make_numeric(silver1, tempbuf1),
+		];
+		let (datacodewordslen, ecl, version) = QrCode::encode_segments_to_codewords(
+			&segs, &mut outbuffer, QrCodeEcc::Low, Version::MIN, Version::MAX, true).unwrap();
+		std::mem::drop(segs);  // Implied, because segs has references to tempbuffer, but tempbuffer will be reused in encode_codewords()
+		let qr = QrCode::encode_codewords(&mut outbuffer, datacodewordslen, &mut tempbuffer, ecl, version, None);
+		print_qr(&qr);
+	}
+	
+	{  // Illustration "golden"
+		let golden0 = "Golden ratio φ = 1.";
+		let golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+		let golden2 = "......";
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text(&[golden0, golden1, golden2].concat(), &mut tempbuffer, &mut outbuffer,
+			QrCodeEcc::Low, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+		
+		let (tempbuf1, tempbuf2) = tempbuffer.split_at_mut(QrSegment::calc_buffer_size(QrSegmentMode::Numeric, golden1.len()).unwrap());
+		let segs = [
+			QrSegment::make_bytes(golden0.as_bytes()),
+			QrSegment::make_numeric(golden1, tempbuf1),
+			QrSegment::make_alphanumeric(golden2, tempbuf2),
+		];
+		let (datacodewordslen, ecl, version) = QrCode::encode_segments_to_codewords(
+			&segs, &mut outbuffer, QrCodeEcc::Low, Version::MIN, Version::MAX, true).unwrap();
+		let qr = QrCode::encode_codewords(&mut outbuffer, datacodewordslen, &mut tempbuffer, ecl, version, None);
+		print_qr(&qr);
+	}
+	
+	{  // Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+		let madoka = "「魔法少女まどか☆マギカ」って、　ИАИ　ｄｅｓｕ　κα？";
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		let qr = QrCode::encode_text(madoka, &mut outbuffer, &mut tempbuffer,
+			QrCodeEcc::Low, Version::MIN, Version::MAX, None, true).unwrap();
+		print_qr(&qr);
+		
+		let kanjichars: Vec<u32> = vec![  // Kanji mode encoding (13 bits per character)
+			0x0035, 0x1002, 0x0FC0, 0x0AED, 0x0AD7,
+			0x015C, 0x0147, 0x0129, 0x0059, 0x01BD,
+			0x018D, 0x018A, 0x0036, 0x0141, 0x0144,
+			0x0001, 0x0000, 0x0249, 0x0240, 0x0249,
+			0x0000, 0x0104, 0x0105, 0x0113, 0x0115,
+			0x0000, 0x0208, 0x01FF, 0x0008,
+		];
+		let mut bb = qrcodegen::BitBuffer::new(&mut tempbuffer);
+		for &c in &kanjichars {
+			bb.append_bits(c, 13);
+		}
+		let segs = [
+			{
+				let bitlen = bb.len();
+				QrSegment::new(qrcodegen::QrSegmentMode::Kanji, kanjichars.len(), &tempbuffer, bitlen)
+			},
+		];
+		let (datacodewordslen, ecl, version) = QrCode::encode_segments_to_codewords(
+			&segs, &mut outbuffer, QrCodeEcc::Low, Version::MIN, Version::MAX, true).unwrap();
+		let qr = QrCode::encode_codewords(&mut outbuffer, datacodewordslen, &mut tempbuffer, ecl, version, None);
+		print_qr(&qr);
+	}
+}
+
+
+// Creates QR Codes with the same size and contents but different mask patterns.
+fn do_mask_demo() {
+	{  // Project Nayuki URL
+		let text = "https://www.nayuki.io/";
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::High,
+			Version::MIN, Version::MAX, None, true).unwrap();  // Automatic mask
+		print_qr(&qr);
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::High,
+			Version::MIN, Version::MAX, Some(Mask::new(3)), true).unwrap();  // Force mask 3
+		print_qr(&qr);
+	}
+	
+	{  // Chinese text as UTF-8
+		let text = "維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫";
+		let mut outbuffer  = vec![0u8; Version::MAX.buffer_len()];
+		let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
+		
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
+			Version::MIN, Version::MAX, Some(Mask::new(0)), true).unwrap();  // Force mask 0
+		print_qr(&qr);
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
+			Version::MIN, Version::MAX, Some(Mask::new(1)), true).unwrap();  // Force mask 1
+		print_qr(&qr);
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
+			Version::MIN, Version::MAX, Some(Mask::new(5)), true).unwrap();  // Force mask 5
+		print_qr(&qr);
+		let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
+			Version::MIN, Version::MAX, Some(Mask::new(7)), true).unwrap();  // Force mask 7
+		print_qr(&qr);
+	}
+}
+
+
+
+/*---- Utilities ----*/
+
+// Returns a string of SVG code for an image depicting
+// the given QR Code, with the given number of border modules.
+// The string always uses Unix newlines (\n), regardless of the platform.
+fn to_svg_string(qr: &QrCode, border: i32) -> String {
+	assert!(border >= 0, "Border must be non-negative");
+	let mut result = String::new();
+	result += "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+	result += "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
+	let dimension = qr.size().checked_add(border.checked_mul(2).unwrap()).unwrap();
+	result += &format!(
+		"<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 {0} {0}\" stroke=\"none\">\n", dimension);
+	result += "\t<rect width=\"100%\" height=\"100%\" fill=\"#FFFFFF\"/>\n";
+	result += "\t<path d=\"";
+	for y in 0 .. qr.size() {
+		for x in 0 .. qr.size() {
+			if qr.get_module(x, y) {
+				if x != 0 || y != 0 {
+					result += " ";
+				}
+				result += &format!("M{},{}h1v1h-1z", x + border, y + border);
+			}
+		}
+	}
+	result += "\" fill=\"#000000\"/>\n";
+	result += "</svg>\n";
+	result
+}
+
+
+// Prints the given QrCode object to the console.
+fn print_qr(qr: &QrCode) {
+	let border: i32 = 4;
+	for y in -border .. qr.size() + border {
+		for x in -border .. qr.size() + border {
+			let c: char = if qr.get_module(x, y) { '█' } else { ' ' };
+			print!("{0}{0}", c);
+		}
+		println!();
+	}
+	println!();
+}

Telegram/ThirdParty/QR/rust/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "qrcodegen"
+version = "1.8.0"
+authors = ["Project Nayuki"]
+description = "High-quality QR Code generator library"
+homepage = "https://www.nayuki.io/page/qr-code-generator-library"
+repository = "https://github.com/nayuki/QR-Code-generator"
+readme = "Readme.markdown"
+keywords = ["qr-code", "barcode", "encoder", "image"]
+categories = ["encoding", "multimedia::images"]
+license = "MIT"
+exclude = ["examples/*"]

Telegram/ThirdParty/QR/rust/Readme.markdown

@@ -0,0 +1,64 @@
+QR Code generator library - Rust
+================================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```rust
+extern crate qrcodegen;
+use qrcodegen::Mask;
+use qrcodegen::QrCode;
+use qrcodegen::QrCodeEcc;
+use qrcodegen::QrSegment;
+use qrcodegen::Version;
+
+// Simple operation
+let qr = QrCode::encode_text("Hello, world!",
+    QrCodeEcc::Medium).unwrap();
+let svg = to_svg_string(&qr, 4);  // See qrcodegen-demo
+
+// Manual operation
+let text: &str = "3141592653589793238462643383";
+let segs = QrSegment::make_segments(text);
+let qr = QrCode::encode_segments_advanced(&segs,
+    QrCodeEcc::High, Version::new(5), Version::new(5),
+    Some(Mask::new(2)), false).unwrap();
+for y in 0 .. qr.size() {
+    for x in 0 .. qr.size() {
+        (... paint qr.get_module(x, y) ...)
+    }
+}
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/rust/examples/qrcodegen-demo.rs .

Telegram/ThirdParty/QR/rust/examples/qrcodegen-demo.rs

@@ -0,0 +1,206 @@
+/* 
+ * QR Code generator demo (Rust)
+ * 
+ * Run this command-line program with no arguments. The program computes a bunch of demonstration
+ * QR Codes and prints them to the console. Also, the SVG code for one QR Code is printed as a sample.
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+extern crate qrcodegen;
+use qrcodegen::Mask;
+use qrcodegen::QrCode;
+use qrcodegen::QrCodeEcc;
+use qrcodegen::QrSegment;
+use qrcodegen::Version;
+
+
+// The main application program.
+fn main() {
+	do_basic_demo();
+	do_variety_demo();
+	do_segment_demo();
+	do_mask_demo();
+}
+
+
+
+/*---- Demo suite ----*/
+
+// Creates a single QR Code, then prints it to the console.
+fn do_basic_demo() {
+	let text: &'static str = "Hello, world!";   // User-supplied Unicode text
+	let errcorlvl: QrCodeEcc = QrCodeEcc::Low;  // Error correction level
+	
+	// Make and print the QR Code symbol
+	let qr: QrCode = QrCode::encode_text(text, errcorlvl).unwrap();
+	print_qr(&qr);
+	println!("{}", to_svg_string(&qr, 4));
+}
+
+
+// Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console.
+fn do_variety_demo() {
+	// Numeric mode encoding (3.33 bits per digit)
+	let qr = QrCode::encode_text("314159265358979323846264338327950288419716939937510", QrCodeEcc::Medium).unwrap();
+	print_qr(&qr);
+	
+	// Alphanumeric mode encoding (5.5 bits per character)
+	let qr = QrCode::encode_text("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCodeEcc::High).unwrap();
+	print_qr(&qr);
+	
+	// Unicode text as UTF-8
+	let qr = QrCode::encode_text("こんにちwa、世界！ αβγδ", QrCodeEcc::Quartile).unwrap();
+	print_qr(&qr);
+	
+	// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+	let qr = QrCode::encode_text(concat!(
+		"Alice was beginning to get very tired of sitting by her sister on the bank, ",
+		"and of having nothing to do: once or twice she had peeped into the book her sister was reading, ",
+		"but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice ",
+		"'without pictures or conversations?' So she was considering in her own mind (as well as she could, ",
+		"for the hot day made her feel very sleepy and stupid), whether the pleasure of making a ",
+		"daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly ",
+		"a White Rabbit with pink eyes ran close by her."), QrCodeEcc::High).unwrap();
+	print_qr(&qr);
+}
+
+
+// Creates QR Codes with manually specified segments for better compactness.
+fn do_segment_demo() {
+	// Illustration "silver"
+	let silver0 = "THE SQUARE ROOT OF 2 IS 1.";
+	let silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
+	let qr = QrCode::encode_text(&[silver0, silver1].concat(), QrCodeEcc::Low).unwrap();
+	print_qr(&qr);
+	
+	let segs = vec![
+		QrSegment::make_alphanumeric(silver0),
+		QrSegment::make_numeric(silver1),
+	];
+	let qr = QrCode::encode_segments(&segs, QrCodeEcc::Low).unwrap();
+	print_qr(&qr);
+	
+	// Illustration "golden"
+	let golden0 = "Golden ratio φ = 1.";
+	let golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+	let golden2 = "......";
+	let qr = QrCode::encode_text(&[golden0, golden1, golden2].concat(), QrCodeEcc::Low).unwrap();
+	print_qr(&qr);
+	
+	let segs = vec![
+		QrSegment::make_bytes(golden0.as_bytes()),
+		QrSegment::make_numeric(golden1),
+		QrSegment::make_alphanumeric(golden2),
+	];
+	let qr = QrCode::encode_segments(&segs, QrCodeEcc::Low).unwrap();
+	print_qr(&qr);
+	
+	// Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+	let madoka = "「魔法少女まどか☆マギカ」って、　ИАИ　ｄｅｓｕ　κα？";
+	let qr = QrCode::encode_text(madoka, QrCodeEcc::Low).unwrap();
+	print_qr(&qr);
+	
+	let kanjichars: Vec<u32> = vec![  // Kanji mode encoding (13 bits per character)
+		0x0035, 0x1002, 0x0FC0, 0x0AED, 0x0AD7,
+		0x015C, 0x0147, 0x0129, 0x0059, 0x01BD,
+		0x018D, 0x018A, 0x0036, 0x0141, 0x0144,
+		0x0001, 0x0000, 0x0249, 0x0240, 0x0249,
+		0x0000, 0x0104, 0x0105, 0x0113, 0x0115,
+		0x0000, 0x0208, 0x01FF, 0x0008,
+	];
+	let mut bb = qrcodegen::BitBuffer(Vec::new());
+	for &c in &kanjichars {
+		bb.append_bits(c, 13);
+	}
+	let segs = vec![
+		QrSegment::new(qrcodegen::QrSegmentMode::Kanji, kanjichars.len(), bb.0),
+	];
+	let qr = QrCode::encode_segments(&segs, QrCodeEcc::Low).unwrap();
+	print_qr(&qr);
+}
+
+
+// Creates QR Codes with the same size and contents but different mask patterns.
+fn do_mask_demo() {
+	// Project Nayuki URL
+	let segs = QrSegment::make_segments("https://www.nayuki.io/");
+	let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High, Version::MIN, Version::MAX, None, true).unwrap();  // Automatic mask
+	print_qr(&qr);
+	let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High, Version::MIN, Version::MAX, Some(Mask::new(3)), true).unwrap();  // Force mask 3
+	print_qr(&qr);
+	
+	// Chinese text as UTF-8
+	let segs = QrSegment::make_segments("維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫");
+	let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::Medium, Version::MIN, Version::MAX, Some(Mask::new(0)), true).unwrap();  // Force mask 0
+	print_qr(&qr);
+	let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::Medium, Version::MIN, Version::MAX, Some(Mask::new(1)), true).unwrap();  // Force mask 1
+	print_qr(&qr);
+	let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::Medium, Version::MIN, Version::MAX, Some(Mask::new(5)), true).unwrap();  // Force mask 5
+	print_qr(&qr);
+	let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::Medium, Version::MIN, Version::MAX, Some(Mask::new(7)), true).unwrap();  // Force mask 7
+	print_qr(&qr);
+}
+
+
+
+/*---- Utilities ----*/
+
+// Returns a string of SVG code for an image depicting
+// the given QR Code, with the given number of border modules.
+// The string always uses Unix newlines (\n), regardless of the platform.
+fn to_svg_string(qr: &QrCode, border: i32) -> String {
+	assert!(border >= 0, "Border must be non-negative");
+	let mut result = String::new();
+	result += "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+	result += "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
+	let dimension = qr.size().checked_add(border.checked_mul(2).unwrap()).unwrap();
+	result += &format!(
+		"<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 {0} {0}\" stroke=\"none\">\n", dimension);
+	result += "\t<rect width=\"100%\" height=\"100%\" fill=\"#FFFFFF\"/>\n";
+	result += "\t<path d=\"";
+	for y in 0 .. qr.size() {
+		for x in 0 .. qr.size() {
+			if qr.get_module(x, y) {
+				if x != 0 || y != 0 {
+					result += " ";
+				}
+				result += &format!("M{},{}h1v1h-1z", x + border, y + border);
+			}
+		}
+	}
+	result += "\" fill=\"#000000\"/>\n";
+	result += "</svg>\n";
+	result
+}
+
+
+// Prints the given QrCode object to the console.
+fn print_qr(qr: &QrCode) {
+	let border: i32 = 4;
+	for y in -border .. qr.size() + border {
+		for x in -border .. qr.size() + border {
+			let c: char = if qr.get_module(x, y) { '█' } else { ' ' };
+			print!("{0}{0}", c);
+		}
+		println!();
+	}
+	println!();
+}

Telegram/ThirdParty/QR/typescript-javascript/Readme.markdown

@@ -0,0 +1,56 @@
+QR Code generator library - TypeScript
+======================================
+
+
+Introduction
+------------
+
+This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
+
+Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
+
+
+Features
+--------
+
+Core features:
+
+* Significantly shorter code but more documentation comments compared to competing libraries
+* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
+* Output format: Raw modules/pixels of the QR symbol
+* Detects finder-like penalty patterns more accurately than other implementations
+* Encodes numeric and special-alphanumeric text in less space than general text
+* Open-source code under the permissive MIT License
+
+Manual parameters:
+
+* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
+* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
+* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
+* User can create a list of data segments manually and add ECI segments
+
+More information about QR Code technology and this library's design can be found on the project home page.
+
+
+Examples
+--------
+
+```typescript
+// Name abbreviated for the sake of these examples here
+const QRC = qrcodegen.QrCode;
+
+// Simple operation
+const qr0 = QRC.encodeText("Hello, world!", QRC.Ecc.MEDIUM);
+const svg = toSvgString(qr0, 4);  // See qrcodegen-input-demo
+
+// Manual operation
+const segs = qrcodegen.QrSegment.makeSegments("3141592653589793238462643383");
+const qr1 = QRC.encodeSegments(segs, QRC.Ecc.HIGH, 5, 5, 2, false);
+for (let y = 0; y < qr1.size; y++) {
+    for (let x = 0; x < qr1.size; x++) {
+        (... paint qr1.getModule(x, y) ...)
+    }
+}
+```
+
+More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/typescript-javascript/qrcodegen-output-demo.ts .

Telegram/ThirdParty/QR/typescript-javascript/build.sh

@@ -0,0 +1,25 @@
+# 
+# Build script for QR Code generator (TypeScript)
+# 
+# Copyright (c) Project Nayuki. (MIT License)
+# https://www.nayuki.io/page/qr-code-generator-library
+# 
+# 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.
+# 
+
+tsc --strict --lib DOM,DOM.Iterable,ES6 --target ES6 qrcodegen.ts qrcodegen-input-demo.ts
+tsc --strict --lib DOM,DOM.Iterable,ES6 --target ES6 qrcodegen.ts qrcodegen-output-demo.ts

Telegram/ThirdParty/QR/typescript-javascript/qrcodegen-input-demo.html

@@ -0,0 +1,156 @@
+<!--
+  - QR Code generator input demo (HTML+JavaScript)
+  - 
+  - Copyright (c) Project Nayuki. (MIT License)
+  - https://www.nayuki.io/page/qr-code-generator-library
+  - 
+  - 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.
+  -->
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="UTF-8">
+		<title>QR Code generator input demo (JavaScript)</title>
+		<style type="text/css">
+			html {
+				font-family: sans-serif;
+			}
+			h1 {
+				text-align: center;
+			}
+			table {
+				border-collapse: collapse;
+			}
+			td {
+				vertical-align: top;
+				padding-top: 0.2em;
+				padding-bottom: 0.2em;
+			}
+			td:first-child {
+				white-space: pre;
+				padding-right: 0.5em;
+			}
+			input[type=number], input[type=text], textarea {
+				font-size: inherit;
+				font-family: inherit;
+			}
+			input[type=radio], input[type=checkbox] {
+				margin: 0em;
+				padding: 0em;
+			}
+			input[type=radio] + label, input[type=checkbox] + label {
+				margin-right: 0.8em;
+				padding-left: 0.2em;
+			}
+			hr {
+				margin: 2em 0em;
+				border: none;
+				border-top: 0.1em solid #A0A0A0;
+			}
+		</style>
+	</head>
+	
+	<body>
+		<h1>QR Code generator input demo (JavaScript)</h1>
+		<div id="loading">
+			<p>Loading application...</p>
+			<p>(Are the JavaScript files missing?)</p>
+			<p>(The JavaScript code needs to be compiled from the TypeScript code.)</p>
+		</div>
+		<form id="loaded" style="display:none" onsubmit="event.preventDefault();">
+			<table>
+				<tbody>
+					<tr>
+						<td><strong>Text string:</strong></td>
+						<td><textarea placeholder="Enter your text to be put into the QR Code" id="text-input" style="width:30em; height:5em"></textarea></td>
+					</tr>
+					<tr>
+						<td><strong>QR Code:</strong></td>
+						<td>
+							<canvas id="qrcode-canvas" style="padding:1em; background-color:#E8E8E8"></canvas>
+							<svg id="qrcode-svg" style="width:30em; height:30em; padding:1em; background-color:#E8E8E8">
+								<rect width="100%" height="100%" fill="#FFFFFF" stroke-width="0"></rect>
+								<path d="" fill="#000000" stroke-width="0"></path>
+							</svg>
+						</td>
+					</tr>
+					<tr>
+						<td><strong>Error correction:</strong></td>
+						<td>
+							<input type="radio" name="errcorlvl" id="errcorlvl-low" checked="checked"><label for="errcorlvl-low">Low</label>
+							<input type="radio" name="errcorlvl" id="errcorlvl-medium"><label for="errcorlvl-medium">Medium</label>
+							<input type="radio" name="errcorlvl" id="errcorlvl-quartile"><label for="errcorlvl-quartile">Quartile</label>
+							<input type="radio" name="errcorlvl" id="errcorlvl-high"><label for="errcorlvl-high">High</label>
+						</td>
+					</tr>
+					<tr>
+						<td>Output format:</td>
+						<td>
+							<input type="radio" name="output-format" id="output-format-bitmap" checked="checked"><label for="output-format-bitmap">Bitmap</label>
+							<input type="radio" name="output-format" id="output-format-vector"><label for="output-format-vector">Vector</label>
+						</td>
+					</tr>
+					<tr>
+						<td>Border:</td>
+						<td><input type="number" value="4" min="0" max="100" step="1" id="border-input" style="width:4em"> modules</td>
+					</tr>
+					<tr id="scale-row">
+						<td>Scale:</td>
+						<td><input type="number" value="8" min="1" max="30" step="1" id="scale-input" style="width:4em"> pixels per module</td>
+					</tr>
+					<tr>
+						<td>Colors:</td>
+						<td>
+							Light = <input type="text" value="#FFFFFF" id="light-color-input" style="width:6em">,
+							dark = <input type="text" value="#000000" id="dark-color-input" style="width:6em">
+						</td>
+					</tr>
+					<tr>
+						<td>Version range:</td>
+						<td>
+							Minimum = <input type="number" value="1"  min="1" max="40" step="1" id="version-min-input" style="width:4em" oninput="app.handleVersionMinMax('min');">,
+							maximum = <input type="number" value="40" min="1" max="40" step="1" id="version-max-input" style="width:4em" oninput="app.handleVersionMinMax('max');">
+						</td>
+					</tr>
+					<tr>
+						<td>Mask pattern:</td>
+						<td><input type="number" value="-1" min="-1" max="7" step="1" id="mask-input" style="width:4em"> (−1 for automatic, 0 to 7 for manual)</td>
+					</tr>
+					<tr>
+						<td>Boost ECC:</td>
+						<td><input type="checkbox" checked="checked" id="boost-ecc-input"><label for="boost-ecc-input">Increase <abbr title="error-correcting code">ECC</abbr> level within same version</label></td>
+					</tr>
+					<tr>
+						<td>Statistics:</td>
+						<td id="statistics-output" style="white-space:pre"></td>
+					</tr>
+					<tr id="svg-xml-row">
+						<td>SVG XML code:</td>
+						<td>
+							<textarea id="svg-xml-output" readonly="readonly" style="width:100%; max-width:50em; height:15em; font-family:monospace"></textarea>
+						</td>
+					</tr>
+				</tbody>
+			</table>
+		</form>
+		<script type="application/javascript" src="qrcodegen.js"></script>
+		<script type="application/javascript" src="qrcodegen-input-demo.js"></script>
+		
+		<hr>
+		<p>Copyright © Project Nayuki – <a href="https://www.nayuki.io/page/qr-code-generator-library">https://www.nayuki.io/page/qr-code-generator-library</a></p>
+	</body>
+</html>

Telegram/ThirdParty/QR/typescript-javascript/qrcodegen-input-demo.ts

@@ -0,0 +1,231 @@
+/* 
+ * QR Code generator input demo (TypeScript)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+"use strict";
+
+
+namespace app {
+	
+	function initialize(): void {
+		getElem("loading").style.display = "none";
+		getElem("loaded").style.removeProperty("display");
+		let elems = document.querySelectorAll("input[type=number], input[type=text], textarea");
+		for (let el of elems) {
+			if (el.id.indexOf("version-") != 0)
+				(el as any).oninput = redrawQrCode;
+		}
+		elems = document.querySelectorAll("input[type=radio], input[type=checkbox]");
+		for (let el of elems)
+			(el as HTMLInputElement).onchange = redrawQrCode;
+		redrawQrCode();
+	}
+	
+	
+	function redrawQrCode(): void {
+		// Show/hide rows based on bitmap/vector image output
+		const bitmapOutput: boolean = getInput("output-format-bitmap").checked;
+		const scaleRow : HTMLElement = getElem("scale-row");
+		const svgXmlRow: HTMLElement = getElem("svg-xml-row");
+		if (bitmapOutput) {
+			scaleRow.style.removeProperty("display");
+			svgXmlRow.style.display = "none";
+		} else {
+			scaleRow.style.display = "none";
+			svgXmlRow.style.removeProperty("display");
+		}
+		const svgXml = getElem("svg-xml-output") as HTMLTextAreaElement;
+		svgXml.value = "";
+		
+		// Reset output images in case of early termination
+		const canvas = getElem("qrcode-canvas") as HTMLCanvasElement;
+		const svg = (document.getElementById("qrcode-svg") as Element) as SVGElement;
+		canvas.style.display = "none";
+		svg.style.display = "none";
+		
+		// Returns a QrCode.Ecc object based on the radio buttons in the HTML form.
+		function getInputErrorCorrectionLevel(): qrcodegen.QrCode.Ecc {
+			if (getInput("errcorlvl-medium").checked)
+				return qrcodegen.QrCode.Ecc.MEDIUM;
+			else if (getInput("errcorlvl-quartile").checked)
+				return qrcodegen.QrCode.Ecc.QUARTILE;
+			else if (getInput("errcorlvl-high").checked)
+				return qrcodegen.QrCode.Ecc.HIGH;
+			else  // In case no radio button is depressed
+				return qrcodegen.QrCode.Ecc.LOW;
+		}
+		
+		// Get form inputs and compute QR Code
+		const ecl: qrcodegen.QrCode.Ecc = getInputErrorCorrectionLevel();
+		const text: string = (getElem("text-input") as HTMLTextAreaElement).value;
+		const segs: Array<qrcodegen.QrSegment> = qrcodegen.QrSegment.makeSegments(text);
+		const minVer: number = parseInt(getInput("version-min-input").value, 10);
+		const maxVer: number = parseInt(getInput("version-max-input").value, 10);
+		const mask: number = parseInt(getInput("mask-input").value, 10);
+		const boostEcc: boolean = getInput("boost-ecc-input").checked;
+		const qr: qrcodegen.QrCode = qrcodegen.QrCode.encodeSegments(segs, ecl, minVer, maxVer, mask, boostEcc);
+		
+		// Draw image output
+		const border: number = parseInt(getInput("border-input").value, 10);
+		const lightColor: string = getInput("light-color-input").value;
+		const darkColor : string = getInput("dark-color-input" ).value;
+		if (border < 0 || border > 100)
+			return;
+		if (bitmapOutput) {
+			const scale: number = parseInt(getInput("scale-input").value, 10);
+			if (scale <= 0 || scale > 30)
+				return;
+			drawCanvas(qr, scale, border, lightColor, darkColor, canvas);
+			canvas.style.removeProperty("display");
+		} else {
+			const code: string = toSvgString(qr, border, lightColor, darkColor);
+			const viewBox: string = (/ viewBox="([^"]*)"/.exec(code) as RegExpExecArray)[1];
+			const pathD: string = (/ d="([^"]*)"/.exec(code) as RegExpExecArray)[1];
+			svg.setAttribute("viewBox", viewBox);
+			(svg.querySelector("path") as Element).setAttribute("d", pathD);
+			(svg.querySelector("rect") as Element).setAttribute("fill", lightColor);
+			(svg.querySelector("path") as Element).setAttribute("fill", darkColor);
+			svg.style.removeProperty("display");
+			svgXml.value = code;
+		}
+		
+		// Returns a string to describe the given list of segments.
+		function describeSegments(segs: Array<qrcodegen.QrSegment>): string {
+			if (segs.length == 0)
+				return "none";
+			else if (segs.length == 1) {
+				const mode: qrcodegen.QrSegment.Mode = segs[0].mode;
+				const Mode = qrcodegen.QrSegment.Mode;
+				if (mode == Mode.NUMERIC     )  return "numeric";
+				if (mode == Mode.ALPHANUMERIC)  return "alphanumeric";
+				if (mode == Mode.BYTE        )  return "byte";
+				if (mode == Mode.KANJI       )  return "kanji";
+				return "unknown";
+			} else
+				return "multiple";
+		}
+		
+		// Returns the number of Unicode code points in the given UTF-16 string.
+		function countUnicodeChars(str: string): number {
+			let result: number = 0;
+			for (let i = 0; i < str.length; i++, result++) {
+				const c: number = str.charCodeAt(i);
+				if (c < 0xD800 || c >= 0xE000)
+					continue;
+				else if (0xD800 <= c && c < 0xDC00 && i + 1 < str.length) {  // High surrogate
+					i++;
+					const d: number = str.charCodeAt(i);
+					if (0xDC00 <= d && d < 0xE000)  // Low surrogate
+						continue;
+				}
+				throw new RangeError("Invalid UTF-16 string");
+			}
+			return result;
+		}
+		
+		// Show the QR Code symbol's statistics as a string
+		getElem("statistics-output").textContent = `QR Code version = ${qr.version}, ` +
+			`mask pattern = ${qr.mask}, ` +
+			`character count = ${countUnicodeChars(text)},\n` +
+			`encoding mode = ${describeSegments(segs)}, ` +
+			`error correction = level ${"LMQH".charAt(qr.errorCorrectionLevel.ordinal)}, ` +
+			`data bits = ${qrcodegen.QrSegment.getTotalBits(segs, qr.version) as number}.`;
+	}
+	
+	
+	// Draws the given QR Code, with the given module scale and border modules, onto the given HTML
+	// canvas element. The canvas's width and height is resized to (qr.size + border * 2) * scale.
+	// The drawn image is purely dark and light, and fully opaque.
+	// The scale must be a positive integer and the border must be a non-negative integer.
+	function drawCanvas(qr: qrcodegen.QrCode, scale: number, border: number, lightColor: string, darkColor: string, canvas: HTMLCanvasElement): void {
+		if (scale <= 0 || border < 0)
+			throw new RangeError("Value out of range");
+		const width: number = (qr.size + border * 2) * scale;
+		canvas.width = width;
+		canvas.height = width;
+		let ctx = canvas.getContext("2d") as CanvasRenderingContext2D;
+		for (let y = -border; y < qr.size + border; y++) {
+			for (let x = -border; x < qr.size + border; x++) {
+				ctx.fillStyle = qr.getModule(x, y) ? darkColor : lightColor;
+				ctx.fillRect((x + border) * scale, (y + border) * scale, scale, scale);
+			}
+		}
+	}
+	
+	
+	// Returns a string of SVG code for an image depicting the given QR Code, with the given number
+	// of border modules. The string always uses Unix newlines (\n), regardless of the platform.
+	function toSvgString(qr: qrcodegen.QrCode, border: number, lightColor: string, darkColor: string): string {
+		if (border < 0)
+			throw new RangeError("Border must be non-negative");
+		let parts: Array<string> = [];
+		for (let y = 0; y < qr.size; y++) {
+			for (let x = 0; x < qr.size; x++) {
+				if (qr.getModule(x, y))
+					parts.push(`M${x + border},${y + border}h1v1h-1z`);
+			}
+		}
+		return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 ${qr.size + border * 2} ${qr.size + border * 2}" stroke="none">
+	<rect width="100%" height="100%" fill="${lightColor}"/>
+	<path d="${parts.join(" ")}" fill="${darkColor}"/>
+</svg>
+`
+		}
+	
+	
+	export function handleVersionMinMax(which: "min"|"max"): void {
+		const minElem: HTMLInputElement = getInput("version-min-input");
+		const maxElem: HTMLInputElement = getInput("version-max-input");
+		let minVal: number = parseInt(minElem.value, 10);
+		let maxVal: number = parseInt(maxElem.value, 10);
+		minVal = Math.max(Math.min(minVal, qrcodegen.QrCode.MAX_VERSION), qrcodegen.QrCode.MIN_VERSION);
+		maxVal = Math.max(Math.min(maxVal, qrcodegen.QrCode.MAX_VERSION), qrcodegen.QrCode.MIN_VERSION);
+		if (which == "min" && minVal > maxVal)
+			maxVal = minVal;
+		else if (which == "max" && maxVal < minVal)
+			minVal = maxVal;
+		minElem.value = minVal.toString();
+		maxElem.value = maxVal.toString();
+		redrawQrCode();
+	}
+	
+	
+	function getElem(id: string): HTMLElement {
+		const result: HTMLElement|null = document.getElementById(id);
+		if (result instanceof HTMLElement)
+			return result;
+		throw new Error("Assertion error");
+	}
+	
+	
+	function getInput(id: string): HTMLInputElement {
+		const result: HTMLElement = getElem(id);
+		if (result instanceof HTMLInputElement)
+			return result;
+		throw new Error("Assertion error");
+	}
+	
+	
+	initialize();
+}

Telegram/ThirdParty/QR/typescript-javascript/qrcodegen-output-demo.html

@@ -0,0 +1,65 @@
+<!--
+  - QR Code generator output demo (HTML+JavaScript)
+  - 
+  - Copyright (c) Project Nayuki. (MIT License)
+  - https://www.nayuki.io/page/qr-code-generator-library
+  - 
+  - 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.
+  -->
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="UTF-8">
+		<title>QR Code generator output demo (JavaScript)</title>
+		<style type="text/css">
+			html {
+				font-family: sans-serif;
+			}
+			h1 {
+				text-align: center;
+			}
+			#output p {
+				margin-top: 0.5em;
+				margin-bottom: 0.5em;
+			}
+			#output canvas {
+				display: block;
+				margin-bottom: 1.5em;
+				border: 0.2em solid #D0D0D0;
+				border-radius: 0.4em;
+			}
+			hr {
+				margin: 2em 0em;
+				border: none;
+				border-top: 0.1em solid #A0A0A0;
+			}
+		</style>
+	</head>
+	
+	<body>
+		<h1>QR Code generator output demo (JavaScript)</h1>
+		<div id="output">
+			<p>Loading application...</p>
+			<p>(Are the JavaScript files missing?)</p>
+			<p>(The JavaScript code needs to be compiled from the TypeScript code.)</p>
+		</div>
+		<script type="application/javascript" src="qrcodegen.js"></script>
+		<script type="application/javascript" src="qrcodegen-output-demo.js"></script>
+		<hr>
+		<p>Copyright © Project Nayuki – <a href="https://www.nayuki.io/page/qr-code-generator-library">https://www.nayuki.io/page/qr-code-generator-library</a></p>
+	</body>
+</html>

Telegram/ThirdParty/QR/typescript-javascript/qrcodegen-output-demo.ts

@@ -0,0 +1,240 @@
+/* 
+ * QR Code generator output demo (TypeScript)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+"use strict";
+
+
+namespace app {
+	
+	let outputElem = document.getElementById("output") as HTMLElement;
+	
+	
+	// The main application program.
+	function main(): void {
+		while (outputElem.firstChild !== null)
+			outputElem.removeChild(outputElem.firstChild);
+		doBasicDemo();
+		doVarietyDemo();
+		doSegmentDemo();
+		doMaskDemo();
+	}
+	
+	
+	// Creates a single QR Code, then appends it to the document.
+	function doBasicDemo(): void {
+		appendHeading("Basic");
+		const text: string = "Hello, world!";  // User-supplied Unicode text
+		const errCorLvl: qrcodegen.QrCode.Ecc = qrcodegen.QrCode.Ecc.LOW;  // Error correction level
+		const qr: qrcodegen.QrCode = qrcodegen.QrCode.encodeText(text, errCorLvl);  // Make the QR Code symbol
+		drawCanvas(qr, 10, 4, "#FFFFFF", "#000000", appendCanvas("hello-world-QR"));  // Draw it on screen
+	}
+	
+	
+	// Creates a variety of QR Codes that exercise different features of the library, and appends each one to the document.
+	function doVarietyDemo(): void {
+		appendHeading("Variety");
+		let qr: qrcodegen.QrCode;
+		const QrCode = qrcodegen.QrCode;  // Abbreviation
+		
+		// Numeric mode encoding (3.33 bits per digit)
+		qr = QrCode.encodeText("314159265358979323846264338327950288419716939937510", QrCode.Ecc.MEDIUM);
+		drawCanvas(qr, 13, 1, "#FFFFFF", "#000000", appendCanvas("pi-digits-QR"));
+		
+		// Alphanumeric mode encoding (5.5 bits per character)
+		qr = QrCode.encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCode.Ecc.HIGH);
+		drawCanvas(qr, 10, 2, "#FFFFFF", "#000000", appendCanvas("alphanumeric-QR"));
+		
+		// Unicode text as UTF-8
+		qr = QrCode.encodeText("\u3053\u3093\u306B\u3061wa\u3001\u4E16\u754C\uFF01 \u03B1\u03B2\u03B3\u03B4", QrCode.Ecc.QUARTILE);
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("unicode-QR"));
+		
+		// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
+		qr = QrCode.encodeText(
+			"Alice was beginning to get very tired of sitting by her sister on the bank, "
+			+ "and of having nothing to do: once or twice she had peeped into the book her sister was reading, "
+			+ "but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice "
+			+ "'without pictures or conversations?' So she was considering in her own mind (as well as she could, "
+			+ "for the hot day made her feel very sleepy and stupid), whether the pleasure of making a "
+			+ "daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly "
+			+ "a White Rabbit with pink eyes ran close by her.", QrCode.Ecc.HIGH);
+		drawCanvas(qr, 6, 10, "#FFFFFF", "#000000", appendCanvas("alice-wonderland-QR"));
+	}
+	
+	
+	// Creates QR Codes with manually specified segments for better compactness.
+	function doSegmentDemo(): void {
+		appendHeading("Segment");
+		let qr: qrcodegen.QrCode;
+		let segs: Array<qrcodegen.QrSegment>;
+		const QrCode = qrcodegen.QrCode;  // Abbreviation
+		const QrSegment = qrcodegen.QrSegment;  // Abbreviation
+		
+		// Illustration "silver"
+		const silver0: string = "THE SQUARE ROOT OF 2 IS 1.";
+		const silver1: string = "41421356237309504880168872420969807856967187537694807317667973799";
+		qr = QrCode.encodeText(silver0 + silver1, QrCode.Ecc.LOW);
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("sqrt2-monolithic-QR"));
+		
+		segs = [
+			QrSegment.makeAlphanumeric(silver0),
+			QrSegment.makeNumeric(silver1)];
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("sqrt2-segmented-QR"));
+		
+		// Illustration "golden"
+		const golden0: string = "Golden ratio \u03C6 = 1.";
+		const golden1: string = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
+		const golden2: string = "......";
+		qr = QrCode.encodeText(golden0 + golden1 + golden2, QrCode.Ecc.LOW);
+		drawCanvas(qr, 8, 5, "#FFFFFF", "#000000", appendCanvas("phi-monolithic-QR"));
+		
+		segs = [
+			QrSegment.makeBytes(toUtf8ByteArray(golden0)),
+			QrSegment.makeNumeric(golden1),
+			QrSegment.makeAlphanumeric(golden2)];
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		drawCanvas(qr, 8, 5, "#FFFFFF", "#000000", appendCanvas("phi-segmented-QR"));
+		
+		// Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
+		const madoka: string = "\u300C\u9B54\u6CD5\u5C11\u5973\u307E\u3069\u304B\u2606\u30DE\u30AE\u30AB\u300D\u3063\u3066\u3001\u3000\u0418\u0410\u0418\u3000\uFF44\uFF45\uFF53\uFF55\u3000\u03BA\u03B1\uFF1F";
+		qr = QrCode.encodeText(madoka, QrCode.Ecc.LOW);
+		drawCanvas(qr, 9, 4, "#FFFFE0", "#303080", appendCanvas("madoka-utf8-QR"));
+		
+		const kanjiCharBits: Array<number> = [  // Kanji mode encoding (13 bits per character)
+			0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1,
+			1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+			0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
+			0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1,
+			0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,
+			0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0,
+			0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,
+			0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1,
+			0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1,
+			0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1,
+			0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1,
+			0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0,
+			0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0,
+			0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1,
+			0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+			0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
+			0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,
+			0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1,
+			0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+			0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
+		];
+		segs = [new QrSegment(QrSegment.Mode.KANJI, kanjiCharBits.length / 13, kanjiCharBits)];
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
+		drawCanvas(qr, 9, 4, "#E0F0FF", "#404040", appendCanvas("madoka-kanji-QR"));
+	}
+	
+	
+	// Creates QR Codes with the same size and contents but different mask patterns.
+	function doMaskDemo(): void {
+		appendHeading("Mask");
+		let qr: qrcodegen.QrCode;
+		let segs: Array<qrcodegen.QrSegment>;
+		const QrCode = qrcodegen.QrCode;  // Abbreviation
+		
+		// Project Nayuki URL
+		segs = qrcodegen.QrSegment.makeSegments("https://www.nayuki.io/");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -1, true);  // Automatic mask
+		drawCanvas(qr, 8, 6, "#E0FFE0", "#206020", appendCanvas("project-nayuki-automask-QR"));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 3, true);  // Force mask 3
+		drawCanvas(qr, 8, 6, "#FFE0E0", "#602020", appendCanvas("project-nayuki-mask3-QR"));
+		
+		// Chinese text as UTF-8
+		segs = qrcodegen.QrSegment.makeSegments("\u7DAD\u57FA\u767E\u79D1\uFF08Wikipedia\uFF0C\u8046\u807Di/\u02CCw\u026Ak\u1D7B\u02C8pi\u02D0di.\u0259/\uFF09\u662F\u4E00"
+			+ "\u500B\u81EA\u7531\u5167\u5BB9\u3001\u516C\u958B\u7DE8\u8F2F\u4E14\u591A\u8A9E\u8A00\u7684\u7DB2\u8DEF\u767E\u79D1\u5168\u66F8\u5354\u4F5C\u8A08\u756B");
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 0, true);  // Force mask 0
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("unicode-mask0-QR"));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 1, true);  // Force mask 1
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("unicode-mask1-QR"));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 5, true);  // Force mask 5
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("unicode-mask5-QR"));
+		qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 7, true);  // Force mask 7
+		drawCanvas(qr, 10, 3, "#FFFFFF", "#000000", appendCanvas("unicode-mask7-QR"));
+	}
+	
+	
+	function appendHeading(text: string): void {
+		let h2 = outputElem.appendChild(document.createElement("h2"));
+		h2.textContent = text;
+	}
+	
+	
+	function appendCanvas(caption: string): HTMLCanvasElement {
+		let p = outputElem.appendChild(document.createElement("p"));
+		p.textContent = caption + ":";
+		let result = document.createElement("canvas");
+		outputElem.appendChild(result);
+		return result;
+	}
+	
+	
+	// Draws the given QR Code, with the given module scale and border modules, onto the given HTML
+	// canvas element. The canvas's width and height is resized to (qr.size + border * 2) * scale.
+	// The drawn image is purely dark and light, and fully opaque.
+	// The scale must be a positive integer and the border must be a non-negative integer.
+	function drawCanvas(qr: qrcodegen.QrCode, scale: number, border: number, lightColor: string, darkColor: string, canvas: HTMLCanvasElement): void {
+		if (scale <= 0 || border < 0)
+			throw new RangeError("Value out of range");
+		const width: number = (qr.size + border * 2) * scale;
+		canvas.width = width;
+		canvas.height = width;
+		let ctx = canvas.getContext("2d") as CanvasRenderingContext2D;
+		for (let y = -border; y < qr.size + border; y++) {
+			for (let x = -border; x < qr.size + border; x++) {
+				ctx.fillStyle = qr.getModule(x, y) ? darkColor : lightColor;
+				ctx.fillRect((x + border) * scale, (y + border) * scale, scale, scale);
+			}
+		}
+	}
+	
+	
+	function toUtf8ByteArray(str: string): Array<number> {
+		str = encodeURI(str);
+		let result: Array<number> = [];
+		for (let i = 0; i < str.length; i++) {
+			if (str.charAt(i) != "%")
+				result.push(str.charCodeAt(i));
+			else {
+				result.push(parseInt(str.substr(i + 1, 2), 16));
+				i += 2;
+			}
+		}
+		return result;
+	}
+	
+	
+	main();
+	
+}

Telegram/ThirdParty/QR/typescript-javascript/qrcodegen.ts

@@ -0,0 +1,991 @@
+/* 
+ * QR Code generator library (TypeScript)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * 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.
+ */
+
+"use strict";
+
+
+namespace qrcodegen {
+	
+	type bit  = number;
+	type byte = number;
+	type int  = number;
+	
+	
+	/*---- QR Code symbol class ----*/
+	
+	/* 
+	 * A QR Code symbol, which is a type of two-dimension barcode.
+	 * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+	 * Instances of this class represent an immutable square grid of dark and light cells.
+	 * The class provides static factory functions to create a QR Code from text or binary data.
+	 * The class covers the QR Code Model 2 specification, supporting all versions (sizes)
+	 * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+	 * 
+	 * Ways to create a QR Code object:
+	 * - High level: Take the payload data and call QrCode.encodeText() or QrCode.encodeBinary().
+	 * - Mid level: Custom-make the list of segments and call QrCode.encodeSegments().
+	 * - Low level: Custom-make the array of data codeword bytes (including
+	 *   segment headers and final padding, excluding error correction codewords),
+	 *   supply the appropriate version number, and call the QrCode() constructor.
+	 * (Note that all ways require supplying the desired error correction level.)
+	 */
+	export class QrCode {
+		
+		/*-- Static factory functions (high level) --*/
+		
+		// Returns a QR Code representing the given Unicode text string at the given error correction level.
+		// As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
+		// Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
+		// QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
+		// ecl argument if it can be done without increasing the version.
+		public static encodeText(text: string, ecl: QrCode.Ecc): QrCode {
+			const segs: Array<QrSegment> = qrcodegen.QrSegment.makeSegments(text);
+			return QrCode.encodeSegments(segs, ecl);
+		}
+		
+		
+		// Returns a QR Code representing the given binary data at the given error correction level.
+		// This function always encodes using the binary segment mode, not any text mode. The maximum number of
+		// bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+		// The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
+		public static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCode.Ecc): QrCode {
+			const seg: QrSegment = qrcodegen.QrSegment.makeBytes(data);
+			return QrCode.encodeSegments([seg], ecl);
+		}
+		
+		
+		/*-- Static factory functions (mid level) --*/
+		
+		// Returns a QR Code representing the given segments with the given encoding parameters.
+		// The smallest possible QR Code version within the given range is automatically
+		// chosen for the output. Iff boostEcl is true, then the ECC level of the result
+		// may be higher than the ecl argument if it can be done without increasing the
+		// version. The mask number is either between 0 to 7 (inclusive) to force that
+		// mask, or -1 to automatically choose an appropriate mask (which may be slow).
+		// This function allows the user to create a custom sequence of segments that switches
+		// between modes (such as alphanumeric and byte) to encode text in less space.
+		// This is a mid-level API; the high-level API is encodeText() and encodeBinary().
+		public static encodeSegments(segs: Readonly<Array<QrSegment>>, ecl: QrCode.Ecc,
+				minVersion: int = 1, maxVersion: int = 40,
+				mask: int = -1, boostEcl: boolean = true): QrCode {
+			
+			if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION)
+					|| mask < -1 || mask > 7)
+				throw new RangeError("Invalid value");
+			
+			// Find the minimal version number to use
+			let version: int;
+			let dataUsedBits: int;
+			for (version = minVersion; ; version++) {
+				const dataCapacityBits: int = QrCode.getNumDataCodewords(version, ecl) * 8;  // Number of data bits available
+				const usedBits: number = QrSegment.getTotalBits(segs, version);
+				if (usedBits <= dataCapacityBits) {
+					dataUsedBits = usedBits;
+					break;  // This version number is found to be suitable
+				}
+				if (version >= maxVersion)  // All versions in the range could not fit the given data
+					throw new RangeError("Data too long");
+			}
+			
+			// Increase the error correction level while the data still fits in the current version number
+			for (const newEcl of [QrCode.Ecc.MEDIUM, QrCode.Ecc.QUARTILE, QrCode.Ecc.HIGH]) {  // From low to high
+				if (boostEcl && dataUsedBits <= QrCode.getNumDataCodewords(version, newEcl) * 8)
+					ecl = newEcl;
+			}
+			
+			// Concatenate all segments to create the data bit string
+			let bb: Array<bit> = []
+			for (const seg of segs) {
+				appendBits(seg.mode.modeBits, 4, bb);
+				appendBits(seg.numChars, seg.mode.numCharCountBits(version), bb);
+				for (const b of seg.getData())
+					bb.push(b);
+			}
+			assert(bb.length == dataUsedBits);
+			
+			// Add terminator and pad up to a byte if applicable
+			const dataCapacityBits: int = QrCode.getNumDataCodewords(version, ecl) * 8;
+			assert(bb.length <= dataCapacityBits);
+			appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
+			appendBits(0, (8 - bb.length % 8) % 8, bb);
+			assert(bb.length % 8 == 0);
+			
+			// Pad with alternating bytes until data capacity is reached
+			for (let padByte = 0xEC; bb.length < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
+				appendBits(padByte, 8, bb);
+			
+			// Pack bits into bytes in big endian
+			let dataCodewords: Array<byte> = [];
+			while (dataCodewords.length * 8 < bb.length)
+				dataCodewords.push(0);
+			bb.forEach((b: bit, i: int) =>
+				dataCodewords[i >>> 3] |= b << (7 - (i & 7)));
+			
+			// Create the QR Code object
+			return new QrCode(version, ecl, dataCodewords, mask);
+		}
+		
+		
+		/*-- Fields --*/
+		
+		// The width and height of this QR Code, measured in modules, between
+		// 21 and 177 (inclusive). This is equal to version * 4 + 17.
+		public readonly size: int;
+		
+		// The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+		// Even if a QR Code is created with automatic masking requested (mask = -1),
+		// the resulting object still has a mask value between 0 and 7.
+		public readonly mask: int;
+		
+		// The modules of this QR Code (false = light, true = dark).
+		// Immutable after constructor finishes. Accessed through getModule().
+		private readonly modules   : Array<Array<boolean>> = [];
+		
+		// Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+		private readonly isFunction: Array<Array<boolean>> = [];
+		
+		
+		/*-- Constructor (low level) and fields --*/
+		
+		// Creates a new QR Code with the given version number,
+		// error correction level, data codeword bytes, and mask number.
+		// This is a low-level API that most users should not use directly.
+		// A mid-level API is the encodeSegments() function.
+		public constructor(
+				// The version number of this QR Code, which is between 1 and 40 (inclusive).
+				// This determines the size of this barcode.
+				public readonly version: int,
+				
+				// The error correction level used in this QR Code.
+				public readonly errorCorrectionLevel: QrCode.Ecc,
+				
+				dataCodewords: Readonly<Array<byte>>,
+				
+				msk: int) {
+			
+			// Check scalar arguments
+			if (version < QrCode.MIN_VERSION || version > QrCode.MAX_VERSION)
+				throw new RangeError("Version value out of range");
+			if (msk < -1 || msk > 7)
+				throw new RangeError("Mask value out of range");
+			this.size = version * 4 + 17;
+			
+			// Initialize both grids to be size*size arrays of Boolean false
+			let row: Array<boolean> = [];
+			for (let i = 0; i < this.size; i++)
+				row.push(false);
+			for (let i = 0; i < this.size; i++) {
+				this.modules   .push(row.slice());  // Initially all light
+				this.isFunction.push(row.slice());
+			}
+			
+			// Compute ECC, draw modules
+			this.drawFunctionPatterns();
+			const allCodewords: Array<byte> = this.addEccAndInterleave(dataCodewords);
+			this.drawCodewords(allCodewords);
+			
+			// Do masking
+			if (msk == -1) {  // Automatically choose best mask
+				let minPenalty: int = 1000000000;
+				for (let i = 0; i < 8; i++) {
+					this.applyMask(i);
+					this.drawFormatBits(i);
+					const penalty: int = this.getPenaltyScore();
+					if (penalty < minPenalty) {
+						msk = i;
+						minPenalty = penalty;
+					}
+					this.applyMask(i);  // Undoes the mask due to XOR
+				}
+			}
+			assert(0 <= msk && msk <= 7);
+			this.mask = msk;
+			this.applyMask(msk);  // Apply the final choice of mask
+			this.drawFormatBits(msk);  // Overwrite old format bits
+			
+			this.isFunction = [];
+		}
+		
+		
+		/*-- Accessor methods --*/
+		
+		// Returns the color of the module (pixel) at the given coordinates, which is false
+		// for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+		// If the given coordinates are out of bounds, then false (light) is returned.
+		public getModule(x: int, y: int): boolean {
+			return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];
+		}
+		
+		
+		/*-- Private helper methods for constructor: Drawing function modules --*/
+		
+		// Reads this object's version field, and draws and marks all function modules.
+		private drawFunctionPatterns(): void {
+			// Draw horizontal and vertical timing patterns
+			for (let i = 0; i < this.size; i++) {
+				this.setFunctionModule(6, i, i % 2 == 0);
+				this.setFunctionModule(i, 6, i % 2 == 0);
+			}
+			
+			// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
+			this.drawFinderPattern(3, 3);
+			this.drawFinderPattern(this.size - 4, 3);
+			this.drawFinderPattern(3, this.size - 4);
+			
+			// Draw numerous alignment patterns
+			const alignPatPos: Array<int> = this.getAlignmentPatternPositions();
+			const numAlign: int = alignPatPos.length;
+			for (let i = 0; i < numAlign; i++) {
+				for (let j = 0; j < numAlign; j++) {
+					// Don't draw on the three finder corners
+					if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0))
+						this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+				}
+			}
+			
+			// Draw configuration data
+			this.drawFormatBits(0);  // Dummy mask value; overwritten later in the constructor
+			this.drawVersion();
+		}
+		
+		
+		// Draws two copies of the format bits (with its own error correction code)
+		// based on the given mask and this object's error correction level field.
+		private drawFormatBits(mask: int): void {
+			// Calculate error correction code and pack bits
+			const data: int = this.errorCorrectionLevel.formatBits << 3 | mask;  // errCorrLvl is uint2, mask is uint3
+			let rem: int = data;
+			for (let i = 0; i < 10; i++)
+				rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+			const bits = (data << 10 | rem) ^ 0x5412;  // uint15
+			assert(bits >>> 15 == 0);
+			
+			// Draw first copy
+			for (let i = 0; i <= 5; i++)
+				this.setFunctionModule(8, i, getBit(bits, i));
+			this.setFunctionModule(8, 7, getBit(bits, 6));
+			this.setFunctionModule(8, 8, getBit(bits, 7));
+			this.setFunctionModule(7, 8, getBit(bits, 8));
+			for (let i = 9; i < 15; i++)
+				this.setFunctionModule(14 - i, 8, getBit(bits, i));
+			
+			// Draw second copy
+			for (let i = 0; i < 8; i++)
+				this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
+			for (let i = 8; i < 15; i++)
+				this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
+			this.setFunctionModule(8, this.size - 8, true);  // Always dark
+		}
+		
+		
+		// Draws two copies of the version bits (with its own error correction code),
+		// based on this object's version field, iff 7 <= version <= 40.
+		private drawVersion(): void {
+			if (this.version < 7)
+				return;
+			
+			// Calculate error correction code and pack bits
+			let rem: int = this.version;  // version is uint6, in the range [7, 40]
+			for (let i = 0; i < 12; i++)
+				rem = (rem << 1) ^ ((rem >>> 11) * 0x1F25);
+			const bits: int = this.version << 12 | rem;  // uint18
+			assert(bits >>> 18 == 0);
+			
+			// Draw two copies
+			for (let i = 0; i < 18; i++) {
+				const color: boolean = getBit(bits, i);
+				const a: int = this.size - 11 + i % 3;
+				const b: int = Math.floor(i / 3);
+				this.setFunctionModule(a, b, color);
+				this.setFunctionModule(b, a, color);
+			}
+		}
+		
+		
+		// Draws a 9*9 finder pattern including the border separator,
+		// with the center module at (x, y). Modules can be out of bounds.
+		private drawFinderPattern(x: int, y: int): void {
+			for (let dy = -4; dy <= 4; dy++) {
+				for (let dx = -4; dx <= 4; dx++) {
+					const dist: int = Math.max(Math.abs(dx), Math.abs(dy));  // Chebyshev/infinity norm
+					const xx: int = x + dx;
+					const yy: int = y + dy;
+					if (0 <= xx && xx < this.size && 0 <= yy && yy < this.size)
+						this.setFunctionModule(xx, yy, dist != 2 && dist != 4);
+				}
+			}
+		}
+		
+		
+		// Draws a 5*5 alignment pattern, with the center module
+		// at (x, y). All modules must be in bounds.
+		private drawAlignmentPattern(x: int, y: int): void {
+			for (let dy = -2; dy <= 2; dy++) {
+				for (let dx = -2; dx <= 2; dx++)
+					this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) != 1);
+			}
+		}
+		
+		
+		// Sets the color of a module and marks it as a function module.
+		// Only used by the constructor. Coordinates must be in bounds.
+		private setFunctionModule(x: int, y: int, isDark: boolean): void {
+			this.modules[y][x] = isDark;
+			this.isFunction[y][x] = true;
+		}
+		
+		
+		/*-- Private helper methods for constructor: Codewords and masking --*/
+		
+		// Returns a new byte string representing the given data with the appropriate error correction
+		// codewords appended to it, based on this object's version and error correction level.
+		private addEccAndInterleave(data: Readonly<Array<byte>>): Array<byte> {
+			const ver: int = this.version;
+			const ecl: QrCode.Ecc = this.errorCorrectionLevel;
+			if (data.length != QrCode.getNumDataCodewords(ver, ecl))
+				throw new RangeError("Invalid argument");
+			
+			// Calculate parameter numbers
+			const numBlocks: int = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+			const blockEccLen: int = QrCode.ECC_CODEWORDS_PER_BLOCK  [ecl.ordinal][ver];
+			const rawCodewords: int = Math.floor(QrCode.getNumRawDataModules(ver) / 8);
+			const numShortBlocks: int = numBlocks - rawCodewords % numBlocks;
+			const shortBlockLen: int = Math.floor(rawCodewords / numBlocks);
+			
+			// Split data into blocks and append ECC to each block
+			let blocks: Array<Array<byte>> = [];
+			const rsDiv: Array<byte> = QrCode.reedSolomonComputeDivisor(blockEccLen);
+			for (let i = 0, k = 0; i < numBlocks; i++) {
+				let dat: Array<byte> = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+				k += dat.length;
+				const ecc: Array<byte> = QrCode.reedSolomonComputeRemainder(dat, rsDiv);
+				if (i < numShortBlocks)
+					dat.push(0);
+				blocks.push(dat.concat(ecc));
+			}
+			
+			// Interleave (not concatenate) the bytes from every block into a single sequence
+			let result: Array<byte> = [];
+			for (let i = 0; i < blocks[0].length; i++) {
+				blocks.forEach((block, j) => {
+					// Skip the padding byte in short blocks
+					if (i != shortBlockLen - blockEccLen || j >= numShortBlocks)
+						result.push(block[i]);
+				});
+			}
+			assert(result.length == rawCodewords);
+			return result;
+		}
+		
+		
+		// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+		// data area of this QR Code. Function modules need to be marked off before this is called.
+		private drawCodewords(data: Readonly<Array<byte>>): void {
+			if (data.length != Math.floor(QrCode.getNumRawDataModules(this.version) / 8))
+				throw new RangeError("Invalid argument");
+			let i: int = 0;  // Bit index into the data
+			// Do the funny zigzag scan
+			for (let right = this.size - 1; right >= 1; right -= 2) {  // Index of right column in each column pair
+				if (right == 6)
+					right = 5;
+				for (let vert = 0; vert < this.size; vert++) {  // Vertical counter
+					for (let j = 0; j < 2; j++) {
+						const x: int = right - j;  // Actual x coordinate
+						const upward: boolean = ((right + 1) & 2) == 0;
+						const y: int = upward ? this.size - 1 - vert : vert;  // Actual y coordinate
+						if (!this.isFunction[y][x] && i < data.length * 8) {
+							this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
+							i++;
+						}
+						// If this QR Code has any remainder bits (0 to 7), they were assigned as
+						// 0/false/light by the constructor and are left unchanged by this method
+					}
+				}
+			}
+			assert(i == data.length * 8);
+		}
+		
+		
+		// XORs the codeword modules in this QR Code with the given mask pattern.
+		// The function modules must be marked and the codeword bits must be drawn
+		// before masking. Due to the arithmetic of XOR, calling applyMask() with
+		// the same mask value a second time will undo the mask. A final well-formed
+		// QR Code needs exactly one (not zero, two, etc.) mask applied.
+		private applyMask(mask: int): void {
+			if (mask < 0 || mask > 7)
+				throw new RangeError("Mask value out of range");
+			for (let y = 0; y < this.size; y++) {
+				for (let x = 0; x < this.size; x++) {
+					let invert: boolean;
+					switch (mask) {
+						case 0:  invert = (x + y) % 2 == 0;                                  break;
+						case 1:  invert = y % 2 == 0;                                        break;
+						case 2:  invert = x % 3 == 0;                                        break;
+						case 3:  invert = (x + y) % 3 == 0;                                  break;
+						case 4:  invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 == 0;  break;
+						case 5:  invert = x * y % 2 + x * y % 3 == 0;                        break;
+						case 6:  invert = (x * y % 2 + x * y % 3) % 2 == 0;                  break;
+						case 7:  invert = ((x + y) % 2 + x * y % 3) % 2 == 0;                break;
+						default:  throw new Error("Unreachable");
+					}
+					if (!this.isFunction[y][x] && invert)
+						this.modules[y][x] = !this.modules[y][x];
+				}
+			}
+		}
+		
+		
+		// Calculates and returns the penalty score based on state of this QR Code's current modules.
+		// This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+		private getPenaltyScore(): int {
+			let result: int = 0;
+			
+			// Adjacent modules in row having same color, and finder-like patterns
+			for (let y = 0; y < this.size; y++) {
+				let runColor = false;
+				let runX = 0;
+				let runHistory = [0,0,0,0,0,0,0];
+				for (let x = 0; x < this.size; x++) {
+					if (this.modules[y][x] == runColor) {
+						runX++;
+						if (runX == 5)
+							result += QrCode.PENALTY_N1;
+						else if (runX > 5)
+							result++;
+					} else {
+						this.finderPenaltyAddHistory(runX, runHistory);
+						if (!runColor)
+							result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
+						runColor = this.modules[y][x];
+						runX = 1;
+					}
+				}
+				result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * QrCode.PENALTY_N3;
+			}
+			// Adjacent modules in column having same color, and finder-like patterns
+			for (let x = 0; x < this.size; x++) {
+				let runColor = false;
+				let runY = 0;
+				let runHistory = [0,0,0,0,0,0,0];
+				for (let y = 0; y < this.size; y++) {
+					if (this.modules[y][x] == runColor) {
+						runY++;
+						if (runY == 5)
+							result += QrCode.PENALTY_N1;
+						else if (runY > 5)
+							result++;
+					} else {
+						this.finderPenaltyAddHistory(runY, runHistory);
+						if (!runColor)
+							result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
+						runColor = this.modules[y][x];
+						runY = 1;
+					}
+				}
+				result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * QrCode.PENALTY_N3;
+			}
+			
+			// 2*2 blocks of modules having same color
+			for (let y = 0; y < this.size - 1; y++) {
+				for (let x = 0; x < this.size - 1; x++) {
+					const color: boolean = this.modules[y][x];
+					if (  color == this.modules[y][x + 1] &&
+					      color == this.modules[y + 1][x] &&
+					      color == this.modules[y + 1][x + 1])
+						result += QrCode.PENALTY_N2;
+				}
+			}
+			
+			// Balance of dark and light modules
+			let dark: int = 0;
+			for (const row of this.modules)
+				dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);
+			const total: int = this.size * this.size;  // Note that size is odd, so dark/total != 1/2
+			// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+			const k: int = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+			assert(0 <= k && k <= 9);
+			result += k * QrCode.PENALTY_N4;
+			assert(0 <= result && result <= 2568888);  // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
+			return result;
+		}
+		
+		
+		/*-- Private helper functions --*/
+		
+		// Returns an ascending list of positions of alignment patterns for this version number.
+		// Each position is in the range [0,177), and are used on both the x and y axes.
+		// This could be implemented as lookup table of 40 variable-length lists of integers.
+		private getAlignmentPatternPositions(): Array<int> {
+			if (this.version == 1)
+				return [];
+			else {
+				const numAlign: int = Math.floor(this.version / 7) + 2;
+				const step: int = (this.version == 32) ? 26 :
+					Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
+				let result: Array<int> = [6];
+				for (let pos = this.size - 7; result.length < numAlign; pos -= step)
+					result.splice(1, 0, pos);
+				return result;
+			}
+		}
+		
+		
+		// Returns the number of data bits that can be stored in a QR Code of the given version number, after
+		// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+		// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
+		private static getNumRawDataModules(ver: int): int {
+			if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
+				throw new RangeError("Version number out of range");
+			let result: int = (16 * ver + 128) * ver + 64;
+			if (ver >= 2) {
+				const numAlign: int = Math.floor(ver / 7) + 2;
+				result -= (25 * numAlign - 10) * numAlign - 55;
+				if (ver >= 7)
+					result -= 36;
+			}
+			assert(208 <= result && result <= 29648);
+			return result;
+		}
+		
+		
+		// Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+		// QR Code of the given version number and error correction level, with remainder bits discarded.
+		// This stateless pure function could be implemented as a (40*4)-cell lookup table.
+		private static getNumDataCodewords(ver: int, ecl: QrCode.Ecc): int {
+			return Math.floor(QrCode.getNumRawDataModules(ver) / 8) -
+				QrCode.ECC_CODEWORDS_PER_BLOCK    [ecl.ordinal][ver] *
+				QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+		}
+		
+		
+		// Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
+		// implemented as a lookup table over all possible parameter values, instead of as an algorithm.
+		private static reedSolomonComputeDivisor(degree: int): Array<byte> {
+			if (degree < 1 || degree > 255)
+				throw new RangeError("Degree out of range");
+			// Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
+			// For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array [255, 8, 93].
+			let result: Array<byte> = [];
+			for (let i = 0; i < degree - 1; i++)
+				result.push(0);
+			result.push(1);  // Start off with the monomial x^0
+			
+			// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
+			// and drop the highest monomial term which is always 1x^degree.
+			// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
+			let root = 1;
+			for (let i = 0; i < degree; i++) {
+				// Multiply the current product by (x - r^i)
+				for (let j = 0; j < result.length; j++) {
+					result[j] = QrCode.reedSolomonMultiply(result[j], root);
+					if (j + 1 < result.length)
+						result[j] ^= result[j + 1];
+				}
+				root = QrCode.reedSolomonMultiply(root, 0x02);
+			}
+			return result;
+		}
+		
+		
+		// Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
+		private static reedSolomonComputeRemainder(data: Readonly<Array<byte>>, divisor: Readonly<Array<byte>>): Array<byte> {
+			let result: Array<byte> = divisor.map(_ => 0);
+			for (const b of data) {  // Polynomial division
+				const factor: byte = b ^ (result.shift() as byte);
+				result.push(0);
+				divisor.forEach((coef, i) =>
+					result[i] ^= QrCode.reedSolomonMultiply(coef, factor));
+			}
+			return result;
+		}
+		
+		
+		// Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
+		// are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
+		private static reedSolomonMultiply(x: byte, y: byte): byte {
+			if (x >>> 8 != 0 || y >>> 8 != 0)
+				throw new RangeError("Byte out of range");
+			// Russian peasant multiplication
+			let z: int = 0;
+			for (let i = 7; i >= 0; i--) {
+				z = (z << 1) ^ ((z >>> 7) * 0x11D);
+				z ^= ((y >>> i) & 1) * x;
+			}
+			assert(z >>> 8 == 0);
+			return z as byte;
+		}
+		
+		
+		// Can only be called immediately after a light run is added, and
+		// returns either 0, 1, or 2. A helper function for getPenaltyScore().
+		private finderPenaltyCountPatterns(runHistory: Readonly<Array<int>>): int {
+			const n: int = runHistory[1];
+			assert(n <= this.size * 3);
+			const core: boolean = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
+			return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)
+			     + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
+		}
+		
+		
+		// Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+		private finderPenaltyTerminateAndCount(currentRunColor: boolean, currentRunLength: int, runHistory: Array<int>): int {
+			if (currentRunColor) {  // Terminate dark run
+				this.finderPenaltyAddHistory(currentRunLength, runHistory);
+				currentRunLength = 0;
+			}
+			currentRunLength += this.size;  // Add light border to final run
+			this.finderPenaltyAddHistory(currentRunLength, runHistory);
+			return this.finderPenaltyCountPatterns(runHistory);
+		}
+		
+		
+		// Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+		private finderPenaltyAddHistory(currentRunLength: int, runHistory: Array<int>): void {
+			if (runHistory[0] == 0)
+				currentRunLength += this.size;  // Add light border to initial run
+			runHistory.pop();
+			runHistory.unshift(currentRunLength);
+		}
+		
+		
+		/*-- Constants and tables --*/
+		
+		// The minimum version number supported in the QR Code Model 2 standard.
+		public static readonly MIN_VERSION: int =  1;
+		// The maximum version number supported in the QR Code Model 2 standard.
+		public static readonly MAX_VERSION: int = 40;
+		
+		// For use in getPenaltyScore(), when evaluating which mask is best.
+		private static readonly PENALTY_N1: int =  3;
+		private static readonly PENALTY_N2: int =  3;
+		private static readonly PENALTY_N3: int = 40;
+		private static readonly PENALTY_N4: int = 10;
+		
+		private static readonly ECC_CODEWORDS_PER_BLOCK: Array<Array<int>> = [
+			// Version: (note that index 0 is for padding, and is set to an illegal value)
+			//0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+			[-1,  7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],  // Low
+			[-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],  // Medium
+			[-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],  // Quartile
+			[-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],  // High
+		];
+		
+		private static readonly NUM_ERROR_CORRECTION_BLOCKS: Array<Array<int>> = [
+			// Version: (note that index 0 is for padding, and is set to an illegal value)
+			//0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+			[-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4,  4,  4,  4,  4,  6,  6,  6,  6,  7,  8,  8,  9,  9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],  // Low
+			[-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5,  5,  8,  9,  9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],  // Medium
+			[-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8,  8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],  // Quartile
+			[-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],  // High
+		];
+		
+	}
+	
+	
+	// Appends the given number of low-order bits of the given value
+	// to the given buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
+	function appendBits(val: int, len: int, bb: Array<bit>): void {
+		if (len < 0 || len > 31 || val >>> len != 0)
+			throw new RangeError("Value out of range");
+		for (let i = len - 1; i >= 0; i--)  // Append bit by bit
+			bb.push((val >>> i) & 1);
+	}
+	
+	
+	// Returns true iff the i'th bit of x is set to 1.
+	function getBit(x: int, i: int): boolean {
+		return ((x >>> i) & 1) != 0;
+	}
+	
+	
+	// Throws an exception if the given condition is false.
+	function assert(cond: boolean): void {
+		if (!cond)
+			throw new Error("Assertion error");
+	}
+	
+	
+	
+	/*---- Data segment class ----*/
+	
+	/* 
+	 * A segment of character/binary/control data in a QR Code symbol.
+	 * Instances of this class are immutable.
+	 * The mid-level way to create a segment is to take the payload data
+	 * and call a static factory function such as QrSegment.makeNumeric().
+	 * The low-level way to create a segment is to custom-make the bit buffer
+	 * and call the QrSegment() constructor with appropriate values.
+	 * This segment class imposes no length restrictions, but QR Codes have restrictions.
+	 * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+	 * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+	 */
+	export class QrSegment {
+		
+		/*-- Static factory functions (mid level) --*/
+		
+		// Returns a segment representing the given binary data encoded in
+		// byte mode. All input byte arrays are acceptable. Any text string
+		// can be converted to UTF-8 bytes and encoded as a byte mode segment.
+		public static makeBytes(data: Readonly<Array<byte>>): QrSegment {
+			let bb: Array<bit> = []
+			for (const b of data)
+				appendBits(b, 8, bb);
+			return new QrSegment(QrSegment.Mode.BYTE, data.length, bb);
+		}
+		
+		
+		// Returns a segment representing the given string of decimal digits encoded in numeric mode.
+		public static makeNumeric(digits: string): QrSegment {
+			if (!QrSegment.isNumeric(digits))
+				throw new RangeError("String contains non-numeric characters");
+			let bb: Array<bit> = []
+			for (let i = 0; i < digits.length; ) {  // Consume up to 3 digits per iteration
+				const n: int = Math.min(digits.length - i, 3);
+				appendBits(parseInt(digits.substr(i, n), 10), n * 3 + 1, bb);
+				i += n;
+			}
+			return new QrSegment(QrSegment.Mode.NUMERIC, digits.length, bb);
+		}
+		
+		
+		// Returns a segment representing the given text string encoded in alphanumeric mode.
+		// The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+		// dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+		public static makeAlphanumeric(text: string): QrSegment {
+			if (!QrSegment.isAlphanumeric(text))
+				throw new RangeError("String contains unencodable characters in alphanumeric mode");
+			let bb: Array<bit> = []
+			let i: int;
+			for (i = 0; i + 2 <= text.length; i += 2) {  // Process groups of 2
+				let temp: int = QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
+				temp += QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+				appendBits(temp, 11, bb);
+			}
+			if (i < text.length)  // 1 character remaining
+				appendBits(QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
+			return new QrSegment(QrSegment.Mode.ALPHANUMERIC, text.length, bb);
+		}
+		
+		
+		// Returns a new mutable list of zero or more segments to represent the given Unicode text string.
+		// The result may use various segment modes and switch modes to optimize the length of the bit stream.
+		public static makeSegments(text: string): Array<QrSegment> {
+			// Select the most efficient segment encoding automatically
+			if (text == "")
+				return [];
+			else if (QrSegment.isNumeric(text))
+				return [QrSegment.makeNumeric(text)];
+			else if (QrSegment.isAlphanumeric(text))
+				return [QrSegment.makeAlphanumeric(text)];
+			else
+				return [QrSegment.makeBytes(QrSegment.toUtf8ByteArray(text))];
+		}
+		
+		
+		// Returns a segment representing an Extended Channel Interpretation
+		// (ECI) designator with the given assignment value.
+		public static makeEci(assignVal: int): QrSegment {
+			let bb: Array<bit> = []
+			if (assignVal < 0)
+				throw new RangeError("ECI assignment value out of range");
+			else if (assignVal < (1 << 7))
+				appendBits(assignVal, 8, bb);
+			else if (assignVal < (1 << 14)) {
+				appendBits(0b10, 2, bb);
+				appendBits(assignVal, 14, bb);
+			} else if (assignVal < 1000000) {
+				appendBits(0b110, 3, bb);
+				appendBits(assignVal, 21, bb);
+			} else
+				throw new RangeError("ECI assignment value out of range");
+			return new QrSegment(QrSegment.Mode.ECI, 0, bb);
+		}
+		
+		
+		// Tests whether the given string can be encoded as a segment in numeric mode.
+		// A string is encodable iff each character is in the range 0 to 9.
+		public static isNumeric(text: string): boolean {
+			return QrSegment.NUMERIC_REGEX.test(text);
+		}
+		
+		
+		// Tests whether the given string can be encoded as a segment in alphanumeric mode.
+		// A string is encodable iff each character is in the following set: 0 to 9, A to Z
+		// (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+		public static isAlphanumeric(text: string): boolean {
+			return QrSegment.ALPHANUMERIC_REGEX.test(text);
+		}
+		
+		
+		/*-- Constructor (low level) and fields --*/
+		
+		// Creates a new QR Code segment with the given attributes and data.
+		// The character count (numChars) must agree with the mode and the bit buffer length,
+		// but the constraint isn't checked. The given bit buffer is cloned and stored.
+		public constructor(
+				// The mode indicator of this segment.
+				public readonly mode: QrSegment.Mode,
+				
+				// The length of this segment's unencoded data. Measured in characters for
+				// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+				// Always zero or positive. Not the same as the data's bit length.
+				public readonly numChars: int,
+				
+				// The data bits of this segment. Accessed through getData().
+				private readonly bitData: Array<bit>) {
+			
+			if (numChars < 0)
+				throw new RangeError("Invalid argument");
+			this.bitData = bitData.slice();  // Make defensive copy
+		}
+		
+		
+		/*-- Methods --*/
+		
+		// Returns a new copy of the data bits of this segment.
+		public getData(): Array<bit> {
+			return this.bitData.slice();  // Make defensive copy
+		}
+		
+		
+		// (Package-private) Calculates and returns the number of bits needed to encode the given segments at
+		// the given version. The result is infinity if a segment has too many characters to fit its length field.
+		public static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number {
+			let result: number = 0;
+			for (const seg of segs) {
+				const ccbits: int = seg.mode.numCharCountBits(version);
+				if (seg.numChars >= (1 << ccbits))
+					return Infinity;  // The segment's length doesn't fit the field's bit width
+				result += 4 + ccbits + seg.bitData.length;
+			}
+			return result;
+		}
+		
+		
+		// Returns a new array of bytes representing the given string encoded in UTF-8.
+		private static toUtf8ByteArray(str: string): Array<byte> {
+			str = encodeURI(str);
+			let result: Array<byte> = [];
+			for (let i = 0; i < str.length; i++) {
+				if (str.charAt(i) != "%")
+					result.push(str.charCodeAt(i));
+				else {
+					result.push(parseInt(str.substr(i + 1, 2), 16));
+					i += 2;
+				}
+			}
+			return result;
+		}
+		
+		
+		/*-- Constants --*/
+		
+		// Describes precisely all strings that are encodable in numeric mode.
+		private static readonly NUMERIC_REGEX: RegExp = /^[0-9]*$/;
+		
+		// Describes precisely all strings that are encodable in alphanumeric mode.
+		private static readonly ALPHANUMERIC_REGEX: RegExp = /^[A-Z0-9 $%*+.\/:-]*$/;
+		
+		// The set of all legal characters in alphanumeric mode,
+		// where each character value maps to the index in the string.
+		private static readonly ALPHANUMERIC_CHARSET: string = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+		
+	}
+	
+}
+
+
+
+/*---- Public helper enumeration ----*/
+
+namespace qrcodegen.QrCode {
+	
+	type int = number;
+	
+	
+	/* 
+	 * The error correction level in a QR Code symbol. Immutable.
+	 */
+	export class Ecc {
+		
+		/*-- Constants --*/
+		
+		public static readonly LOW      = new Ecc(0, 1);  // The QR Code can tolerate about  7% erroneous codewords
+		public static readonly MEDIUM   = new Ecc(1, 0);  // The QR Code can tolerate about 15% erroneous codewords
+		public static readonly QUARTILE = new Ecc(2, 3);  // The QR Code can tolerate about 25% erroneous codewords
+		public static readonly HIGH     = new Ecc(3, 2);  // The QR Code can tolerate about 30% erroneous codewords
+		
+		
+		/*-- Constructor and fields --*/
+		
+		private constructor(
+			// In the range 0 to 3 (unsigned 2-bit integer).
+			public readonly ordinal: int,
+			// (Package-private) In the range 0 to 3 (unsigned 2-bit integer).
+			public readonly formatBits: int) {}
+		
+	}
+}
+
+
+
+/*---- Public helper enumeration ----*/
+
+namespace qrcodegen.QrSegment {
+	
+	type int = number;
+	
+	
+	/* 
+	 * Describes how a segment's data bits are interpreted. Immutable.
+	 */
+	export class Mode {
+		
+		/*-- Constants --*/
+		
+		public static readonly NUMERIC      = new Mode(0x1, [10, 12, 14]);
+		public static readonly ALPHANUMERIC = new Mode(0x2, [ 9, 11, 13]);
+		public static readonly BYTE         = new Mode(0x4, [ 8, 16, 16]);
+		public static readonly KANJI        = new Mode(0x8, [ 8, 10, 12]);
+		public static readonly ECI          = new Mode(0x7, [ 0,  0,  0]);
+		
+		
+		/*-- Constructor and fields --*/
+		
+		private constructor(
+			// The mode indicator bits, which is a uint4 value (range 0 to 15).
+			public readonly modeBits: int,
+			// Number of character count bits for three different version ranges.
+			private readonly numBitsCharCount: [int,int,int]) {}
+		
+		
+		/*-- Method --*/
+		
+		// (Package-private) Returns the bit width of the character count field for a segment in
+		// this mode in a QR Code at the given version number. The result is in the range [0, 16].
+		public numCharCountBits(ver: int): int {
+			return this.numBitsCharCount[Math.floor((ver + 7) / 17)];
+		}
+		
+	}
+}

Telegram/ThirdParty/cld3/.github/workflows/main.yml

@@ -0,0 +1,149 @@
+name: gcld3
+
+on: [push, pull_request]
+
+jobs:
+
+  test:
+    name: ${{ matrix.os }}-${{matrix.python-version}}-test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest,  macos-latest]
+        python-version: [3.6, 3.7, 3.8, pypy3]
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Linux Dependencies
+      if: runner.os == 'Linux'
+      run: sudo apt-get install libprotobuf-dev protobuf-compiler python3-dev
+
+    - name: MacOS Dependencies
+      if: runner.os == 'macOS'
+      run: brew install protobuf
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+
+    - name: Build package
+      run: |
+        pip install setuptools
+        python setup.py install
+
+    - name:  Test with pytest
+      run: |
+        pip install pytest pytest-cov
+        pytest gcld3/tests/gcld3_test.py
+
+
+  sdist:
+      name: Build source distribution
+      runs-on: ubuntu-latest
+      steps:
+        - uses: actions/checkout@v2
+
+        - uses: actions/setup-python@v2
+          name: Install Python
+          with:
+            python-version: "3.8"
+
+        - name: Install dependencies
+          run: |
+            python -m pip install --upgrade pip
+            pip install setuptools wheel
+        - name: Build sdist
+          run: python setup.py sdist
+
+        - uses: actions/upload-artifact@v2
+          with:
+            path: dist/*.tar.gz
+
+  wheel:
+    name: ${{ matrix.os }},${{ matrix.arch }}-wheel
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest,  macos-latest]
+        arch: [auto]
+        include:
+          - os: ubuntu-latest
+            arch: aarch64
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set up QEMU
+      if: ${{ matrix.arch == 'aarch64' }}
+      uses: docker/setup-qemu-action@v1
+
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v2
+      with:
+          python-version: 3.8
+
+    - name: Install cibuildwheel
+      run: |
+          python -m pip install cibuildwheel>=1.5.5 auditwheel delocate
+
+    - name: Build
+      env:
+        CIBW_BUILD: "cp36-* cp38-* pp36-*"
+        CIBW_SKIP: "*-win32 *-manylinux_i686 pp27-* cp27-* cp35-* *-musllinux_aarch64"
+        CIBW_ARCHS: ${{matrix.arch}}
+        CIBW_BEFORE_BUILD_LINUX: yum -y install protobuf-devel protobuf-compiler python3-devel
+        CIBW_REPAIR_WHEEL_COMMAND_LINUX: "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
+        CIBW_BEFORE_BUILD_MACOS: brew install protobuf
+        CIBW_REPAIR_WHEEL_COMMAND_MACOS: "delocate-listdeps {wheel} && delocate-wheel -w {dest_dir} -v {wheel}"
+      run: |
+          python -m cibuildwheel --output-dir wheelhouse
+
+    - uses: actions/upload-artifact@v2
+      with:
+          path: ./wheelhouse/*.whl
+
+
+  pypi:
+    needs: [wheel, sdist]
+    runs-on: ubuntu-latest
+    # upload to PyPI on every tag starting with 'v'
+    if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v')
+    # alternatively, to publish when a GitHub Release is created, use the following rule:
+    # if: github.event_name == 'release' && github.event.action == 'published'
+    steps:
+      - uses: actions/download-artifact@v2
+        with:
+          name: artifact
+          path: dist
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.8'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install twine
+
+      - name: Upload to test pypi
+        env:
+          TWINE_USERNAME: ${{ secrets.TEST_PYPI_USERNAME }}
+          TWINE_PASSWORD: ${{ secrets.TEST_PYPI_PASSWORD }}
+        run: |
+          twine upload --repository-url https://test.pypi.org/legacy/ dist/*
+
+      - name: Upload to pypi
+        env:
+          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+        run: |
+          twine upload dist/*

Telegram/ThirdParty/cld3/.gitignore

@@ -0,0 +1 @@
+build

Telegram/ThirdParty/cld3/CMakeLists.txt

@@ -0,0 +1,69 @@
+# This cmake scripts only builds a static cld3 lib and the unittests.
+
+project(cld3)
+
+# Old versions of cmake dont search/find protobuf lite
+cmake_minimum_required(VERSION 3.9)
+
+find_package(Protobuf REQUIRED)
+message(STATUS "Protobuf_FOUND= ${Protobuf_FOUND}")
+message(STATUS "Protobuf_VERSION= ${Protobuf_VERSION}")
+message(WARNING "Protobuf 2.5 and CLD3 seems happy together. This script does NOT check if your verison of protobuf is compatible.")
+message(STATUS "Protobuf_LIBRARIES= ${Protobuf_LIBRARIES}")
+message(STATUS "Protobuf_LITE_LIBRARIES= ${Protobuf_LITE_LIBRARIES}") # Usually /usr/lib64/libprotobuf-lite.so
+
+# By default, protobuf_generate_cpp generates pb.* files directy in the cmake build dir. 
+# But CLD3 sources have been coded using hard coded pathes to cld_3/protos/*.pb.h. 
+# So *.pb.h must be output to cld_3/protos.
+# For that, let's use a custom my_protobuf_generate_cpp:
+include(${CMAKE_CURRENT_SOURCE_DIR}/misc/myprotobuf.cmake)
+my_protobuf_generate_cpp(cld_3/protos PROTO_SRCS PROTO_HDRS src/feature_extractor.proto src/sentence.proto src/task_spec.proto)
+message(STATUS "PROTO_HDRS= ${PROTO_HDRS}")
+
+add_definitions(-fPIC) # Position Independant Code
+add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
+add_definitions(-std=c++11) # Needed for std::to_string(), ...
+
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${Protobuf_INCLUDE_DIRS}) # needed to include generated pb headers
+
+add_library(${PROJECT_NAME} 
+	${PROTO_SRCS} ${PROTO_HDRS}
+	src/base.cc
+	src/embedding_feature_extractor.cc
+	src/embedding_network.cc
+	src/feature_extractor.cc
+	src/feature_extractor.h
+	src/feature_types.cc
+	src/fml_parser.cc
+	src/language_identifier_features.cc
+	src/lang_id_nn_params.cc 
+	src/nnet_language_identifier.cc
+	src/registry.cc
+	src/relevant_script_feature.cc
+	src/sentence_features.cc
+	src/task_context.cc
+	src/task_context_params.cc
+	src/unicodetext.cc
+	src/utils.cc
+	src/workspace.cc
+	
+	src/script_span/generated_entities.cc
+	src/script_span/getonescriptspan.cc
+	src/script_span/getonescriptspan.h
+	src/script_span/getonescriptspan_test.cc
+	src/script_span/utf8statetable.cc
+	src/script_span/offsetmap.cc
+	src/script_span/text_processing.cc
+	src/script_span/text_processing.h
+	src/script_span/fixunicodevalue.cc
+	)
+
+# unit tests exec:
+add_executable(language_identifier_main src/language_identifier_main.cc)
+target_link_libraries(language_identifier_main cld3 ${Protobuf_LITE_LIBRARIES})
+
+add_executable(getonescriptspan_test src/script_span/getonescriptspan_test.cc)
+target_link_libraries(getonescriptspan_test cld3 ${Protobuf_LITE_LIBRARIES})
+
+add_executable(language_identifier_features_test src/language_identifier_features_test.cc)
+target_link_libraries(language_identifier_features_test cld3 ${Protobuf_LITE_LIBRARIES})

Telegram/ThirdParty/cld3/CONTRIBUTING.md

@@ -0,0 +1,26 @@
+Want to contribute? Great! First, read this page (including the small print at
+the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use Github pull requests for this purpose.
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement](https://cla.developers.google.com/about/google-corporate).